---

expandlib-expandable.h

Go to the documentation of this file.

/* This file is part of Expandlib.

  Copyright (C) 2002 Jasper van de Gronde

  This software is provided 'as-is', without any express or implied
  warranty.  In no event will the authors be held liable for any damages
  arising from the use of this software.

  Permission is granted to anyone to use this software for any purpose,
  including commercial applications, and to alter it and redistribute it
  freely, subject to the following restrictions:

  1. The origin of this software must not be misrepresented; you must not
     claim that you wrote the original software. If you use this software
     in a product, an acknowledgment in the product documentation would be
     appreciated but is not required.
  2. Altered source versions must be plainly marked as such, and must not be
     misrepresented as being the original software.
  3. This notice may not be removed or altered from any source distribution.

  Jasper van de Gronde th.v.d.gronde@hccnet.nl

*/

#ifndef EXPANDLIB_EXPANDABLE_H_INCLUDED
#define EXPANDLIB_EXPANDABLE_H_INCLUDED

#include <iostream>
#include <string>
#include <vector>
#include <map>

#include <tchar.h>

// This is done because all the commands need to know expandable exists (they all hold a pointer to an expandable class)
namespace expander {
    template <
        class StringType = ::std::string            // Used for the expandable string (and the expanded string)
        > class expandable;
}

#include "expandlib-cmd.h"
#include "expandlib-vartype.h"
#include "expandlib-exceptions.h"

// Commands that will be supported
#include "expandlib-cmd-abbr.h"
#include "expandlib-cmd-bpad.h"
#include "expandlib-cmd-btrunc.h"
#include "expandlib-cmd-fpad.h"
#include "expandlib-cmd-ftrunc.h"
#include "expandlib-cmd-if.h"
#include "expandlib-cmd-knownvars.h"
#include "expandlib-cmd-lower.h"
#include "expandlib-cmd-ltrim.h"
#include "expandlib-cmd-numvars.h"
#include "expandlib-cmd-rtrim.h"
#include "expandlib-cmd-trim.h"
#include "expandlib-cmd-unknownvars.h"
#include "expandlib-cmd-upper.h"

// Disables "'this' : used in base member initializer list"
#pragma warning(disable: 4355)


namespace expander { // *** Start of namespace


    template <
        class StringType = ::std::string            // Used for the expandable string (and the expanded string)
        >
    class expandable {
    public:
        typedef ::std::vector<StringType> FParamVectorType; 
        typedef ::std::map<StringType, ::expander::expandvartype<StringType>*> FVarMapType; 
        typedef ::std::map<StringType, ::expander::expandcmd<StringType>*> FCmdMapType; 

    protected:
        const bool InlineExpandErrors;

        const bool InlineGeneralErrors;

        StringType expstr;

        FCmdMapType cmdmap;

        friend class expandcmd<StringType>; 
        friend class expcmd_abbr<StringType>;
        expcmd_abbr<StringType> cmd_abbr;
        friend class expcmd_bpad<StringType>;
        expcmd_bpad<StringType> cmd_bpad;
        friend class expcmd_btrunc<StringType>;
        expcmd_btrunc<StringType> cmd_btrunc;
        friend class expcmd_fpad<StringType>;
        expcmd_fpad<StringType> cmd_fpad;
        friend class expcmd_ftrunc<StringType>;
        expcmd_ftrunc<StringType> cmd_ftrunc;
        friend class expcmd_if<StringType>;
        expcmd_if<StringType> cmd_if;
        friend class expcmd_knownvars<StringType>;
        expcmd_knownvars<StringType> cmd_knownvars;
        friend class expcmd_lower<StringType>;
        expcmd_lower<StringType> cmd_lower;
        friend class expcmd_ltrim<StringType>;
        expcmd_ltrim<StringType> cmd_ltrim;
        friend class expcmd_numvars<StringType>;
        expcmd_numvars<StringType> cmd_numvars;
        friend class expcmd_rtrim<StringType>;
        expcmd_rtrim<StringType> cmd_rtrim;
        friend class expcmd_trim<StringType>;
        expcmd_trim<StringType> cmd_trim;
        friend class expcmd_unknownvars<StringType>;
        expcmd_unknownvars<StringType> cmd_unknownvars;
        friend class expcmd_upper<StringType>;
        expcmd_upper<StringType> cmd_upper;

        bool expand(StringType &dest, const StringType &src, const FVarMapType &vars, ExpandResultsType &results);

