Parser.c

Go to the documentation of this file.

/*******************************************************************************
  APG Version 6.3
  Copyright (C) 2005 - 2012 Lowell D. Thomas, all rights reserved
 
  author:  Lowell D. Thomas
  email:   lowell@coasttocoastresearch.com
  website: http://www.coasttocoastresearch.com
 
  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 2 of the License, or
  (at your option) any later version.
 
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see
  <http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>
  or write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
*******************************************************************************/
#include "Apg.h"
#include "Grammar.h"
#include "Private.h"
 
// error reporting and handling
#undef PASSERT
 
#define PASSERT(cond) if(!(cond)){spCtx->pfnAlertHandler(__LINE__, __FILE__);}
 
// static declarations
static apg_uint uiConvertRules(APG_PARSER_CTX* spCtx, G_RULE* spGRules, apg_uint uiCount);
static apg_uint uiConvertUdts(APG_PARSER_CTX* spCtx, G_UDT* spGUddts, apg_uint uiCount);
static apg_uint uiConvertOpcodes(APG_PARSER_CTX* spCtx, G_OPCODE* spGOpcodes, apg_uint uiCount);
static apg_uint uiRunStartRule(APG_PARSER_CTX* spCtx, apg_uint uiStartRule);
static apg_uint uiValidate(APG_PARSER_CTX* spCtx);
 
