docs/doc7.0/parserp_8h_source.html

/*  *************************************************************************************

    Copyright (c) 2021, Lowell D. Thomas

    All rights reserved.


    This file is part of APG Version 7.0.

    APG Version 7.0 may be used under the terms of the BSD 2-Clause License.


    Redistribution and use in source and binary forms, with or without

    modification, are permitted provided that the following conditions are met:


    1. Redistributions of source code must retain the above copyright notice, this

       list of conditions and the following disclaimer.


    2. Redistributions in binary form must reproduce the above copyright notice,

       this list of conditions and the following disclaimer in the documentation

       and/or other materials provided with the distribution.


    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE

    FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

    DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

    OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


*   *************************************************************************************/

#ifndef LIB_PARSERP_H_

#define LIB_PARSERP_H_


typedef struct  {

    uint32_t uiSizeofAchar;

    uint32_t uiSizeofUint;

    uint32_t uiStringTableLength;

    uint32_t uiAcharTableLength;

    uint32_t uiPpptTableLength;

    uint32_t uiParserInitLength;

    const char* cpStringTable;

    const uint8_t* ucpPpptTable;

    const void* vpAcharTable;

    const void* vpParserInit;

} parser_init;


typedef struct  {

    luint uiSizeInInts;

    luint uiAcharMin;

    luint uiAcharMax;

    luint uiSizeofAchar;

    luint uiUintMax;

    luint uiSizeofUint;

    luint uiRuleCount;

    luint uiUdtCount;

    luint uiOpcodeCount;

    luint uiMapCount;

    luint uiMapSize;

    luint uiVersionOffset;

    luint uiCopyrightOffset;

    luint uiLicenseOffset;

    luint uiChildListOffset;

    luint uiChildListLength;

    luint uiRulesOffset;

    luint uiRulesLength;

    luint uiUdtsOffset;

    luint uiUdtsLength;

    luint uiOpcodesOffset;

    luint uiOpcodesLength;

} init_hdr;


// runtime opcodes

struct parser_tag;

union opcode_tag;

typedef void (*pfn_op)(struct parser_tag* spCtx, const union opcode_tag* spOp);


typedef struct  {

    const char* cpRuleName;

    const uint8_t* ucpPpptMap;

    const union opcode_tag* spOp;

    aint uiOpcodeCount;

    parser_callback pfnCallback;

    aint uiEmpty;

    aint uiRuleIndex;

} rule;


typedef struct  {

    const char* cpUdtName;

    parser_callback pfnCallback;

    aint uiEmpty;

    aint uiUdtIndex;

} udt;


// opcodes

typedef struct  {

    aint uiId;

    const uint8_t* ucpPpptMap;

    const aint* uipChildList;

    aint uiChildCount;

} op_alt;


typedef struct  {

    aint uiId;

    const uint8_t* ucpPpptMap;

    const aint* uipChildList;

    aint uiChildCount;

} op_cat;


typedef struct  {

    aint uiId;

    const uint8_t* ucpPpptMap;

    aint uiMin;

    aint uiMax;

} op_rep;


typedef struct  {

    aint uiId;

    const uint8_t* ucpPpptMap;

    rule* spRule;

}op_rnm;


typedef struct  {

    aint uiId;

    const uint8_t* ucpPpptMap;

    achar acMin;

    achar acMax;

} op_trg;


typedef struct  {

    aint uiId;

    const uint8_t* ucpPpptMap;

    const achar* acpStrTbl;

    aint uiStrLen;

} op_tls;


typedef struct  {

    aint uiId;

    const uint8_t* ucpPpptMap;

    const achar* acpStrTbl;

    aint uiStrLen;

} op_tbs;


typedef struct  {

    aint uiId;

    const uint8_t* ucpPpptMap;

    udt* spUdt;

    aint uiEmpty;

} op_udt;


typedef struct  {

    aint uiId;

    const uint8_t* ucpPpptMap;

} op_and;


typedef struct  {

    aint uiId;

    const uint8_t* ucpPpptMap;

} op_not;


typedef struct  {

    aint uiId;

    const uint8_t* ucpPpptMap;

    aint uiRuleIndex;

    aint uiCase;

    aint uiMode;

} op_bkr;


typedef struct  {

    aint uiId;

    const uint8_t* ucpPpptMap;

} op_bka;


typedef struct  {

    aint uiId;

    const uint8_t* ucpPpptMap;

} op_bkn;


typedef struct  {

    aint uiId;

    const uint8_t* ucpPpptMap;

} op_abg;


typedef struct  {

    aint uiId;

    const uint8_t* ucpPpptMap;

} op_aen;

typedef struct  {

    aint uiId;

    const uint8_t* ucpPpptMap;

} op_gen;


typedef union opcode_tag {

    op_gen sGen;

    op_alt sAlt;

    op_cat sCat;

    op_rep sRep;

    op_rnm sRnm;

    op_trg sTrg;

    op_tbs sTbs;

    op_tls sTls;

    op_udt sUdt;

    op_and sAnd;

    op_not sNot;

    op_bkr sBkr;

    op_bka sBka;

    op_bkn sBkn;

    op_abg sAbg;

    op_aen sAen;

} opcode;


// parser context

typedef struct parser_tag {

    // basic objects

    const void* vpValidate;

    exception* spException;

    void* vpMem;

    void* vpAst;

    void* vpTrace;

    void* vpStats;

    void* vpBkru;

    void* vpBkrp;

    pfn_op* pfnOpFunc;

    // grammar data

    const char* cpStringTable;

    const achar* acpAcharTable;

    const aint* uipChildList;

    rule* spRules;

    udt* spUdts;

    opcode* spOpcodes;

    aint uiRuleCount;

    aint uiUdtCount;

    aint uiOpcodeCount;

    // input data

    aint uiStartRule;

    void* vpVecInputString;

    const achar* acpInputString;

    aint uiInputStringLength;

    aint uiSubStringBeg;

    aint uiSubStringEnd;

    aint uiSubStringLength;

    // look around management

    aint uiLookBehindLength;

    aint uiInLookaround;

    // PPPT

    const uint8_t* ucpMaps;

    aint uiMapSize;

    aint uiMapCount;

    achar acAcharMin;

    achar acAcharMax;

    // parsing control

    aint uiOffset;

    aint uiPhraseLength;

    aint uiOpState;

    opcode sStartOp;

    callback_data sCBData;

    aint uiTreeDepth;

    // parsing state

    parser_state sState;

} parser;


void* vpParserAllocCtor(exception* spException, void* vpParserInit, abool bAllocateTables);

aint uiGetAcharTable(parser_init* spHdr, achar* acpAcharTable);

abool bGetParserInitData(parser_init* spHdr, luint* luipParserInit);

void vGetChildListTable(init_hdr* spHdr, aint* uipList);

void vTranslateRules(parser* spCtx, rule* spRules, opcode* spOpcodes, luint* luipData);

void vTranslateUdts(parser* spCtx, udt* spUdts, luint* luipData);

void vTranslateOpcodes(parser* spCtx, rule* spRules, udt* spUdts, opcode* spOpcodes, luint* luipData);

uint8_t ucGetMapVal(const uint8_t* ucpMap, luint luiOffset, luint luiChar);


#ifndef APG_NO_PPPT

void vDisplayMap();

abool bPpptEval(parser* spCtx, const opcode* spOp, aint uiOffset);

aint uiPpptState(parser* spCtx, const opcode* spOp, aint uiOffset);

#endif /* APG_NO_PPPT */


#endif /* LIB_PARSERP_H_ */