        inline const StringType::value_type ConvHexToChar(const StringType &h)
        {
            if ( h.size() != 2 ) throw general_error(_T("ConvHexToChar"),_T("Wrong size!"),h.c_str());

            if ( ( h[0] < _T('0') || h[0] > _T('9') ) && ( h[0] < _T('a') || h[0] > _T('f') ) && ( h[0] < _T('A') || h[0] > _T('F') ) ) throw expand_error(_T("ConvHexToChar"),_T("Not a hexadecimal number!"),h.c_str());
            if ( ( h[1] < _T('0') || h[1] > _T('9') ) && ( h[1] < _T('a') || h[1] > _T('f') ) && ( h[1] < _T('A') || h[1] > _T('F') ) ) throw expand_error(_T("ConvHexToChar"),_T("Not a hexadecimal number!"),h.c_str());

            StringType::value_type ch;

            if ( h[0] > _T('F') ) {         // a-f
                ch=(h[0] - _T('a') + 10)*16;
            } else if ( h[0] > _T('9') ) {  // A-F
                ch=(h[0] - _T('A') + 10)*16;
            } else {                    // 0-9
                ch=(h[0] - _T('0'))*16;
            }

            if ( h[1] > _T('F') ) {         // a-f
                ch+=h[1] - _T('a') + 10;
            } else if ( h[1] > _T('9') ) {  // A-F
                ch+=h[1] - _T('A') + 10;
            } else {                    // 0-9
                ch+=h[1] - _T('0');
            }

            return ch;
        }

    public:
        expandable(const StringType & value = StringType(_T("")), const bool iee=true, const bool ige=false) : cmdmap(), InlineExpandErrors(iee), InlineGeneralErrors(ige),
            cmd_abbr(this),
            cmd_bpad(this),
            cmd_btrunc(this),
            cmd_fpad(this),
            cmd_ftrunc(this),
            cmd_if(this),
            cmd_knownvars(this),
            cmd_lower(this),
            cmd_ltrim(this),
            cmd_numvars(this),
            cmd_rtrim(this),
            cmd_trim(this),
            cmd_unknownvars(this),
            cmd_upper(this),
            expstr(value)
        {
            cmd_abbr.Register();
            cmd_bpad.Register();
            cmd_btrunc.Register();
            cmd_fpad.Register();
            cmd_ftrunc.Register();
            cmd_if.Register();
            cmd_knownvars.Register();
            cmd_lower.Register();
            cmd_ltrim.Register();
            cmd_numvars.Register();
            cmd_rtrim.Register();
            cmd_trim.Register();
            cmd_unknownvars.Register();
            cmd_upper.Register();
        }

        inline bool expandto(StringType &dest, FVarMapType &vars, ExpandResultsType &results) { return expand(dest, expstr, vars, results); }

        inline void set_expstr(const StringType &value) { expstr=value; }

        inline StringType get_expstr() { return expstr; }
    };

    const _TCHAR TwoCharVarDelimiter    = _T('%');      
    const _TCHAR RealVarDelimiter       = _T('$');      
    const _TCHAR CommandDelimiter       = _T('#');      
    const _TCHAR VarnameOpenChar        = _T('{');      
    const _TCHAR VarnameCloseChar       = _T('}');      
    const _TCHAR ParamsOpenChar         = _T('(');      
    const _TCHAR ParamsCloseChar        = _T(')');      
    const _TCHAR ParamsSeperator        = _T(';');      