// PARSER COMPONENT FUNCTIONS
 
 void* vpParserCtor(void* vpParserInit ,
                     PFN_ALERT pfnAlertHandler
                     ){
        void*                   vpReturn = NULL;
        void*                   vpMemCtx = NULL;
        APG_PARSER_CTX* spCtx = NULL;
        G_HDR*                  spHdr = (G_HDR*)vpParserInit;
        apg_uint                i, uiTest;
        G_UINT*                 g_uipData;
        char*                   cpVersion;
        G_RULE*                 spGRules;
        G_UDT*                  spGUdts;
        G_OPCODE*               spGOpcodes;
 
        // set the alert handler - handles all terminal errors
        if(pfnAlertHandler == NULL){pfnAlertHandler = vDefaultAlertHandler;}
        if(!spHdr){pfnAlertHandler(__LINE__, __FILE__);}
 
        // get the memory context
        vpMemCtx = vpMemCtor();
        if(!vpMemCtx){pfnAlertHandler(__LINE__, __FILE__);}
 
        // validate the alphabet character width
        uiTest = sizeof(apg_achar);
        if(!(uiTest >= spHdr->uiMinSizeofACharMax)){pfnAlertHandler(__LINE__, __FILE__);}
 
        // validate the integer width
        uiTest = sizeof(apg_uint);
        if(!(uiTest >= spHdr->uiMinSizeofUintMax)){pfnAlertHandler(__LINE__, __FILE__);}
 
        // validate the version
        cpVersion = (char*)vpMemAlloc(vpMemCtx, sizeof(char) * spHdr->uiVersionLen);
        if(!cpVersion){pfnAlertHandler(__LINE__, __FILE__);}
        g_uipData = (G_UINT*)spHdr;
        g_uipData += spHdr->uiVersionOffset;
        for(i = 0; i < spHdr->uiVersionLen; i++){cpVersion[i] = (char)g_uipData[i];}
        uiTest = (apg_uint)strcmp(cpVersion, cpApgVersion());
        vMemFree(vpMemCtx, (void*)cpVersion);
        if(!(uiTest == 0)){pfnAlertHandler(__LINE__, __FILE__);}
 
        // allocate a context
        spCtx = (APG_PARSER_CTX*)vpMemAlloc(vpMemCtx, (apg_uint)sizeof(APG_PARSER_CTX));
        if(!spCtx){pfnAlertHandler(__LINE__, __FILE__);}
        memset((void*)spCtx, 0, sizeof(APG_PARSER_CTX));
        spCtx->vpMemCtx = vpMemCtx;
        spCtx->vpValidate = (void*)spCtx;
        spCtx->pfnAlertHandler = pfnAlertHandler;
 
        // string table
        spCtx->cpCharTable = (char*)vpMemAlloc(spCtx->vpMemCtx, sizeof(char) * spHdr->uiCharTableLen);
        PASSERT(spCtx->cpCharTable);
        g_uipData = (G_UINT*)spHdr;
        g_uipData += spHdr->uiCharTableOffset;
        for(i = 0; i < spHdr->uiCharTableLen; i++){
          spCtx->cpCharTable[i] = (char)g_uipData[i];
        }
 
        // achar table
        spCtx->acpACharTable = (apg_achar*)vpMemAlloc(spCtx->vpMemCtx, sizeof(apg_achar) * spHdr->uiACharTableLen);
        PASSERT(spCtx->acpACharTable);
        g_uipData = (G_UINT*)spHdr;
        g_uipData += spHdr->uiACharTableOffset;
        for(i = 0; i < spHdr->uiACharTableLen; i++){
          spCtx->acpACharTable[i] = (apg_achar)g_uipData[i];
        }
 
        // ALT/CAT child list
        spCtx->uipChildList = (apg_uint*)vpMemAlloc(spCtx->vpMemCtx, sizeof(apg_uint) * spHdr->uiChildListLen);
        PASSERT(spCtx->uipChildList);
        g_uipData = (G_UINT*)spHdr;
        g_uipData += spHdr->uiChildListOffset;
        for(i = 0; i < spHdr->uiChildListLen; i++){
          spCtx->uipChildList[i] = (apg_uint)g_uipData[i];
        }
 
        // allocate opcodes
        spCtx->spOpcodes = (APG_OPCODE*)vpMemAlloc(spCtx->vpMemCtx, sizeof(APG_OPCODE) * spHdr->uiOpcodesLen);
        PASSERT(spCtx->spOpcodes);
 
        // convert rules
        spCtx->spRules = (APG_RULE*)vpMemAlloc(spCtx->vpMemCtx, sizeof(APG_RULE) * spHdr->uiRulesLen);
        PASSERT(spCtx->spRules);
        spCtx->uiRuleCount = spHdr->uiRulesLen;
        spGRules = (G_RULE*)((G_UINT*)spHdr + spHdr->uiRulesOffset);
        uiTest = uiConvertRules(spCtx, spGRules, spHdr->uiRulesLen);
        PASSERT(uiTest);
 
        // convert UDTs
        spCtx->spUdts = (APG_UDT*)vpMemAlloc(spCtx->vpMemCtx, sizeof(APG_UDT) * spHdr->uiUdtsLen);
        PASSERT(spCtx->spUdts);
        spCtx->uiUdtCount = spHdr->uiUdtsLen;
        spGUdts = (G_UDT*)((G_UINT*)spHdr + spHdr->uiUdtsOffset);
        uiTest = uiConvertUdts(spCtx, spGUdts, spHdr->uiUdtsLen);
        if(!spCtx->uiUdtCount){spCtx->uiHaveAllUdtCallbacks = APG_TRUE;}
        PASSERT(uiTest);
 
        // convert opcodes
        spGOpcodes = (G_OPCODE*)((G_UINT*)spHdr + spHdr->uiOpcodesOffset);
        uiTest = uiConvertOpcodes(spCtx, spGOpcodes, spHdr->uiOpcodesLen);
        PASSERT(uiTest);
 
        // success
        vpReturn = (void*)spCtx;
        return vpReturn;
}
 
void vParserDtor(void* vpCtx){
        APG_PARSER_CTX* spCtx = (APG_PARSER_CTX*)vpCtx;
        if(uiValidate(spCtx)){
                void* vpMemCtx = spCtx->vpMemCtx;
                memset((void*)spCtx, 0, sizeof(APG_PARSER_CTX));
                vMemDtor(vpMemCtx);
        }
}
 
