fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
a894400a85bf4fa89419f5fef21492e93cf17b92
harbour-core/harbour/include/hbcompdf.h
Viktor Szakats a894400a85 2010-01-18 16:34 UTC+0100 Viktor Szakats (harbour.01 syenar.hu) 
* include/hbcompdf.h
  * src/compiler/cmdcheck.c
  * src/compiler/hbmain.c
  * src/compiler/hbcomp.c
  * src/compiler/hbopt.c
  * src/compiler/hbusage.c
  * src/compiler/hbgenerr.c
    + Added options to control error/warning output format/style
      in Harbour, to make it possible to switch to formats which
      are handled by popular IDEs, like Eclipse, Code::Blocks.
      Currently these are supported:
        -ge[0]: Clipper compatible (default)
        -ge1:   "IDE friendly". Mimics the one submitted by Lorenzo
                for Eclipse.
      The goal is to cover the most IDEs with the less options,
      so please test them to reach this optimum.
2010-01-18 15:36:56 +00:00

772 lines
28 KiB
C
Raw Blame History

/*
* $Id$
*/
/*
* Harbour Project source code:
* definitions shared by compiler and macro compiler
*
* Copyright 2006 Przemyslaw Czerpak <druzus / at / priv.onet.pl>
* www - http://www.harbour-project.org
*
* 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, 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 software; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/).
*
* As a special exception, the Harbour Project gives permission for
* additional uses of the text contained in its release of Harbour.
*
* The exception is that, if you link the Harbour libraries with other
* files to produce an executable, this does not by itself cause the
* resulting executable to be covered by the GNU General Public License.
* Your use of that executable is in no way restricted on account of
* linking the Harbour library code into it.
*
* This exception does not however invalidate any other reasons why
* the executable file might be covered by the GNU General Public License.
*
* This exception applies only to the code released by the Harbour
* Project under the name Harbour. If you copy code from other
* Harbour Project or Free Software Foundation releases into a copy of
* Harbour, as the General Public License permits, the exception does
* not apply to the code that you add in this way. To avoid misleading
* anyone as to the status of such modified files, you must delete
* this exception notice from them.
*
* If you write modifications of your own for Harbour, it is your choice
* whether to permit this exception to apply to your modifications.
* If you do not wish that, delete this exception notice.
*
*/
#ifndef HB_COMPDF_H_
#define HB_COMPDF_H_
#include "hbapi.h"
#include "hbpp.h"
#include "hbhash.h"
HB_EXTERN_BEGIN
/* compiler related declarations */
/* Output types */
typedef enum
{
HB_LANG_C, /* C language (by default) <file.c> */
HB_LANG_OBJ32, /* DOS/Windows 32 bits <file.obj> */
HB_LANG_PORT_OBJ, /* Portable objects <file.hrb> */
HB_LANG_PORT_OBJ_BUF /* Portable objects in memory buffer */
} HB_LANGUAGES; /* supported Harbour output languages */
/* Error message format modes */
typedef enum
{
HB_ERRORFMT_CLIPPER,
HB_ERRORFMT_IDE
} HB_ERRORFMT;
struct _COMCLASS; /* forward declaration */
/* Declared Function/Method support structure */
typedef struct _COMDECLARED
{
const char * szName; /* the name of the symbol */
BYTE cType;
USHORT iParamCount;
BYTE * cParamTypes;
struct _COMCLASS * pClass;
struct _COMCLASS * ( * pParamClasses );
struct _COMDECLARED * pNext; /* pointer to the next declared function */
} COMDECLARED, * PCOMDECLARED;
/* Declared Class support structure */
typedef struct _COMCLASS
{
const char * szName;
PCOMDECLARED pMethod;
PCOMDECLARED pLastMethod;
struct _COMCLASS * pNext;
} COMCLASS, * PCOMCLASS;
/* locals, static, public variables support */
typedef struct _VAR
{
const char * szName; /* variable name */
const char * szAlias; /* variable alias namespace */
int iUsed; /* number of times used */
int iDeclLine; /* declaration line number */
USHORT uiFlags; /* optional falgs, f.e. THREAD STATIC */
BYTE cType; /* optional strong typing */
PCOMCLASS pClass;
struct _VAR * pNext; /* pointer to next defined variable */
} VAR, * PVAR;
/* local variables declared in a codeblock */
typedef struct HB_CBVAR_
{
const char * szName;
BYTE bType;
HB_BOOL bUsed;
struct HB_CBVAR_ * pNext;
} HB_CBVAR, * HB_CBVAR_PTR;
typedef struct _HB_VARTYPE
{
struct _HB_VARTYPE * pNext;
char cVarType;
const char * szFromClass;
} HB_VARTYPE, * PHB_VARTYPE;
/* value types seen at language level
*/
#define HB_EV_UNKNOWN 0x0000
#define HB_EV_NIL 0x0001
#define HB_EV_NUMERIC 0x0002
#define HB_EV_STRING 0x0004
#define HB_EV_CODEBLOCK 0x0008
#define HB_EV_LOGICAL 0x0010
#define HB_EV_OBJECT 0x0020
#define HB_EV_ARRAY 0x0040
#define HB_EV_SYMBOL 0x0080
#define HB_EV_VARREF 0x0100
#define HB_EV_FUNREF 0x0200
#define HB_EV_DATE 0x0400
#define HB_EV_TIMESTAMP 0x0800
#define HB_EV_HASH 0x1000
/* messages sent to expressions
*/
typedef enum
{
HB_EA_REDUCE = 0, /* reduce the expression into optimized one */
HB_EA_ARRAY_AT, /* check if the expession can be used as array */
HB_EA_ARRAY_INDEX, /* check if the expession can be used as index */
HB_EA_LVALUE, /* check if the expression can be used as lvalue (left side of an assigment) */
HB_EA_PUSH_PCODE, /* generate the pcodes to push the value of expression */
HB_EA_POP_PCODE, /* generate the pcodes to pop the value of expression */
HB_EA_PUSH_POP, /* generate the pcodes to push and pop the expression */
HB_EA_STATEMENT, /* generate the pcodes for a statement */
HB_EA_DELETE /* delete components of the expression */
} HB_EXPR_MESSAGE;
/* additional definitions used to distinguish numeric expressions
*/
#define HB_ET_LONG 1
#define HB_ET_DOUBLE 2
/* additional definitions used to distinguish macro expressions
*/
#define HB_ET_MACRO_VAR 0 /* &variable */
#define HB_ET_MACRO_SYMBOL 1 /* &fimcall() */
#define HB_ET_MACRO_ALIASED 2 /* &alias->&variable */
#define HB_ET_MACRO_EXPR 4 /* &( expr ) */
#define HB_ET_MACRO_LIST 16 /* &variable used as in literal arrays or function call argument. */
#define HB_ET_MACRO_PARE 32 /* &variable used as parentesised expressions. */
#define HB_ET_MACRO_REFER 64 /* &macro used in @ (pass by reference) */
#define HB_ET_MACRO_ASSIGN 128 /* o:&msgname := value */
/* types of expressions
* NOTE: the order of these definition is important - change it carefully
* All types <= HB_ET_FUNREF are constant values
* All types <= HB_ET_VARIABLE are a simple values
* All types > HB_ET_VARIABLE are operators
*/
typedef enum
{
HB_ET_NONE = 0,
HB_ET_NIL,
HB_ET_NUMERIC,
HB_ET_DATE,
HB_ET_TIMESTAMP,
HB_ET_STRING,
HB_ET_CODEBLOCK,
HB_ET_LOGICAL,
HB_ET_SELF,
HB_ET_ARRAY,
HB_ET_HASH,
HB_ET_FUNREF,
HB_ET_VARREF,
HB_ET_REFERENCE,
HB_ET_IIF,
HB_ET_LIST,
HB_ET_ARGLIST,
HB_ET_MACROARGLIST,
HB_ET_ARRAYAT,
HB_ET_MACRO,
HB_ET_FUNCALL,
HB_ET_ALIASVAR,
HB_ET_ALIASEXPR,
HB_ET_SEND,
HB_ET_FUNNAME,
HB_ET_ALIAS,
HB_ET_RTVAR, /* PRIVATE or PUBLIC declaration of variable */
HB_ET_VARIABLE,
HB_EO_POSTINC, /* post-operators -> lowest precedence */
HB_EO_POSTDEC,
HB_EO_ASSIGN, /* assigments */
HB_EO_PLUSEQ,
HB_EO_MINUSEQ,
HB_EO_MULTEQ,
HB_EO_DIVEQ,
HB_EO_MODEQ,
HB_EO_EXPEQ,
HB_EO_OR, /* logical operators */
HB_EO_AND,
HB_EO_NOT,
HB_EO_EQUAL, /* relational operators */
HB_EO_EQ,
HB_EO_NE,
HB_EO_IN,
HB_EO_LT,
HB_EO_GT,
HB_EO_LE,
HB_EO_GE,
HB_EO_PLUS, /* addition */
HB_EO_MINUS,
HB_EO_MULT, /* multiple */
HB_EO_DIV,
HB_EO_MOD,
HB_EO_POWER,
HB_EO_NEGATE, /* sign operator */
HB_EO_PREINC,
HB_EO_PREDEC /* pre-operators -> the highest precedence */
} HB_EXPR_OPERATOR;
#define HB_EXPR_COUNT ( HB_EO_PREDEC + 1 )
typedef USHORT HB_EXPRTYPE;
typedef struct HB_EXPR_
{
union
{
const char * asSymbol; /* variable name */
HB_BOOL asLogical; /* logical value */
struct
{
char * string; /* literal strings */
HB_BOOL dealloc; /* automatic deallocate on expresion deletion */
} asString;
struct
{
struct HB_EXPR_ * pMacro; /* macro variable */
const char * szName; /* variable name */
} asRTVar; /* PUBLIC or PRIVATE variable declaration */
struct
{
union {
HB_LONG l; /* long value */
double d; /* double value */
} val;
unsigned char bWidth; /* unsigned char used intentionally */
unsigned char bDec; /* unsigned char used intentionally */
unsigned char NumType; /* used to distinguish LONG and DOUBLE */
} asNum;
struct
{
long lDate; /* julian date */
long lTime; /* time in milliseconds */
} asDate;
struct
{
const char * szMacro; /* identifier after the macro operator */
struct HB_EXPR_ * pExprList; /* list elements if &(...) was used */
USHORT SubType; /* context in which macro is used */
unsigned char cMacroOp; /* macro operator */
} asMacro;
struct
{
struct HB_EXPR_ * pExprList; /* list elements */
struct HB_EXPR_ * pIndex; /* array index, others */
HB_BOOL reference; /* push array item by reference or pass variable parameters to called function or method */
} asList;
struct
{
struct HB_EXPR_ * pExprList; /* list elements */
HB_CBVAR_PTR pLocals; /* list of local variables */
char * string; /* source code of a codeblock */
USHORT flags; /* HB_BLOCK_MACRO, HB_BLOCK_LATEEVAL, HB_BLOCK_VPARAMS */
} asCodeblock;
struct
{
struct HB_EXPR_ * pAlias; /* alias expression */
struct HB_EXPR_ * pVar; /* aliased variable or macro */
struct HB_EXPR_ * pExpList; /* aliased expression list */
} asAlias;
struct
{
struct HB_EXPR_ * pFunName; /* function name */
struct HB_EXPR_ * pParms; /* function call parameters */
} asFunCall;
struct
{
struct HB_EXPR_ * pObject; /* object */
struct HB_EXPR_ * pParms; /* method parameters */
const char * szMessage; /* message as string */
struct HB_EXPR_ * pMessage; /* message as macro */
} asMessage;
struct
{
struct HB_EXPR_ * pLeft; /* object */
struct HB_EXPR_ * pRight; /* object */
} asOperator;
struct HB_EXPR_ * asReference;
} value;
ULONG ulLength;
ULONG Counter;
HB_EXPRTYPE ExprType; /* internal expression type */
USHORT ValType; /* language level value type */
struct HB_EXPR_ *pNext; /* next expression in the list of expressions */
} HB_EXPR, *HB_EXPR_PTR;
typedef struct HB_ENUMERATOR_
{
const char *szName;
HB_BOOL bForEach;
struct HB_ENUMERATOR_ *pNext;
} HB_ENUMERATOR, *HB_ENUMERATOR_PTR; /* support structure for FOR EACH statements */
/* support structure for else if pcode fixups */
typedef struct HB_ELSEIF_
{
ULONG ulOffset;
struct HB_ELSEIF_ * pElseif; /* next ELSEIF in the current IF statement */
struct HB_ELSEIF_ * pPrev; /* previous IF statement */
} HB_ELSEIF, * HB_ELSEIF_PTR;
/* support structure for EXIT and LOOP statements */
typedef struct HB_LOOPEXIT_
{
ULONG ulOffset;
HB_BOOL fCanLoop;
USHORT wSeqCounter;
USHORT wAlwaysCounter;
USHORT wWithObjectCnt;
struct HB_LOOPEXIT_ * pLoopList;
struct HB_LOOPEXIT_ * pExitList;
struct HB_LOOPEXIT_ * pNext;
} HB_LOOPEXIT, * HB_LOOPEXIT_PTR;
/* support structure for SWITCH statement */
typedef struct HB_SWITCHCASE_
{
ULONG ulOffset;
HB_EXPR_PTR pExpr;
struct HB_SWITCHCASE_ *pNext;
} HB_SWITCHCASE, * HB_SWITCHCASE_PTR;
typedef struct HB_SWITCHCMD_
{
ULONG ulOffset;
HB_SWITCHCASE_PTR pCases;
HB_SWITCHCASE_PTR pLast;
HB_EXPR_PTR pExpr;
ULONG ulDefault;
struct HB_SWITCHCMD_ *pPrev;
} HB_SWITCHCMD, *HB_SWITCHCMD_PTR;
/* support structure for PUBLIC and PRIVATE statements */
typedef struct HB_RTVAR_
{
HB_EXPR_PTR pVar;
HB_BOOL bPopValue;
struct HB_RTVAR_ *pNext;
struct HB_RTVAR_ *pPrev;
} HB_RTVAR, *HB_RTVAR_PTR;
/* structure to hold a Clipper defined function */
typedef struct __FUNC
{
const char * szName; /* name of a defined Clipper function */
HB_SYMBOLSCOPE cScope; /* scope of a defined Clipper function */
USHORT funFlags; /* some flags we may need */
USHORT wParamCount; /* number of declared parameters */
USHORT wParamNum; /* current parameter number */
PVAR pLocals; /* pointer to local variables list */
PVAR pStatics; /* pointer to static variables list */
PVAR pFields; /* pointer to fields variables list */
PVAR pMemvars; /* pointer to memvar variables list */
PVAR pDetached; /* pointer to detached local variables list */
PVAR pPrivates; /* pointer to private variables list */
BYTE * pCode; /* pointer to a memory block where pcode is stored */
ULONG lPCodeSize; /* total memory size for pcode */
ULONG lPCodePos; /* actual pcode offset */
int iStaticsBase; /* base for this function statics */
int iFuncSuffix; /* function suffix for multiple static functions with the same name */
ULONG * pNOOPs; /* pointer to the NOOP array */
ULONG * pJumps; /* pointer to the Jumps array */
ULONG iNOOPs; /* NOOPs Counter */
ULONG iJumps; /* Jumps Counter */
HB_BOOL bLateEval; /* HB_TRUE if accessing of declared (compile time) variables is allowed */
HB_BOOL fVParams; /* HB_TRUE if variable number of parameters is used */
HB_BOOL bError; /* error during function compilation */
HB_BOOL bBlock; /* HB_TRUE if simple codeblock body is compiled */
struct __FUNC * pOwner; /* pointer to the function/procedure that owns the codeblock */
struct __FUNC * pNext; /* pointer to the next defined function */
HB_ENUMERATOR_PTR pEnum; /* pointer to FOR EACH variables */
HB_LOOPEXIT_PTR pLoops;
HB_SWITCHCMD_PTR pSwitch;
HB_ELSEIF_PTR elseif;
HB_RTVAR_PTR rtvars;
USHORT wSeqCounter;
USHORT wAlwaysCounter;
USHORT wForCounter;
USHORT wIfCounter;
USHORT wWhileCounter;
USHORT wCaseCounter;
USHORT wSwitchCounter;
USHORT wWithObjectCnt;
} _FUNC, * PFUNCTION;
/* structure to hold an INLINE block of source */
typedef struct __INLINE
{
const char * szName; /* name of a inline function */
BYTE * pCode; /* pointer to a memory block where pcode is stored */
ULONG lPCodeSize; /* total memory size for pcode */
const char * szFileName; /* Source file name */
int iLine; /* Source line number */
struct __INLINE * pNext; /* pointer to the next defined inline */
} _INLINE, * PINLINE;
/* structure to hold a called functions */
typedef struct __FUNCALL
{
const char * szName; /* name of a called function */
HB_SYMBOLSCOPE cScope; /* the scope of the function */
struct __FUNCALL * pNext; /* pointer to the next called function */
} _FUNCALL, * PFUNCALL;
/* structure to control all Clipper defined functions */
typedef struct
{
PFUNCTION pFirst; /* pointer to the first defined funtion */
PFUNCTION pLast; /* pointer to the last defined function */
int iCount; /* number of defined functions */
} FUNCTIONS;
/* structure to control all Clipper defined functions */
typedef struct
{
PINLINE pFirst; /* pointer to the first defined inline */
PINLINE pLast; /* pointer to the last defined inline */
int iCount; /* number of defined inlines */
} INLINES;
/* compiler symbol support structure */
typedef struct _COMSYMBOL
{
const char * szName; /* the name of the symbol */
HB_SYMBOLSCOPE cScope; /* the scope of the symbol */
int iFunc; /* is it a function name (TRUE) or memvar (FALSE) */
PFUNCTION pFunc;
struct _COMSYMBOL * pNext; /* pointer to the next defined symbol */
} COMSYMBOL, * PCOMSYMBOL;
/* symbol table support structures */
typedef struct
{
PCOMSYMBOL pFirst; /* pointer to the first defined symbol */
PCOMSYMBOL pLast; /* pointer to the last defined symbol */
int iCount; /* number of defined symbols */
} SYMBOLS;
typedef struct __EXTERN
{
const char * szName; /* name of the extern function */
HB_SYMBOLSCOPE cScope; /* the scope of the function */
struct __EXTERN * pNext;
} _EXTERN, * PEXTERN; /* support structure for extern symbols */
/* as they have to be placed on the symbol table later than the first public symbol */
typedef struct _HB_MODULE
{
const char * szName;
HB_BOOL force;
struct _HB_MODULE * pNext;
} HB_MODULE, * PHB_MODULE;
typedef struct _HB_DEBUGINFO
{
char * pszModuleName;
ULONG ulFirstLine;
ULONG ulLastLine;
ULONG ulAllocated;
BYTE * pLineMap;
struct _HB_DEBUGINFO * pNext;
} HB_DEBUGINFO, * PHB_DEBUGINFO;
typedef struct _HB_LABEL_INFO
{
FILE * yyc;
HB_BOOL fVerbose;
HB_BOOL fSetSeqBegin;
HB_BOOL fCondJump;
HB_BOOL fEndRequest;
int iNestedBlock;
ULONG * pulLabels;
} HB_LABEL_INFO, * PHB_LABEL_INFO;
#define HB_MODE_COMPILER 1
#define HB_MODE_MACRO 2
struct _HB_COMP_FUNCS;
#if defined( HB_COMMON_SUPPORT )
typedef struct _HB_COMMON
{
/* common to macro compiler members */
int mode; /* HB_MODE_* */
ULONG supported; /* various flags for supported capabilities */
const struct _HB_COMP_FUNCS * funcs;
}
HB_COMMON, * HB_COMMON_PTR;
#define HB_COMP_PARAM pCommon
#define HB_COMP_DECL HB_COMMON_PTR HB_COMP_PARAM
#elif defined( HB_MACRO_SUPPORT )
#define HB_COMP_PARAM pMacro
#define HB_COMP_DECL HB_MACRO_PTR HB_COMP_PARAM
typedef struct HB_PCODE_INFO_ /* compiled pcode container for macro compiler */
{
BYTE * pCode; /* pointer to a memory block where pcode is stored */
ULONG lPCodeSize; /* total memory size for pcode */
ULONG lPCodePos; /* actual pcode offset */
HB_BOOL fVParams; /* function/codeblock with variable parameters */
struct HB_PCODE_INFO_ * pPrev;
HB_CBVAR_PTR pLocals;
} HB_PCODE_INFO, * HB_PCODE_INFO_PTR;
typedef struct HB_MACRO_ /* a macro compiled pcode container */
{
/* common to compiler members */
int mode; /* HB_MODE_* */
ULONG supported; /* various flags for supported capabilities */
const struct _HB_COMP_FUNCS * funcs;
/* macro compiler only members */
char * string; /* compiled string */
ULONG length; /* length of the string */
int Flags; /* some flags we may need */
int status; /* status of compilation */
HB_ITEM_PTR pError; /* error object returned from the parser */
HB_PCODE_INFO_PTR pCodeInfo; /* pointer to pcode buffer and info */
void * pLex; /* lexer buffer pointer */
void * pExprLst; /* list with allocated expressions */
void * pIdentLst; /* list with allocated identifiers */
int exprType; /* type of successfully compiled expression */
USHORT uiListElements; /* number of elements in macro list expression */
USHORT uiNameLen; /* the maximum symbol name length */
} HB_MACRO;
#else
#define HB_COMP_PARAM pComp
#define HB_COMP_DECL HB_COMP_PTR HB_COMP_PARAM
#define HB_I18N_PLURAL_MAX 8
typedef struct _HB_I18NPOS
{
const char * szFile;
UINT uiLine;
} HB_I18NPOS, *PHB_I18NPOS;
typedef struct _HB_I18NSTRING
{
const char * szText;
const char * szContext;
const char * szPlurals[ HB_I18N_PLURAL_MAX ];
UINT uiPlurals;
HB_I18NPOS pPos;
HB_I18NPOS * pPosLst;
UINT uiPosCount;
} HB_I18NSTRING, * PHB_I18NSTRING;
typedef struct _HB_I18NTABLE
{
PHB_I18NSTRING pString;
ULONG uiCount;
ULONG uiAllocated;
} HB_I18NTABLE, * PHB_I18NTABLE;
typedef struct _HB_COMP_LEX
{
PHB_PP_STATE pPP;
int iState;
HB_BOOL fEol;
const char * lasttok;
}
HB_COMP_LEX, * PHB_COMP_LEX;
typedef struct _HB_EXPRLST
{
HB_EXPR Expression;
struct _HB_EXPRLST *pPrev;
struct _HB_EXPRLST *pNext;
}
HB_EXPRLST, * PHB_EXPRLST;
typedef struct _HB_INCLST
{
struct _HB_INCLST *pNext;
char szFileName[ 1 ];
}
HB_INCLST, * PHB_INCLST;
typedef struct _HB_COMP
{
/* common to macro compiler members */
int mode; /* HB_MODE_* */
ULONG supported; /* various flags for supported capabilities */
const struct _HB_COMP_FUNCS * funcs;
/* compiler only members */
PHB_COMP_LEX pLex;
PHB_EXPRLST pExprLst;
HB_HASH_TABLE_PTR pIdentifiers;
FUNCTIONS functions;
SYMBOLS symbols;
INLINES inlines;
PEXTERN externs;
PHB_MODULE modules;
PHB_VARTYPE pVarType;
PHB_INCLST incfiles;
PCOMDECLARED pFirstDeclared;
PCOMDECLARED pLastDeclared;
PCOMDECLARED pLastMethod;
PCOMCLASS pFirstClass;
PCOMCLASS pLastClass;
PFUNCTION pInitFunc;
PFUNCTION pLineFunc;
PFUNCTION pDeclFunc;
PHB_FNAME pFileName;
PHB_FNAME pOutPath;
PHB_FNAME pPpoPath;
PHB_FNAME pI18nFileName;
PHB_I18NTABLE pI18n;
HB_BOOL fI18n;
void ( * outStdFunc ) ( void *, const char* );
void ( * outErrFunc ) ( void *, const char* );
void * cargo;
ULONG ulOutBufSize; /* memory output buffer size */
BYTE * pOutBuf; /* memory output buffer address */
ULONG lastLinePos; /* position of last opcode with line number */
int lastLine; /* last generated in PCODE line number */
int currLine; /* currently compiled line number */
const char * lastModule; /* last generated in PCODE module name */
const char * currModule; /* currently compiled module name */
const char * szAnnounce;
const char * szDeclaredFun;
const char * szFile; /* Source file name of compiled module */
char szPrefix[ 20 ]; /* holds the prefix added to the generated symbol init function name (in C output currently) */
char * szDepExt; /* destination file extension used in decencies list */
char * szStdCh; /* standard definitions file name (-u) */
char ** szStdChExt; /* extended definitions file names (-u+<file>) */
int iStdChExt; /* number of extended definition files (-u+<file>) */
char cDataListType; /* current declared variable list type */
char cCastType; /* current casting type */
int iErrorCount;
int iModulesCount; /* number of compiled .prg modules */
int iStartProc; /* holds if we need to create the starting procedure */
int iMaxTransCycles; /* maximum translate cycles in PP (-r=<n>) */
int iHidden; /* hide strings */
int iWarnings; /* enable parse warnings */
int iExitLevel; /* holds if there was any warning during the compilation process */
int iStaticCnt; /* number of defined statics variables on the PRG */
int iVarScope; /* holds the scope for next variables to be defined */
int iLanguage; /* default Harbour generated output language */
int iGenCOutput; /* C code generation should be verbose (use comments) or not */
int ilastLineErr; /* line numer with last syntax error */
int iTraceInclude; /* trace included files and generate dependencies list */
int iSyntaxCheckOnly; /* syntax check only */
int iErrorFmt; /* error message formatting mode (default: Clipper) */
HB_BOOL fQuiet; /* be quiet during compilation (-q) */
HB_BOOL fFullQuiet; /* be quiet during compilation disable all messages */
HB_BOOL fExit; /* force breaking compilation process */
HB_BOOL fPPO; /* flag indicating, is ppo output needed */
HB_BOOL fPPT; /* flag indicating, is ppt output needed */
HB_BOOL fLineNumbers; /* holds if we need pcodes with line numbers */
HB_BOOL fAnyWarning; /* holds if there was any warning during the compilation process */
HB_BOOL fAutoMemvarAssume; /* holds if undeclared variables are automatically assumed MEMVAR (-a)*/
HB_BOOL fForceMemvars; /* holds if memvars are assumed when accesing undeclared variable (-v)*/
HB_BOOL fDebugInfo; /* holds if generate debugger required info */
HB_BOOL fNoStartUp; /* C code generation embed HB_FS_FIRST or not */
HB_BOOL fCredits; /* print credits */
HB_BOOL fBuildInfo; /* print build info */
HB_BOOL fLogo; /* print logo */
HB_BOOL fLongOptimize; /* optimize PCODEs generated for integers */
HB_BOOL fSingleModule; /* do not automatically compile DO...[WITH...] external modules (-m) */
HB_BOOL fError; /* error appeared during compilation */
HB_BOOL fNoArchDefs; /* do not define architecture dependent macros: __PLATFORM__*, __ARCH??BIT__, __*_ENDIAN__ */
HB_BOOL fMeaningful; /* do not generate warnings about meaningless expression usage */
HB_BOOL fINCLUDE; /* use INCLUDE envvar as header path (default) */
}
HB_COMP, * HB_COMP_PTR;
extern HB_COMP_PTR hb_comp_new( void );
extern void hb_comp_free( HB_COMP_PTR );
#endif /* !HB_MACRO_SUPPORT */
typedef struct _HB_COMP_FUNCS
{
HB_EXPR_PTR ( * ExprNew ) ( HB_COMP_DECL, HB_EXPRTYPE iType );
void ( * ExprClear ) ( HB_COMP_DECL, HB_EXPR_PTR pExpr );
void ( * ExprFree ) ( HB_COMP_DECL, HB_EXPR_PTR pExpr );
void ( * ExprDelete ) ( HB_COMP_DECL, HB_EXPR_PTR pExpr );
HB_EXPR_PTR ( * ErrorType ) ( HB_COMP_DECL, HB_EXPR_PTR );
HB_EXPR_PTR ( * ErrorSyntax ) ( HB_COMP_DECL, HB_EXPR_PTR );
void ( * ErrorDuplVar ) ( HB_COMP_DECL, const char* );
} HB_COMP_FUNCS, * PHB_COMP_FUNCS;
#define HB_MACRO_DATA HB_COMP_PARAM
#define HB_PCODE_DATA ( HB_MACRO_DATA->pCodeInfo )
/*Support for traversing of linked list */
#define HB_CARGO_FUNC( proc ) void proc( HB_COMP_DECL, void *cargo )
typedef HB_CARGO_FUNC( HB_CARGO_FUNC_ );
typedef HB_CARGO_FUNC_ *HB_CARGO_FUNC_PTR;
#define HB_CARGO2_FUNC( proc ) void proc( HB_COMP_DECL, void *cargo, void *dummy )
typedef HB_CARGO2_FUNC( HB_CARGO2_FUNC_ );
typedef HB_CARGO2_FUNC_ *HB_CARGO2_FUNC_PTR;
/* pcode chunks bytes size */
#define HB_PCODE_CHUNK 100
HB_EXTERN_END
#endif /* HB_COMPDF_H_ */
Reference in New Issue View Git Blame Copy Permalink