    template <class StringType> bool expandable<StringType>::expand(StringType &dest, const StringType &src, const FVarMapType &vars, ExpandResultsType &results)
    {
        // NOTE: expand (and any functions called by it) are NOT allowed to delete from rvars (and/or free) elements of rvars they did not create themselves

        // *** All kinds of variable declarations
        enum {
            searching,
            twocharvar,
            realvar,
//          command, // Only commandchk is used
            twocharvarchk,
            realvarchk,
            commandchk,
            commandparams,
            realvarparams,
            realvarafterparams
        } mode=searching;               // Used to keep track of the current "mode"
        enum {
            none,
            backslash
        };                              // Used for quotemode, I couldn't use a named enum as template argument, so I chose this solution

        int level=0;                    // Used for commandparams, to keep track of how deep we are in nested commands (command)
        StringType::const_iterator s_it;// Used for going through the src string

        bool pendingparams;             // Used for variable params, because they can't be escaped immediately

        StringType varname;             // Used for the name of rvars and for hex numbers (twocharvar, realvar)
        StringType cmdname;             // Used to store the name of the command now processing/reading (command)
        StringType param;               // Used to store the value of the param now reading (command)

        FParamVectorType params;        // Used to store read parameters (command)
        //::std::deque<int> quotemode;
        int quotemode=none;             // Used to keep track of the current quote status, originally it was designed to be much more flexible, that is why a deque is (was) used

        StringType * curstring=&dest;   // Used to keep track of the current string to write to, in case something is quoted

        // *** Start of the mainloop (, after some initing)
        //quotemode.push_front(none);

        for(s_it=src.begin(); s_it!=src.end(); ++s_it) {
//          if ( quotemode[0] == backslash ) {
            if ( quotemode == backslash ) {
                // Quoted by a backslash
                //quotemode.pop_front();
                quotemode=none;
                if ( curstring != NULL ) (*curstring)+=*s_it;
            } else if ( *s_it == _T('\\') ) {
                // Encountering a backslash
                //quotemode.push_front(backslash);
                quotemode=backslash;
                if ( curstring != NULL && level>0 ) (*curstring)+=_T('\\'); // This has to do with not removing backslashes from nested #if's (and similar stuff)
            } else {
                // Not quoted
                switch(mode) {


                // Searching mode (inbetween commands, twocharvars and realvars)

                case searching:
                    {
                        switch(*s_it) {
                        case TwoCharVarDelimiter:
                            {
                                mode=twocharvarchk;
                                varname=_T("");
                                curstring=&varname;
                            }
                            break;
                        case RealVarDelimiter:
                            {
                                mode=realvarchk;
                                curstring=NULL;
                            }
                            break;
                        case CommandDelimiter:
                            {
                                mode=commandchk;
                                cmdname=_T("");
                                curstring=&cmdname;
                            }
                            break;
                        default:
                            dest+=*s_it;
                        }
                    }
                    break;


                // Twochar mode

                case twocharvarchk:
                    {
                        mode=twocharvar;
                        varname+=*s_it;
                    }
                    break;
                case twocharvar:
                    {
                        varname+=*s_it;
                        if ( varname.size() >= 2 ) {
                            mode=searching;
                            curstring=&dest;

                            {
                                try {
                                    dest+=ConvHexToChar(varname);
                                } catch(general_error e) {
                                    if ( InlineGeneralErrors ) {
                                        dest+=_T('#');
                                        dest+=e.error_message();
                                        dest+=_T('#');
                                    } else {
                                        throw;
                                    }
                                } catch(expand_error e) {
                                    if ( InlineExpandErrors ) {
                                        dest+=_T('#');
                                        dest+=e.error_message();
                                        dest+=_T('#');
                                    } else {
                                        throw;
                                    }
                                }
                            }
                        }
                    }
                    break;


                // Realvar mode

                case realvarchk:
                    {
                        if ( *s_it == VarnameOpenChar ) {
                            mode=realvar;
                            varname=_T("");
                            curstring=&varname;
                        } else {
                            if ( *s_it == RealVarDelimiter ) {
                                dest+=RealVarDelimiter;
                            } else if ( InlineExpandErrors ) {
                                mode=searching;
                                curstring=&dest;
                                dest+=_T("#Syntax error#");
                            } else {
                                throw expand_error(_T("expandable"),_T("Syntax error!"));
                            }
                        }
                    }
                    break;
                case realvar:
                    {
                        if ( *s_it == VarnameCloseChar ) {
                            mode=searching;
                            curstring=&dest;

                            {
                                const FVarMapType::const_iterator it=vars.find(varname);
                                if ( it!=vars.end() ) {
                                    try {
                                        (*it).second->AppendValue(dest);
                                    } catch(general_error e) {
                                        if ( InlineGeneralErrors ) {
                                            dest+=_T('#');
                                            dest+=e.error_message();
                                            dest+=_T('#');
                                        } else {
                                            throw;
                                        }
                                    } catch(expand_error e) {
                                        if ( InlineExpandErrors ) {
                                            dest+=_T('#');
                                            dest+=e.error_message();
                                            dest+=_T('#');
                                        } else {
                                            throw;
                                        }
                                    }
                                    ++results.FoundVars;
                                } else {
                                    ++results.MissedVars;
                                }
                            }
                        } else if ( *s_it == ParamsOpenChar ) {
                            mode=realvarparams;
                            param=_T("");
                            params.clear();
                            pendingparams=false;
                            curstring=&param;
                        } else {
                            varname+=*s_it;
                        }
                    }
                    break;
                case realvarparams:
                    {
                        if ( level > 0 ) {
                            param+=*s_it;
                            if ( *s_it == CommandDelimiter ) {
                                ++level;
                            } else if ( *s_it == RealVarDelimiter ) {
                                pendingparams=true;
                            } else if ( pendingparams ) {
                                if ( *s_it == ParamsOpenChar ) {
                                    ++level;
                                    pendingparams=false;
                                } else if ( *s_it == VarnameCloseChar ) { // Apparantly there were no parameters with this var
                                    pendingparams=false;
                                }
                            } else if ( *s_it == ParamsCloseChar ) {
                                --level;
                            }
                        } else if ( *s_it == ParamsCloseChar ) {
                            mode=realvarafterparams;
                            curstring=NULL;
                            params.push_back(param);

                            {
                                const FVarMapType::const_iterator it=vars.find(varname);
                                if ( it!=vars.end() ) {
                                    try {
                                        (*it).second->AppendValue(dest, params, vars, results);
                                    } catch(general_error e) {
                                        if ( InlineGeneralErrors ) {
                                            dest+='#';
                                            dest+=e.error_message();
                                            dest+='#';
                                        } else {
                                            throw;
                                        }
                                    } catch(expand_error e) {
                                        if ( InlineExpandErrors ) {
                                            dest+='#';
                                            dest+=e.error_message();
                                            dest+='#';
                                        } else {
                                            throw;
                                        }
                                    }
                                    ++results.FoundVars;
                                } else {
                                    ++results.MissedVars;
                                }
                            }
                        } else if ( *s_it == ParamsSeperator ) {
                            params.push_back(param);
                            param=_T("");
                        } else if ( *s_it == CommandDelimiter ) {
                            ++level;
                            param+=*s_it;
                        } else if ( *s_it == RealVarDelimiter ) {
                            pendingparams=true;
                            param+=*s_it;
                        } else if ( pendingparams ) {
                            param+=*s_it;
                            if ( *s_it == ParamsOpenChar ) {
                                ++level;
                                pendingparams=false;
                            } else if ( *s_it == VarnameCloseChar ) { // Apparantly there were no parameters with this var
                                pendingparams=false;
                            }
                        } else {
                            param+=*s_it;
                        }
                    }
                    break;
                case realvarafterparams:
                    {
                        if ( *s_it == VarnameCloseChar ) {
                            mode=searching;
                            curstring=&dest;
                        }
                    }
                    break;


                // Command mode

                case commandchk:
                    {
                        if ( *s_it == ParamsOpenChar ) {
                            mode=commandparams;
                            param=_T("");
                            params.clear();
                            pendingparams=false;
                            curstring=&param;
                        } else {
                            cmdname+=*s_it;
                        }
                    }
                    break;
/*              case command:
                    {
                        if ( *s_it == ParamsOpenChar ) {
                            mode=commandparams;
                            param="";
                            params.clear();
                            pendingparams=false;
                            curstring=&param;
                        } else {
                            cmdname+=*s_it;
                        }
                    }
                    break;*/
                case commandparams:
                    {
                        if ( level > 0 ) {
                            param+=*s_it;
                            if ( *s_it == CommandDelimiter ) {
                                ++level;
                            } else if ( *s_it == RealVarDelimiter ) {
                                pendingparams=true;
                            } else if ( pendingparams ) {
                                if ( *s_it == ParamsOpenChar ) {
                                    ++level;
                                    pendingparams=false;
                                } else if ( *s_it == VarnameCloseChar ) { // Apparantly there were no parameters with this var
                                    pendingparams=false;
                                }
                            } else if ( *s_it == ParamsCloseChar ) {
                                --level;
                            }
                        } else if ( *s_it == ParamsCloseChar ) {
                            mode=searching;
                            curstring=&dest;
                            params.push_back(param);

                            {
                                const FCmdMapType::const_iterator it=cmdmap.find(cmdname);
                                if ( it != cmdmap.end() ) {
                                    try {
                                        (*((*it).second))(dest, params, vars, results);
                                    } catch(general_error e) {
                                        if ( InlineGeneralErrors ) {
                                            dest+='#';
                                            dest+=e.error_message();
                                            dest+='#';
                                        } else {
                                            throw;
                                        }
                                    } catch(expand_error e) {
                                        if ( InlineExpandErrors ) {
                                            dest+='#';
                                            dest+=e.error_message();
                                            dest+='#';
                                        } else {
                                            throw;
                                        }
                                    }
                                }
                            }
                        } else if ( *s_it == ParamsSeperator ) {
                            params.push_back(param);
                            param=_T("");
                        } else if ( *s_it == CommandDelimiter ) {
                            ++level;    // Should also be pendingparams=true, but it doesn't need to be, so why bother
                            param+=*s_it;
                        } else if ( *s_it == RealVarDelimiter ) {
                            pendingparams=true;
                            param+=*s_it;
                        } else if ( pendingparams ) {
                            param+=*s_it;
                            if ( *s_it == ParamsOpenChar ) {
                                ++level;
                                pendingparams=false;
                            } else if ( *s_it == VarnameCloseChar ) { // Apparantly there were no parameters with this var
                                pendingparams=false;
                            }
                        } else {
                            param+=*s_it;
                        }
                    }
                    break;
                } // End of switch(mode)
            } // End of else (from the quotemode if)
        } // End of main for loop

        if ( mode != searching ) {
            if ( InlineExpandErrors ) {
                dest+=_T("#Unexpected end of string#");
            } else {
                throw expand_error(_T("expandable"),_T("Unexpected end of string!"));
            }
        }

        return true;
    }
} // *** End of namespace

#endif //EXPANDLIB_EXPANDABLE_H_INCLUDED

---