apg_uint uiParserSyntaxInitCallbacks(void* vpCtx, APG_CALLBACK* spRuleCallbacks, APG_CALLBACK* spUdtCallbacks){
        APG_PARSER_CTX* spCtx = (APG_PARSER_CTX*)vpCtx;
        apg_uint uiIndex;
        APG_RULE* spRules = (APG_RULE*)spCtx->spRules;
        APG_UDT* spUdts = (APG_UDT*)spCtx->spUdts;
        PASSERT(uiValidate(spCtx));
        if(spRuleCallbacks){
                for(uiIndex = 0; uiIndex < spCtx->uiRuleCount; ++uiIndex){spRules[uiIndex].pfnCBSyntax = spRuleCallbacks[uiIndex];}
        } else{
                for(uiIndex = 0; uiIndex < spCtx->uiRuleCount; ++uiIndex){spRules[uiIndex].pfnCBSyntax = NULL;}
        }
        spCtx->uiHaveAllUdtCallbacks = APG_TRUE;
        if(spCtx->uiUdtCount){
                if(spUdtCallbacks){
                        for(uiIndex = 0; uiIndex < spCtx->uiUdtCount; ++uiIndex){
                                if(!spUdtCallbacks[uiIndex]){spCtx->uiHaveAllUdtCallbacks = APG_FALSE;}
                                spUdts[uiIndex].pfnCBSyntax = spUdtCallbacks[uiIndex];
                        }
                } else{spCtx->uiHaveAllUdtCallbacks = APG_FALSE;}
        }
        return spCtx->uiHaveAllUdtCallbacks;
}
 
apg_uint uiParserSyntaxAnalysis(void* vpCtx, apg_uint uiStartRule, const apg_achar* acpSrc, apg_uint uiSrcLen, void* vpData)
{
  apg_uint           uiReturn = APG_FALSE;
  apg_uint           uiState = PRE_PARSE;
  apg_uint           uiPhraseLength;
  APG_PARSER_CTX* spCtx = (APG_PARSER_CTX*)vpCtx;
        PASSERT(uiValidate(spCtx));
  PASSERT(acpSrc);
  PASSERT(uiStartRule < spCtx->uiRuleCount);
  PASSERT(spCtx->uiHaveAllUdtCallbacks);
 
  // set up for this parse
  spCtx->acpInputString = acpSrc;
  spCtx->uiInputStringLen = uiSrcLen;
  spCtx->sCBData.vpCtx = (void*)spCtx;
  spCtx->sCBData.acpSrc = acpSrc;
  spCtx->sCBData.uiSrcLen = uiSrcLen;
  spCtx->sCBData.vpUserData = vpData;
  memset((void*)&spCtx->sState, 0, sizeof(spCtx->sState));
 
  vAstClear(spCtx);
  APG_TRACE(spCtx, NULL, TRACE_ACTION_BEGIN, P_RNM, 0, 0);
 
  // run the start rule
  spCtx->uiStartRule = uiStartRule;
  uiPhraseLength = uiRunStartRule(spCtx, uiStartRule);
  if(uiPhraseLength == APG_UNDEFINED){uiState = NOMATCH;}
  else if(uiPhraseLength == 0){uiState = EMPTY;}
  else{uiState = MATCH;}
 
  // return the parser state
  spCtx->sState.uiStringLength = spCtx->uiInputStringLen;
  spCtx->sState.uiState = uiState;
  spCtx->sState.uiPhraseLength = (uiPhraseLength == APG_UNDEFINED) ? 0: uiPhraseLength;
  spCtx->sState.uiSuccess = ((uiState != NOMATCH) && (spCtx->sState.uiPhraseLength == spCtx->uiInputStringLen)) ? APG_TRUE: APG_FALSE;
 
  APG_TRACE(spCtx, NULL, TRACE_ACTION_END, P_RNM, 0, (spCtx->sState.uiSuccess)?spCtx->uiInputStringLen:APG_UNDEFINED);
 
  // success
  uiReturn = spCtx->sState.uiSuccess;
  return uiReturn;
}
 
// defines AST nodes
void vParserAstInitNodes(void* vpCtx, apg_uint* uipRules, apg_uint* uipUdts){
        APG_PARSER_CTX* spCtx = (APG_PARSER_CTX*)vpCtx;
        APG_AST_CTX* spAstCtx;
        apg_uint i;
        PASSERT(uiValidate(spCtx));
        vAstDtor(spCtx);
        vAstCtor(spCtx);
        spAstCtx = (APG_AST_CTX*)spCtx->vpAstCtx;
        if(uipRules){
                for(i = 0; i < spCtx->uiRuleCount; i++){spAstCtx->uipNodes[i] = uipRules[i];}
        } else{
                for(i = 0; i < spCtx->uiRuleCount; i++){spAstCtx->uipNodes[i] = APG_FALSE;}
        }
        if(spCtx->uiUdtCount){
                if(uipUdts){
                        for(i = 0; i < spCtx->uiUdtCount; i++){spAstCtx->uipNodes[i + spCtx->uiRuleCount] = uipUdts[i];}
                } else{
                        for(i = 0; i < spCtx->uiUdtCount; i++){spAstCtx->uipNodes[i + spCtx->uiRuleCount] = APG_FALSE;}
                }
        }
}
 
