docs/doc7.0/apg_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 APG_H_7_0_

#define APG_H_7_0_


 #include <inttypes.h>


#define APG_VERSION "7.0"

#define APG_COPYRIGHT "Copyright (c) 2021 Lowell D. Thomas, all rights reserved"

#define APG_LICENSE "BSD 2-Clause"


#if defined APG_AINT && APG_AINT == 8

typedef uint8_t aint;

#elif defined APG_AINT && APG_AINT == 16

typedef uint16_t aint;

#elif defined APG_AINT && APG_AINT == 32

typedef uint32_t aint;

#elif defined APG_AINT && APG_AINT == 64

typedef uint64_t aint;

#else

typedef uint_fast32_t aint;

#endif


#if defined APG_ACHAR && APG_ACHAR == 8

typedef uint8_t achar;

#elif defined APG_ACHAR && APG_ACHAR == 16

typedef uint16_t achar;

#elif defined APG_ACHAR && APG_ACHAR == 32

typedef uint32_t achar;

#elif defined APG_ACHAR && APG_ACHAR == 64

typedef uint64_t achar;

#else

typedef uint_fast8_t achar;

#endif


typedef uintmax_t luint;


typedef uint8_t abool;


#ifdef APG_DEBUG

#define APG_MEM_STATS 1

#define APG_VEC_STATS 1

#define APG_STATS 1

#define APG_TRACE 1

#define APG_AST 1

#define APG_BKR 1

#endif /* APG_DEBUG */


#ifdef APG_TRACE

#define TRACE_DOWN(x, o, f) if((x))vTraceDown((x), (o), (f))

#define TRACE_UP(x, o, s, f, p) if((x))vTraceUp((x), (o), (s), (f), (p));

#define TRACE_BEGIN(x) if((x))vTraceBegin((x))

#define TRACE_END(x) if((x))vTraceEnd((x))

#define TRACE_DTOR(x) if((x))vTraceDtor((x))

#else

#define TRACE_DOWN(x, o, f)

#define TRACE_UP(x, o, s, f, p)

#define TRACE_BEGIN(x)

#define TRACE_END(x)

#define TRACE_DTOR(v)

#endif /* APG_TRACE */


#ifdef APG_STATS

#define STATS_HIT(x, o, s) if((x))vStatsHit((x), (o), (s))

#else

#define STATS_HIT(x, o, s)

#endif /* APG_STATS */


// ABNF strict implies that no super set expressions are present in the grammar */

#ifdef APG_STRICT_ABNF

#undef APG_BKR

#endif /* APG_STRICT_ABNF */


#ifdef APG_BKR

#define BKR_APGEX_CHECK(e)

#define BKRU_CTOR(x) vpBkruCtor((x))

#define BKRU_RULE_OPEN(x, i) if((x)) vBkruRuleOpen((x), (i))

#define BKRU_RULE_CLOSE(x, i, s, o, p) if((x)) vBkruRuleClose((x), (i), (s), (o), (p))

#define BKRU_UDT_CLOSE(x, i, s, o, p) if((x)) vBkruUdtClose((x), (i), (s), (o), (p))

#define BKRU_OP_OPEN(x) if((x)) vBkruOpOpen((x))

#define BKRU_OP_CLOSE(x, s) if((x)) vBkruOpClose((x), (s))

#define BKRP_CTOR(x) vpBkrpCtor((x))

#define BKRP_RULE_OPEN(x, i) if((x)) vBkrpRuleOpen((x), (i))

#define BKRP_RULE_CLOSE(x, i, s, o, p) if((x)) vBkrpRuleClose((x), (i), (s), (o), (p))

#define BKRP_UDT_CLOSE(x, i, s, o, p) if((x)) vBkrpUdtClose((x), (i), (s), (o), (p))

#define BKRP_OP_OPEN(x) if((x)) vBkrpOpOpen((x))

#define BKRP_OP_CLOSE(x, s) if((x)) vBkrpOpClose((x), (s))

#else

#define BKR_APGEX_CHECK(e) vApgexBkrCheck((e))

#define BKRU_CTOR(x) NULL

#define BKRU_RULE_OPEN(x, i)

#define BKRU_RULE_CLOSE(x, i, s, o, p)

#define BKRU_UDT_CLOSE(x, i, s, o, p)

#define BKRU_OP_OPEN(x)

#define BKRU_OP_CLOSE(x, s)

#define BKRP_CTOR(x) NULL

#define BKRP_RULE_OPEN(x, i)

#define BKRP_RULE_CLOSE(x, i, s, o, p)

#define BKRP_UDT_CLOSE(x, i, s, o, p)

#define BKRP_OP_OPEN(x)

#define BKRP_OP_CLOSE(x, s)

#endif /* APG_BKR */


#ifdef APG_AST

#define AST_CLEAR(v) if(v)vAstClear(v)

#define AST_RULE_OPEN(x, l, i, o) if((x) && !(l)) vAstRuleOpen((x), (i), (o))

#define AST_RULE_CLOSE(x, l, i, s, o, p) if((x) && !(l))  vAstRuleClose((x), (i), (s), (o), (p))

#define AST_OP_OPEN(x, l) if((x)) if((x) && !(l)) vAstOpOpen((x))

#define AST_OP_CLOSE(x, l, s) if((x) && !(l))  vAstOpClose((x), (s))

#else

#define AST_CLEAR(v)

#define AST_RULE_OPEN(x, l, i, o)

#define AST_RULE_CLOSE(x, l, i, s, o, p)

#define AST_OP_OPEN(x, l)

#define AST_OP_CLOSE(x, l, s)

#endif /* APG_AST */


#ifdef APG_NO_PPPT

#define PPPT_OPEN(x, o, f)

#define PPPT_CLOSE

#define PPPT_DEFINED 0

#else

#define PPPT_OPEN(x, o, f) if(bPpptEval((x), (o), (f))) goto done

#define PPPT_CLOSE done:

#define PPPT_DEFINED 1

#endif /* APG_NO_PPPT */


#undef APG_TRUE

#undef APG_FALSE

#define APG_TRUE       1

#define APG_FALSE      0


#undef APG_SUCCESS

#undef APG_FAULURE

#define APG_SUCCESS 1

#define APG_FAILURE 0


#undef APG_UNDEFINED

#define APG_UNDEFINED ((aint)-1)

#undef APG_INFINITE

#define APG_INFINITE  ((aint)-1)


#undef APG_MAX_AINT


#define APG_MAX_AINT  ((aint)-2)

#undef APG_MAX_ACHAR

#define APG_MAX_ACHAR  ((achar)-1)


#endif /* APG_H_7_0_ */