// defines AST callbacks
// node records will be generated for non-NULL callbacks whether the nodes are defined true/false or not
void vParserAstInitCallbacks(void* vpCtx, APG_CALLBACK* pfnRuleCallbacks, APG_CALLBACK* pfnUdtCallbacks){
        APG_PARSER_CTX* spCtx = (APG_PARSER_CTX*)vpCtx;
        APG_AST_CTX* spAstCtx;
        apg_uint i;
        PASSERT(uiValidate(spCtx));
        vAstDtor(spCtx);
        vAstCtor(spCtx);
        spAstCtx = (APG_AST_CTX*)spCtx->vpAstCtx;
        APG_CALLBACK pfnTemp;
        if(pfnRuleCallbacks){
                for(i = 0; i < spCtx->uiRuleCount; i++){
                        if(pfnRuleCallbacks[i]){spAstCtx->pfnCallbacks[i] = pfnRuleCallbacks[i];}
                        else{spAstCtx->pfnCallbacks[i] = NULL;}
                        pfnTemp = spAstCtx->pfnCallbacks[i];
                }
        }
        if(spCtx->uiUdtCount && pfnUdtCallbacks){
                for(i = 0; i < spCtx->uiUdtCount; i++){
                        if(pfnUdtCallbacks[i]){spAstCtx->pfnCallbacks[i + spCtx->uiRuleCount] = pfnUdtCallbacks[i];}
                        else{spAstCtx->pfnCallbacks[i + spCtx->uiRuleCount] = NULL;}
                        pfnTemp = spAstCtx->pfnCallbacks[i + spCtx->uiRuleCount];
                }
        }
}
 
//      void vParserAstTraslation(void* vpCtx, void* vpData);
apg_uint        uiParserAstTranslate(void* vpCtx, APG_CALLBACK* pfnRuleCallbacks, APG_CALLBACK* pfnUdtCallbacks, void* vpData){
        apg_uint uiRet = 0;
        APG_PARSER_CTX* spCtx = (APG_PARSER_CTX*)vpCtx;
        PASSERT(uiValidate(spCtx));
        if(spCtx->vpAstCtx){
                spCtx->sCBData.vpUserData = vpData;
                uiRet = uiAstTraverse((APG_AST_CTX*)spCtx->vpAstCtx, pfnRuleCallbacks, pfnUdtCallbacks, &spCtx->sCBData);
        }
        return uiRet;
}
 
apg_uint        uiParserState(void* vpCtx, APG_PARSER_STATE* spState){
        apg_uint uiRet = APG_FALSE;
        APG_PARSER_CTX* spCtx = (APG_PARSER_CTX*)vpCtx;
        PASSERT(uiValidate(spCtx));
        if(spState){
        *spState = spCtx->sState;
        uiRet = spState->uiSuccess;
        }
        return uiRet;
}
 
apg_uint uiParserStatsEnable(void* vpCtx, apg_uint uiEnable){
        apg_uint uiRet = APG_FALSE;
        APG_PARSER_CTX* spCtx = (APG_PARSER_CTX*)vpCtx;
        PASSERT(uiValidate(spCtx));
        if(uiEnable){APG_STATS_ADMIN(spCtx, STATS_ACTION_ENABLE, NULL, 0, &uiRet);}
        else{APG_STATS_ADMIN(spCtx, STATS_ACTION_DISABLE, NULL, 0, &uiRet);}
        return uiRet;
}
 
apg_uint uiParserStatsGet(void* vpCtx, APG_PARSER_STATS* spStats, apg_uint* uipBufferSize){
        apg_uint uiRet = APG_FALSE;
        APG_PARSER_CTX* spCtx = (APG_PARSER_CTX*)vpCtx;
        PASSERT(uiValidate(spCtx));
        APG_STATS_ADMIN(spCtx, STATS_ACTION_GETSTATS, (void*)spStats, uipBufferSize, &uiRet);
        return uiRet;
}
 
apg_uint uiParserTraceEnable(void* vpCtx, apg_uint uiEnable){
        apg_uint uiRet = APG_FALSE;
        APG_PARSER_CTX* spCtx = (APG_PARSER_CTX*)vpCtx;
        PASSERT(uiValidate(spCtx));
        if(uiEnable){APG_TRACE_ADMIN(spCtx, TRACE_ACTION_ENABLE, 0, 0, &uiRet);}
        else{APG_TRACE_ADMIN(spCtx, TRACE_ACTION_DISABLE, 0, 0, &uiRet);}
        return uiRet;
}
 
void vParserTraceOp(void* vpCtx, apg_uint uiOpId, apg_uint uiEnable){
        APG_PARSER_CTX* spCtx = (APG_PARSER_CTX*)vpCtx;
        PASSERT(uiValidate(spCtx));
        APG_TRACE_ADMIN(spCtx, TRACE_ACTION_OP, uiOpId, uiEnable, NULL);
}
 
void vParserTraceRule(void* vpCtx, apg_uint uiIndex, apg_uint uiEnable){
        APG_PARSER_CTX* spCtx = (APG_PARSER_CTX*)vpCtx;
        PASSERT(uiValidate(spCtx));
        APG_TRACE_ADMIN(spCtx, TRACE_ACTION_RULE, uiIndex, uiEnable, NULL);
}
 
void vParserTraceUdt(void* vpCtx, apg_uint uiIndex, apg_uint uiEnable){
        APG_PARSER_CTX* spCtx = (APG_PARSER_CTX*)vpCtx;
        PASSERT(uiValidate(spCtx));
        APG_TRACE_ADMIN(spCtx, TRACE_ACTION_UDT, uiIndex, uiEnable, NULL);
}
 
void vParserTraceRange(void* vpCtx, apg_uint uiBegin, apg_uint uiCount){
        APG_PARSER_CTX* spCtx = (APG_PARSER_CTX*)vpCtx;
        PASSERT(uiValidate(spCtx));
        APG_TRACE_ADMIN(spCtx, TRACE_ACTION_RANGE, uiBegin, uiCount, NULL);
}
 
void vExecuteRule(APG_CBDATA* spData, apg_uint uiId, apg_uint uiOffset){
        APG_PARSER_CTX* spCtx = (APG_PARSER_CTX*)spData->vpCtx;
        APG_OPCODE sOp;
        PASSERT(uiId < spCtx->uiRuleCount);
        PASSERT(uiOffset < spData->uiSrcLen);
 
        // create a dummy RNM opcode
        sOp.pfnOp = uiRNM;
        sOp.sUnion.sRnm.spRule = &spCtx->spRules[uiId];
        sOp.sUnion.sRnm.spNext = sOp.sUnion.sRnm.spRule->spOp;
 
        // execute the start rule
        spData->uiPhraseLength = sOp.pfnOp(spCtx, &sOp, uiOffset);
}
 
void vExecuteUdt(APG_CBDATA* spData, apg_uint uiId, apg_uint uiOffset){
        APG_PARSER_CTX* spCtx = (APG_PARSER_CTX*)spData->vpCtx;
        APG_OPCODE sOp;
        PASSERT(uiId < spCtx->uiUdtCount);
        PASSERT(uiOffset < spData->uiSrcLen);
 
        // create a dummy UDT opcode
        sOp.pfnOp = uiUDT;
        sOp.sUnion.sUdt.spUdt = &spCtx->spUdts[uiId];
        sOp.sUnion.sUdt.uiEmpty = spCtx->spUdts[uiId].uiEmpty;
 
        // execute the start rule
        spData->uiPhraseLength = sOp.pfnOp(spCtx, &sOp, uiOffset);
}
 
// STATIC HELPER FUNCTIONS
static apg_uint uiConvertRules(APG_PARSER_CTX* spCtx, G_RULE* spGRules, apg_uint uiCount){
        apg_uint uiReturn = APG_FALSE;
        G_RULE* spGRule = spGRules;
        APG_RULE* spRule = spCtx->spRules;
        APG_RULE* spRuleEnd = spRule + uiCount;
        apg_uint uiIndex = 0;
        for(; spRule < spRuleEnd; spRule++, spGRule++, uiIndex++){
                spRule->cpRuleName = spCtx->cpCharTable + spGRule->uiNameOffset;
                spRule->pfnCBSyntax = NULL;
                spRule->spOp = spCtx->spOpcodes + spGRule->uiChildOffset;
                spRule->uiOpcodeCount = (apg_uint)spGRule->uiChildCount;
                spRule->uiRuleIndex = uiIndex;
        }
        uiReturn = APG_TRUE;
        return uiReturn;
}
 
static apg_uint uiConvertUdts(APG_PARSER_CTX* spCtx, G_UDT* spGUdts, apg_uint uiCount){
        apg_uint uiReturn = APG_FALSE;
        G_UDT* spGUdt = spGUdts;
        APG_UDT* spUdt = spCtx->spUdts;
        APG_UDT* spUdtEnd = spUdt + uiCount;
        apg_uint uiIndex = 0;
        for(; spUdt < spUdtEnd; spUdt++, spGUdt++, uiIndex++){
                spUdt->cpUdtName = spCtx->cpCharTable + spGUdt->uiNameOffset;
                spUdt->pfnCBSyntax = NULL;
                spUdt->uiEmpty = (apg_uint)spGUdt->uiEmpty;
                spUdt->uiUdtIndex = uiIndex;
        }
        uiReturn = APG_TRUE;
        return uiReturn;
}
 
static apg_uint uiConvertOpcodes(APG_PARSER_CTX* spCtx, G_OPCODE* spGOpcodes, apg_uint uiCount){
        apg_uint uiReturn = APG_FALSE;
        G_OPCODE* spGOp = spGOpcodes;
        APG_OPCODE* spOp = spCtx->spOpcodes;
        APG_OPCODE* spOpEnd = spCtx->spOpcodes + uiCount;
        for(; spOp < spOpEnd; spOp++, spGOp++){
//              switch(spGOp->sOpType.sRnm.uiType){
                switch(spGOp->uiType){
                case G_TYPE_RNM:
                {
                        G_RNMOP* spG = &spGOp->sOpType.sRnm;
                        APG_OP_RNM* spP = &spOp->sUnion.sRnm;
                        spOp->pfnOp = uiRNM;
                        spP->spRule = spCtx->spRules + spG->uiRuleIndex;
                        spP->spNext = spP->spRule->spOp;
                        spOp->cpName = "G_TYPE_RNM";
                }
                        break;
                case G_TYPE_UDT:
                {
                        G_UDTOP* spG = &spGOp->sOpType.sUdt;
                        APG_OP_UDT* spP = &spOp->sUnion.sUdt;
                        spOp->pfnOp = uiUDT;
                        spP->spUdt = spCtx->spUdts + spG->uiUdtIndex;
                        spP->uiEmpty = (apg_uint)spG->uiEmpty;
 
                        spOp->cpName = "G_TYPE_UDT";
                }
                        break;
                case G_TYPE_REP:
                {
                        G_REPOP* spG = &spGOp->sOpType.sRep;
                        APG_OP_REP* spP = &spOp->sUnion.sRep;
                        spOp->pfnOp = uiREP;
                        spP->spNext = spCtx->spOpcodes + spG->uiChildOffset;
                        spP->uiMin = (apg_uint)spG->uiMin;
                        spP->uiMax = (apg_uint)spG->uiMax;
                        spOp->cpName = "G_TYPE_REP";
                }
                        break;
                case G_TYPE_ALT:
                {
                        G_ALTOP* spG = &spGOp->sOpType.sAlt;
                        APG_OP_ALT* spP = &spOp->sUnion.sAlt;
                        spOp->pfnOp = uiALT;
                        spP->uipChildList = (apg_uint*)(spCtx->uipChildList + spG->uiChildListOffset);
                        spP->uiChildCount = (apg_uint)spG->uiChildCount;
                        spOp->cpName = "G_TYPE_ALT";
                }
                        break;
                case G_TYPE_CAT:
                {
                        G_CATOP* spG = &spGOp->sOpType.sCat;
                        APG_OP_CAT* spP = &spOp->sUnion.sCat;
                        spOp->pfnOp = uiCAT;
                        spP->uipChildList = (apg_uint*)(spCtx->uipChildList + spG->uiChildListOffset);
                        spP->uiChildCount = (apg_uint)spG->uiChildCount;
                        spOp->cpName = "G_TYPE_CAT";
                }
                        break;
                case G_TYPE_AND:
                {
                        G_ANDOP* spG = &spGOp->sOpType.sAnd;
                        APG_OP_AND* spP = &spOp->sUnion.sAnd;
                        spOp->pfnOp = uiAND;
                        spP->spNext = spCtx->spOpcodes + spG->uiChildOffset;
                        spOp->cpName = "G_TYPE_AND";
                }
                        break;
                case G_TYPE_NOT:
                {
                        G_NOTOP* spG = &spGOp->sOpType.sNot;
                        APG_OP_NOT* spP = &spOp->sUnion.sNot;
                        spOp->pfnOp = uiNOT;
                        spP->spNext = spCtx->spOpcodes + spG->uiChildOffset;
                        spOp->cpName = "G_TYPE_NOT";
                }
                        break;
                case G_TYPE_TRG:
                {
                        G_TRGOP* spG = &spGOp->sOpType.sTrg;
                        APG_OP_TRG* spP = &spOp->sUnion.sTrg;
                        spOp->pfnOp = uiTRG;
                        spP->acMin = (apg_achar)spG->uiMin;
                        spP->acMax = (apg_achar)spG->uiMax;
                        spOp->cpName = "G_TYPE_TRG";
                }
                        break;
                case G_TYPE_TBS:
                {
                        G_TBSOP* spG = &spGOp->sOpType.sTbs;
                        APG_OP_TBS* spP = &spOp->sUnion.sTbs;
                        spOp->pfnOp = uiTBS;
                        spP->acpStrTbl= spCtx->acpACharTable + spG->uiOffset;
                        spP->uiStrLen = (apg_uint)spG->uiLen;
                        spOp->cpName = "G_TYPE_TBS";
                }
                        break;
                case G_TYPE_TLS:
                {
                        apg_achar* acpBeg;
                        apg_achar* acpEnd;
                        G_TLSOP* spG = &spGOp->sOpType.sTls;
                        APG_OP_TLS* spP = &spOp->sUnion.sTls;
                        spOp->pfnOp = uiTLS;
                        spP->acpStrTbl = spCtx->acpACharTable + spG->uiOffset;
                        spP->uiStrLen = spG->uiLen;
                        acpBeg = spP->acpStrTbl;
                        acpEnd = acpBeg + spP->uiStrLen;
                        for(; acpBeg < acpEnd; acpBeg++){ // convert string to lower
                                if(*acpBeg >= (apg_achar)65 && *acpBeg <= (apg_achar)90){*acpBeg += (apg_achar)32;}
                        }
                        spOp->cpName = "G_TYPE_TLS";
                }
                        break;
                default:
                        PASSERT(APG_FALSE);
                        break;
                }
        }
        uiReturn = APG_TRUE;
        return uiReturn;
}
 
static apg_uint uiRunStartRule(APG_PARSER_CTX* spCtx, apg_uint uiStartRule){
        apg_uint uiRet;
  APG_OPCODE sOp;
  PASSERT(uiStartRule < spCtx->uiRuleCount);
  PASSERT(spCtx);
 
  // create a dummy RNM opcode
  sOp.pfnOp = uiRNM;
  sOp.sUnion.sRnm.spRule = &spCtx->spRules[uiStartRule];
  sOp.sUnion.sRnm.spNext = sOp.sUnion.sRnm.spRule->spOp;
 
  // execute the start rule
  uiRet = sOp.pfnOp(spCtx, &sOp, 0);
  return uiRet;
}
 
static apg_uint uiValidate(APG_PARSER_CTX* spCtx){
        return (spCtx && spCtx->vpValidate == (void*)spCtx);
}