fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
3d0bcacc1074b07252d9e1354732a88802ecc310
harbour-core/harbour/source/compiler/harbour.y

3215 lines
105 KiB
Plaintext
Raw Blame History

%{
/*
* $Id$
*
* Harbour compiler (yacc rules and actions)
* Build 21 proposal: spring 1999
* Usage: bison -d -v harbour.y You may find Bison at www.harbour.project.org
*/
#define BUILD 21 /* current harbour.y build */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <malloc.h> /* required for allocating and freeing memory */
#include "pcode.h" /* pcode values */
#include "types.h" /* our defined types */
#ifdef __BORLANDC__
#define HAVE_STRUPR
#endif
#ifndef HAVE_STRUPR
#include <ctype.h>
char *strupr( char *p );
#endif
/* TODO: #define this for various platforms */
#define PATH_DELIMITER "/\\"
#define IS_PATH_SEP( c ) (strchr(PATH_DELIMITER, (c))!=NULL)
extern FILE * yyin; /* currently yacc parsed file */
extern int iLine; /* currently parsed file line number */
typedef struct /* #include support */
{
FILE * handle; /* handle of the opened file */
void * pBuffer; /* buffer used by yacc */
char * szFileName; /* name of the file */
void * pPrev; /* pointer to the previous opened file */
void * pNext; /* pointer to the next opened file */
int iLine; /* currently processed line number */
} _FILE, * PFILE; /* structure to hold an opened PRG or CH */
typedef struct
{
PFILE pLast; /* pointer to the last opened file */
int iFiles; /* number of files currently opened */
} FILES; /* structure to control several opened PRGs and CHs */
int Include( char * szFileName ); /* end #include support */
typedef struct _VAR /* locals, static, public variables support */
{
char *szName; /* variable name */
char *szAlias; /* variable alias namespace */
struct _VAR * pNext; /* pointer to next defined variable */
} VAR, * PVAR;
typedef struct __FUNC /* functions definition support */
{
char * szName; /* name of a defined Clipper function */
char cScope; /* scope of a defined Clipper function */
BYTE bFlags; /* some flags we may need */
WORD wParamCount; /* number of declared parameters */
PVAR pLocals; /* pointer to local variables list */
PVAR pStatics; /* pointer to static variables list */
PVAR pFields; /* pointer to fields variables list */
BYTE * pCode; /* pointer to a memory block where pcode is stored */
LONG lPCodeSize; /* total memory size for pcode */
LONG lPCodePos; /* actual pcode offset */
WORD wStaticsBase; /* base for this function statics */
struct __FUNC * pOwner; /* pointer to the function/procedure that owns the codeblock */
struct __FUNC * pNext; /* pointer to the next defined function */
} _FUNC, * PFUNCTION; /* structure to hold a Clipper defined function */
/*
* flags for bFlags member
*/
#define FUN_STATEMENTS 1 /* Function have at least one executable statement */
#define FUN_USES_STATICS 2 /* Function uses static variables */
#define FUN_PROCEDURE 4 /* This is a procedure that shouldn't return value */
#define FUN_ILLEGAL_INIT 8 /* Attempt to initialize static variable with a function call */
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 */
/* pcode chunks bytes size */
#define PCODE_CHUNK 100
typedef struct _COMSYMBOL /* compiler symbol support structure */
{
char * szName; /* the name of the symbol */
char cScope; /* the scope of the symbol */
struct _COMSYMBOL * pNext; /* pointer to the next defined symbol */
} COMSYMBOL, * PCOMSYMBOL;
typedef struct /* symbol table support structures */
{
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 __ELSEIF
{
WORD wOffset;
struct __ELSEIF * pNext;
} _ELSEIF, * PELSEIF; /* support structure for else if pcode fixups */
typedef struct __RETURN
{
WORD wOffset;
struct __RETURN * pNext;
} _RETURN, * PRETURN; /* support structure for multiple returns from a function */
typedef struct /* support for filenames */
{
char _buffer[ _POSIX_PATH_MAX+3 ];
char *path;
char *name;
char *extension;
} FILENAME;
typedef struct __EXTERN
{
char * szName;
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 */
FILENAME *SplitFilename( char * ); /* splits filename into a path, a name and an extension */
char *MakeFilename( char *, FILENAME *); /* joins a path, a name an an extension int filename */
/* lex & yacc related prototypes */
void yyerror( char * ); /* parsing error management function */
int yylex( void ); /* main lex token function, called by yyparse() */
int yyparse( void ); /* main yacc parsing function */
#ifdef __cplusplus
extern "C" int yywrap( void );
#else
int yywrap( void ); /* manages the EOF of current processed file */
#endif
void AddDefine( char * szDefine, char * szValue ); /* add a new Lex define from the command line */
void * yy_create_buffer( FILE *, int ); /* yacc functions to manage multiple files */
#ifdef __cplusplus
typedef struct yy_buffer_state *YY_BUFFER_STATE;
void yy_switch_to_buffer( YY_BUFFER_STATE ); /* yacc functions to manage multiple files */
void yy_delete_buffer( YY_BUFFER_STATE ); /* yacc functions to manage multiple files */
#else
void yy_switch_to_buffer( void * ); /* yacc functions to manage multiple files */
void yy_delete_buffer( void * ); /* yacc functions to manage multiple files */
#endif
static void __yy_memcpy( char * from, char * to, int count ); /* Bison prototype */
/* production related functions */
PFUNCTION AddFunCall( char * szFuntionName );
void AddExtern( char * szExternName ); /* defines a new extern name */
void AddVar( char * szVarName ); /* add a new param, local, static variable to a function definition or a public or private */
PCOMSYMBOL AddSymbol( char * szSymbolName );
void CheckDuplVars( PVAR pVars, char * szVarName, int iVarScope ); /*checks for duplicate variables definitions */
void Dec( void ); /* generates the pcode to decrement the latest value on the virtual machine stack */
void DimArray( WORD wDimensions ); /* instructs the virtual machine to build an array with wDimensions */
void Do( BYTE bParams ); /* generates the pcode to execute a Clipper function discarding its result */
void Duplicate( void ); /* duplicates the virtual machine latest stack latest value and places it on the stack */
void DupPCode( WORD wStart ); /* duplicates the current generated pcode from an offset */
void FixElseIfs( void * pIfElseIfs ); /* implements the ElseIfs pcode fixups */
void FixReturns( void ); /* fixes all last defined function returns jumps offsets */
void Function( BYTE bParams ); /* generates the pcode to execute a Clipper function pushing its result */
PFUNCTION FunctionNew( char *, char ); /* creates and initialises the _FUNC structure */
void FunDef( char * szFunName, char cScope, int iType ); /* starts a new Clipper language function definition */
void GenArray( WORD wElements ); /* instructs the virtual machine to build an array and load elemnst from the stack */
void * GenElseIf( void * pFirstElseIf, WORD wOffset ); /* generates a support structure for elseifs pcode fixups */
void GenError( int, char*, char * ); /* generic parsing error management function */
void GenExterns( void ); /* generates the symbols for the EXTERN names */
void GenReturn( WORD wOffset ); /* generates a return offset to later on fill it with the proper exiting pcode address */
PFUNCTION GetFuncall( char * szFunName ); /* locates a previously defined called function */
PFUNCTION GetFunction( char * szFunName ); /* locates a previously defined function */
PVAR GetVar( PVAR pVars, WORD wOrder ); /* returns a variable if defined or zero */
WORD GetVarPos( PVAR pVars, char * szVarName ); /* returns the order + 1 of a variable if defined or zero */
int GetLocalVarPos( char * szVarName ); /* returns the order + 1 of a local variable */
PCOMSYMBOL GetSymbol( char * szSymbolName ); /* returns a symbol pointer from the symbol table */
PCOMSYMBOL GetSymbolOrd( WORD wSymbol ); /* returns a symbol based on its index on the symbol table */
WORD GetSymbolPos( char * szSymbolName ); /* returns the index + 1 of a symbol on the symbol table */
void Inc( void ); /* generates the pcode to increment the latest value on the virtual machine stack */
WORD Jump( int iOffset ); /* generates the pcode to jump to a specific offset */
WORD JumpFalse( int iOffset ); /* generates the pcode to jump if false */
void JumpHere( int iOffset ); /* returns the pcode pos where to set a jump offset */
void JumpThere( int iOffset, WORD wTo ); /* sets a jump offset */
WORD JumpTrue( int iOffset ); /* generates the pcode to jump if true */
void Line( void ); /* generates the pcode with the currently compiled source code line */
void LineBody( void ); /* generates the pcode with the currently compiled source code line */
void Message( char * szMsgName ); /* sends a message to an object */
void PopId( char * szVarName ); /* generates the pcode to pop a value from the virtual machine stack onto a variable */
void PushDouble( double fNumber ); /* Pushes a number on the virtual machine stack */
void PushId( char * szVarName ); /* generates the pcode to push a variable value to the virtual machine stack */
void PushIdByRef( char * szVarName ); /* generates the pcode to push a variable by reference to the virtual machine stack */
void PushInteger( int iNumber ); /* Pushes a integer number on the virtual machine stack */
void PushLogical( int iTrueFalse ); /* pushes a logical value on the virtual machine stack */
void PushLong( long lNumber ); /* Pushes a long number on the virtual machine stack */
void PushNil( void ); /* Pushes nil on the virtual machine stack */
void PushString( char * szText ); /* Pushes a string on the virtual machine stack */
void PushSymbol( char * szSymbolName, int iIsFunction ); /* Pushes a symbol on to the Virtual machine stack */
void GenPCode1( BYTE ); /* generates 1 byte of pcode */
void GenPCode3( BYTE, BYTE, BYTE ); /* generates 3 bytes of pcode */
void GenPCodeN( BYTE * pBuffer, WORD wSize ); /* copy bytes to a pcode buffer */
char * SetData( char * szMsg ); /* generates an underscore-symbol name for a data assignment */
void SetFrame( void ); /* generates the proper _FRAME values */
/* support for FIELD declaration */
void SetAlias( char *, int );
int FieldsCount( void );
/* Codeblocks */
void CodeBlockStart( void ); /* starts a codeblock creation */
void CodeBlockEnd( void ); /* end of codeblock creation */
/* Static variables */
void StaticDefStart( void );
void StaticDefEnd( WORD );
void StaticAssign( void ); /* checks if static variable is initialized with function call */
void * OurMalloc( LONG lSize ); /* our malloc with error control */
void * OurRealloc( void * p, LONG lSize ); /* our malloc with error control */
#define OurFree( p ) free( (p) ); /* just for symetry -we can expand it later */
/* output related functions */
void GenCCode( char *, char * ); /* generates the C language output */
void GenJava( char *, char * ); /* generates the Java language output */
void GenPascal( char *, char * ); /* generates the Pascal language output */
void GenRC( char *, char * ); /* generates the RC language output */
void PrintUsage( char * );
#define YYDEBUG 1 /* Parser debug information support */
typedef enum
{
LANG_C, /* C language (by default) <file.c> */
LANG_JAVA, /* Java <file.java> */
LANG_PASCAL, /* Pascal <file.pas> */
LANG_RESOURCES /* Resources <file.rc> */
} LANGUAGES; /* supported Harbour output languages */
extern int iLine; /* currently compiled source code line */
int iVarScope = 0; /* holds the scope for next variables to be defined */
#define VS_LOCAL 0 /* different values for iVarScope */
#define VS_STATIC 1
#define VS_PARAMETER 2
#define VS_FIELD 3
#define VS_MEMVAR 4
#define ERR_OUTSIDE 1
#define ERR_FUNC_DUPL 2
#define ERR_VAR_DUPL 3
#define ERR_FOLLOWS_EXEC 4
#define ERR_OUTER_VAR 5
#define ERR_NUMERIC_FORMAT 6
#define ERR_STRING_TERMINATOR 7
#define ERR_FUNC_RESERVED 8
#define ERR_ILLEGAL_INIT 9
/* Table with parse errors */
char * _szErrors[] = { "Statement not allowed outside of procedure or function",
"Redefinition of procedure or function: \'%s\'",
"Duplicate variable declaration: \'%s\'",
"%s declaration follows executable statement",
"Outer codeblock variable is out of reach: \'%s\'",
"Invalid numeric format '.'",
"Unterminated string: \'%s\'",
"Redefinition of predefined function %s: \'%s\'",
"Illegal initializer: \'%s\'"
};
/* Table with reserved functions names
* NOTE: THIS TABLE MUST BE SORTED ALPHABETICALLY
*/
static const char * _szReservedFun[] = {
"AADD" ,
"ABS" ,
"ASC" ,
"AT" ,
"BOF" ,
"BREAK" ,
"CDOW" ,
"CHR" ,
"CMONTH" ,
"COL" ,
"CTOD" ,
"DATE" ,
"DAY" ,
"DELETED" ,
"DEVPOS" ,
"DOW" ,
"DTOC" ,
"DTOS" ,
"EMPTY" ,
"EOF" ,
"EXP" ,
"FCOUNT" ,
"FIELDNAME" ,
"FLOCK" ,
"FOUND" ,
"INKEY" ,
"INT" ,
"LASTREC" ,
"LEFT" ,
"LEN" ,
"LOCK" ,
"LOG" ,
"LOWER" ,
"LTRIM" ,
"MAX" ,
"MIN" ,
"MONTH" ,
"PCOL" ,
"PCOUNT" ,
"PROW" ,
"QSELF" ,
"RECCOUNT" ,
"RECNO" ,
"REPLICATE" ,
"RLOCK" ,
"ROUND" ,
"ROW" ,
"RTRIM" ,
"SECONDS" ,
"SELECT" ,
"SETPOS" ,
"SPACE" ,
"SQRT" ,
"STR" ,
"SUBSTR" ,
"TIME" ,
"TRANSFORM" ,
"TRIM" ,
"TYPE" ,
"UPPER" ,
"VAL" ,
"WORD" ,
"YEAR"
};
#define RESERVED_FUNCTIONS sizeof(_szReservedFun) / sizeof(char *)
/* function compares strings upto maximum 4 characters (used in bsearch) */
/* Borland C 3.1 reports error when this forward declaration is used
* int sz_compare4( const void *, const void * );
*
*/
/* Compare first 4 characters
* If they are the same then compare the whole name
* SECO() is not allowed because of Clipper function SECONDS()
* however SECO32() is a valid name.
*/
int EXTERNAL_LINKAGE sz_compare4( const void *pLookup, const void *pReserved )
{
int iCmp;
iCmp = strncmp( (const char *)pLookup, *((const char * *)pReserved), 4 );
if( iCmp == 0 )
iCmp = strncmp( (const char *)pLookup, *((const char * *)pReserved),
strlen((const char *)pLookup) );
return iCmp;
}
#define RESERVED_FUNC(szName) \
bsearch( (szName), _szReservedFun, RESERVED_FUNCTIONS, sizeof(char*), sz_compare4 )
FILES files;
FUNCTIONS functions, funcalls;
PFUNCTION _pInitFunc;
SYMBOLS symbols;
int _iStartProc = 1; /* holds if we need to create the starting procedure */
int _iLineNumbers = 1; /* holds if we need pcodes with line numbers */
int _iQuiet = 0; /* quiet mode */
int _iSyntaxCheckOnly = 0; /* syntax check only */
int _iLanguage = LANG_C; /* default Harbour generated output language */
int _iRestrictSymbolLength = 0; /* generate 10 chars max symbols length */
int _iShortCuts = 1; /* .and. & .or. expressions shortcuts */
WORD _wStatics = 0; /* number of defined statics variables on the PRG */
PRETURN pReturns = 0; /* list of multiple returns from a function */
PEXTERN pExterns = 0;
%}
%union /* special structure used by lex and yacc to share info */
{
char * string; /* to hold a string returned by lex */
int iNumber; /* to hold a number returned by lex */
long lNumber; /* to hold a long number returned by lex */
double dNumber; /* to hold a double number returned by lex */
void * pVoid; /* to hold any memory structure we may need */
};
%token FUNCTION PROCEDURE IDENTIFIER RETURN NIL DOUBLE INASSIGN INTEGER INTLONG
%token LOCAL STATIC IF ELSE ELSEIF END ENDIF LITERAL TRUE FALSE
%token INCLUDE EXTERN INIT EXIT AND OR NOT PUBLIC EQ NE1 NE2
%token INC DEC ALIAS DOCASE CASE OTHERWISE ENDCASE ENDDO MEMVAR
%token WHILE EXIT LOOP END FOR NEXT TO STEP LE GE FIELD IN PARAMETERS
%token PLUSEQ MINUSEQ MULTEQ DIVEQ POWER EXPEQ MODEQ EXITLOOP
%token PRIVATE BEGINSEQ BREAK RECOVER USING DO WITH SELF
/*the lowest precedence*/
/*postincrement and postdecrement*/
%left POST
/*assigment - from right to left*/
%right INASSIGN
%left PLUSEQ MINUSEQ
%left MULTEQ DIVEQ MODEQ
%left EXPEQ
/*logical operators*/
%left OR
%left AND
%left NOT
/*relational operators*/
%left '<' '>' EQ NE1 NE2 LE GE '$'
/*mathematical operators*/
%left '+' '-'
%left '*' '/' '%'
%left POWER
%left UNARY
/*preincrement and predecrement*/
%left PRE
/*special operators*/
%left ALIAS '&' '@' ')'
%right '\n' ';' ',' '='
/*the highest precedence*/
%type <string> IDENTIFIER LITERAL FunStart MethStart IdSend
%type <dNumber> DOUBLE ObjectData
%type <iNumber> ArgList ElemList ExpList FunCall FunScope IncDec Logical Params ParamList
%type <iNumber> INTEGER BlockExpList Argument IfBegin VarId VarList MethParams ObjFunCall
%type <iNumber> MethCall BlockList FieldList
%type <lNumber> INTLONG WhileBegin BlockBegin
%type <pVoid> IfElseIf Cases
%%
Main : { Line(); } Source { if( ! _iQuiet ) printf( "\nsyntax ok\n" ); }
;
Source : Crlf
| Extern
| Include
| VarDefs
| FieldsDef
| MEMVAR IdentList
| Function
| Statement
| Source Crlf
| Source Extern
| Source Include
| Source Function
| Source { LineBody(); } Statement
| Source VarDefs
| Source FieldsDef
| Source MEMVAR IdentList
;
Include : NE1 INCLUDE LITERAL { Include( $3 ); } Crlf
;
Extern : EXTERN ExtList Crlf
;
ExtList : IDENTIFIER { AddExtern( $1 ); }
| ExtList ',' IDENTIFIER { AddExtern( $3 ); }
;
Function : FunScope FUNCTION IDENTIFIER { FunDef( $3, $1, 0 ); } Params Crlf { SetFrame(); }
| FunScope PROCEDURE IDENTIFIER { FunDef( $3, $1, FUN_PROCEDURE ); } Params Crlf { SetFrame(); }
;
FunScope : { $$ = FS_PUBLIC; }
| STATIC { $$ = FS_STATIC; }
| INIT { $$ = FS_INIT; }
| EXIT { $$ = FS_EXIT; }
;
Params : { $$ = 0; }
| '(' ')' { $$ = 0; }
| '(' { iVarScope = VS_PARAMETER; } ParamList ')' { $$ = $3; }
;
ParamList : IDENTIFIER { AddVar( $1 ); $$ = 1; }
| ParamList ',' IDENTIFIER { AddVar( $3 ); $$++; }
;
Statements : Statement
| Statements { Line(); } Statement
;
Statement : ExecFlow Crlf {}
| FunCall Crlf { Do( $1 ); }
| AliasFunc Crlf {}
| IfInline Crlf { GenPCode1( _POP ); }
| ObjectMethod Crlf { GenPCode1( _POP ); }
| VarUnary Crlf { GenPCode1( _POP ); }
| VarAssign Crlf { GenPCode1( _POP ); }
| IDENTIFIER '=' Expression Crlf { PopId( $1 ); }
| VarId ArrayIndex '=' Expression Crlf { GenPCode1( _ARRAYPUT ); GenPCode1( _POP ); }
| FunCall ArrayIndex '=' Expression Crlf { Do( $1 ); GenPCode1( _ARRAYPUT ); }
| IdSend IDENTIFIER '=' { Message( SetData( $2 ) ); } Expression Crlf { Function( 1 ); }
| IdSend IDENTIFIER INASSIGN { Message( SetData( $2 ) ); } Expression Crlf { Function( 1 ); }
| ObjectData ArrayIndex '=' Expression Crlf {}
| ObjectMethod ArrayIndex '=' Expression Crlf {}
| BREAK Crlf
| BREAK Expression Crlf
| RETURN Crlf { GenReturn( Jump( 0 ) ); }
| RETURN Expression Crlf { GenPCode1( _RETVALUE ); GenReturn( Jump ( 0 ) ); }
| PUBLIC VarList Crlf
| PRIVATE VarList Crlf
| PARAMETERS IdentList Crlf
| EXITLOOP Crlf
| LOOP Crlf
| DoProc Crlf
;
FunCall : FunStart ')' { $$ = 0; }
| FunStart ArgList ')' { $$ = $2; }
;
FunStart : IDENTIFIER '(' { StaticAssign(); PushSymbol( $1, 1 ); PushNil(); $$ = $1; }
;
MethCall : MethStart ')' { $$ = 0; }
| MethStart ArgList ')' { $$ = $2; }
;
MethStart : IDENTIFIER '(' { StaticAssign(); Message( $1 ); $$ = $1; }
;
ArgList : ',' { PushNil(); PushNil(); $$ = 2; }
| Argument { $$ = 1; }
| ArgList ',' { PushNil(); $$++; }
| ArgList ',' Argument { $$++; }
;
Argument : Expression {}
| '@' IDENTIFIER { PushIdByRef( $2 ); }
| '@' IDENTIFIER '(' ')' { PushSymbol( $2, 1 ); GenPCode1( _FUNCPTR ); }
;
MethParams : /* empty */ { $$ = 0; }
| ArgList { $$ = $1; }
;
ObjectData : IdSend IDENTIFIER { Message( $2 ); Function( 0 ); }
| VarId ArrayIndex ':' IDENTIFIER { Message( $4 ); Function( 0 ); }
| ObjFunCall IDENTIFIER { Message( $2 ); Function( 0 ); }
| FunCall ArrayIndex ':' IDENTIFIER { Function( $1 ); Message( $4 ); Function( 0 ); }
| ObjectMethod ':' IDENTIFIER { Message( $3 ); Function( 0 ); }
| ObjectData ':' IDENTIFIER { Message( $3 ); Function( 0 ); }
| ObjectData ArrayIndex ':' IDENTIFIER { Message( $4 ); Function( 0 ); }
;
ObjectMethod : IdSend IDENTIFIER { Message( $2 ); } '(' MethParams ')' { Function( $5 ); }
| VarId ArrayIndex ':' MethCall { Function( $4 ); }
| ObjFunCall MethCall { Function( $2 ); }
| FunCall ArrayIndex ':' MethCall { Function( $4 ); }
| ObjectData ':' MethCall { Function( $3 ); }
| ObjectData ArrayIndex ':' MethCall { Function( $4 ); }
| ObjectMethod ':' MethCall { Function( $3 ); }
;
IdSend : IDENTIFIER ':' { PushId( $1 ); $$ = $1; }
;
ObjFunCall : FunCall ':' { Function( $1 ); $$ = $1; }
;
Expression : NIL { PushNil(); }
| DOUBLE { PushDouble( $1 ); }
| INTEGER { PushInteger( $1 ); }
| INTLONG { PushLong( $1 ); }
| LITERAL { PushString( $1 ); }
| Variable
| VarUnary
| Logical { PushLogical( $1 ); }
| Operators {}
| FunCall { Function( $1 ); }
| IfInline {}
| Array {}
| CodeBlock {}
| ObjectMethod {}
| Macro {}
| AliasExp {}
| '(' Expression ')' {}
| '(' ExpList ')' {}
| SELF { GenPCode1( _PUSHSELF ); }
;
IfInline : IF '(' Expression ',' { $<iNumber>$ = JumpFalse( 0 ); }
IfInlExp ',' { $<iNumber>$ = Jump( 0 ); JumpHere( $<iNumber>5 ); }
IfInlExp ')' { JumpHere( $<iNumber>8 ); }
;
IfInlExp : /* nothing => nil */ { PushNil(); }
| Expression
;
Macro : '&' Variable
| '&' '(' Expression ')'
;
AliasExp : IDENTIFIER ALIAS IDENTIFIER {}
| '(' Expression ')' ALIAS IDENTIFIER {}
| AliasFunc {}
;
AliasFunc : IDENTIFIER ALIAS '(' ExpList ')' {}
| '(' Expression ')' ALIAS '(' ExpList ')' {}
;
VarUnary : IDENTIFIER IncDec %prec POST { PushId( $1 ); Duplicate(); $2 ? Inc(): Dec(); PopId( $1 ); }
| IncDec IDENTIFIER %prec PRE { PushId( $2 ); $1 ? Inc(): Dec(); Duplicate(); PopId( $2 ); }
| VarId ArrayIndex IncDec %prec POST { DupPCode( $1 ); GenPCode1( _ARRAYAT ); $3 ? Inc(): Dec(); GenPCode1( _ARRAYPUT ); $3 ? Dec(): Inc(); }
| IncDec VarId ArrayIndex %prec PRE { DupPCode( $2 ); GenPCode1( _ARRAYAT ); $1 ? Inc(): Dec(); GenPCode1( _ARRAYPUT ); }
| FunCall ArrayIndex IncDec %prec POST {}
| IncDec FunCall ArrayIndex %prec PRE {}
| ObjectData IncDec %prec POST {}
| IncDec ObjectData %prec PRE {}
| ObjectData ArrayIndex IncDec %prec POST {}
| IncDec ObjectData ArrayIndex %prec PRE {}
| ObjectMethod ArrayIndex IncDec %prec POST {}
| IncDec ObjectMethod ArrayIndex %prec PRE {}
;
IncDec : INC { $$ = 1; }
| DEC { $$ = 0; }
;
Variable : VarId {}
| VarId ArrayIndex { GenPCode1( _ARRAYAT ); }
| FunCall ArrayIndex { GenPCode1( _ARRAYAT ); }
| ObjectData {}
| ObjectData ArrayIndex { GenPCode1( _ARRAYAT ); }
| ObjectMethod ArrayIndex { GenPCode1( _ARRAYAT ); }
;
VarId : IDENTIFIER { $$ = functions.pLast->lPCodePos; PushId( $1 ); }
;
ArrayIndex : '[' IndexList ']'
| ArrayIndex { GenPCode1( _ARRAYAT ); } '[' IndexList ']'
;
IndexList : Expression
| IndexList { GenPCode1( _ARRAYAT ); } ',' Expression
;
VarAssign : IDENTIFIER INASSIGN Expression { PopId( $1 ); PushId( $1 ); }
| IDENTIFIER PLUSEQ { PushId( $1 ); } Expression { GenPCode1( _PLUS ); PopId( $1 ); PushId( $1 ); }
| IDENTIFIER MINUSEQ { PushId( $1 ); } Expression { GenPCode1( _MINUS ); PopId( $1 ); PushId( $1 ); }
| IDENTIFIER MULTEQ { PushId( $1 ); } Expression { GenPCode1( _MULT ); PopId( $1 ); PushId( $1 ); }
| IDENTIFIER DIVEQ { PushId( $1 ); } Expression { GenPCode1( _DIVIDE ); PopId( $1 ); PushId( $1 ); }
| IDENTIFIER EXPEQ { PushId( $1 ); } Expression { GenPCode1( _POWER ); PopId( $1 ); PushId( $1 ); }
| IDENTIFIER MODEQ { PushId( $1 ); } Expression { GenPCode1( _MODULUS ); PopId( $1 ); PushId( $1 ); }
| VarId ArrayIndex INASSIGN Expression { GenPCode1( _ARRAYPUT ); }
| VarId ArrayIndex PLUSEQ Expression { GenPCode1( _PLUS ); GenPCode1( _ARRAYPUT ); }
| VarId ArrayIndex MINUSEQ Expression {}
| VarId ArrayIndex MULTEQ Expression {}
| VarId ArrayIndex DIVEQ Expression {}
| VarId ArrayIndex EXPEQ Expression {}
| VarId ArrayIndex MODEQ Expression {}
| FunCall ArrayIndex INASSIGN Expression {}
| FunCall ArrayIndex PLUSEQ Expression {}
| FunCall ArrayIndex MINUSEQ Expression {}
| FunCall ArrayIndex MULTEQ Expression {}
| FunCall ArrayIndex DIVEQ Expression {}
| FunCall ArrayIndex EXPEQ Expression {}
| FunCall ArrayIndex MODEQ Expression {}
| ObjectData PLUSEQ Expression {}
| ObjectData MINUSEQ Expression {}
| ObjectData MULTEQ Expression {}
| ObjectData DIVEQ Expression {}
| ObjectData EXPEQ Expression {}
| ObjectData MODEQ Expression {}
| ObjectData ArrayIndex INASSIGN Expression {}
| ObjectData ArrayIndex PLUSEQ Expression {}
| ObjectData ArrayIndex MINUSEQ Expression {}
| ObjectData ArrayIndex MULTEQ Expression {}
| ObjectData ArrayIndex DIVEQ Expression {}
| ObjectData ArrayIndex EXPEQ Expression {}
| ObjectData ArrayIndex MODEQ Expression {}
| ObjectMethod ArrayIndex INASSIGN Expression {}
| ObjectMethod ArrayIndex PLUSEQ Expression {}
| ObjectMethod ArrayIndex MINUSEQ Expression {}
| ObjectMethod ArrayIndex MULTEQ Expression {}
| ObjectMethod ArrayIndex DIVEQ Expression {}
| ObjectMethod ArrayIndex EXPEQ Expression {}
| ObjectMethod ArrayIndex MODEQ Expression {}
| AliasExp INASSIGN Expression {}
;
Operators : Expression '=' Expression { GenPCode1( _EQUAL ); } /* compare */
| Expression '+' Expression { GenPCode1( _PLUS ); }
| Expression '-' Expression { GenPCode1( _MINUS ); }
| Expression '*' Expression { GenPCode1( _MULT ); }
| Expression '/' Expression { GenPCode1( _DIVIDE ); }
| Expression '<' Expression { GenPCode1( _LESS ); }
| Expression '>' Expression { GenPCode1( _GREATER ); }
| Expression '$' Expression { GenPCode1( _INSTRING ); }
| Expression '%' Expression { GenPCode1( _MODULUS ); }
| Expression LE Expression { GenPCode1( _LESSEQUAL ); }
| Expression GE Expression { GenPCode1( _GREATEREQUAL ); }
| Expression AND { if( _iShortCuts ){ Duplicate(); $<iNumber>$ = JumpFalse( 0 ); } }
Expression { GenPCode1( AND_ ); if( _iShortCuts ) JumpHere( $<iNumber>3 ); }
| Expression OR { if( _iShortCuts ){ Duplicate(); $<iNumber>$ = JumpTrue( 0 ); } }
Expression { GenPCode1( OR_ ); if( _iShortCuts ) JumpHere( $<iNumber>3 ); }
| Expression EQ Expression { GenPCode1( _EQUAL ); }
| Expression NE1 Expression { GenPCode1( _NOTEQUAL ); }
| Expression NE2 Expression { GenPCode1( _NOTEQUAL ); }
| Expression POWER Expression { GenPCode1( _POWER ); }
| NOT Expression { GenPCode1( _NOT ); }
| '-' Expression %prec UNARY { GenPCode1( _NEGATE ); }
| '+' Expression %prec UNARY
| VarAssign
;
Logical : TRUE { $$ = 1; }
| FALSE { $$ = 0; }
;
Array : '{' ElemList '}' { GenArray( $2 ); }
;
ElemList : /*empty array*/ { $$ = 0; }
| Expression { $$ = 1; }
| ElemList ',' { if( $$ == 0 ) {
PushNil();
PushNil();
$$ = 2;
} else {
PushNil();
$$++;
} }
| ElemList ',' Expression { if( $$ == 0 )
{
PushNil();
$$ = 2;
}
else
$$++; }
;
CodeBlock : BlockBegin '|' BlockExpList '}' { CodeBlockEnd(); }
| BlockBegin BlockList '|' BlockExpList '}' { CodeBlockEnd(); }
;
BlockBegin : '{' '|' { CodeBlockStart(); }
;
BlockExpList : Expression { $$ = 1; }
| ',' { PushNil(); GenPCode1( _POP ); PushNil(); $$ = 2; }
| BlockExpList ',' { GenPCode1( _POP ); PushNil(); $$++; }
| BlockExpList ',' { GenPCode1( _POP ); } Expression { $$++; }
;
BlockList : IDENTIFIER { AddVar( $1 ); $$ = 1; }
| BlockList ',' IDENTIFIER { AddVar( $3 ); $$++; }
;
ExpList : Expression %prec POST { $$ = 1; }
| ExpList { GenPCode1( _POP ); } ',' Expression %prec POST { $$++; }
;
VarDefs : LOCAL { iVarScope = VS_LOCAL; Line(); } VarList Crlf { SetFrame(); }
| STATIC { StaticDefStart() } VarList Crlf { StaticDefEnd( $<iNumber>3 ); }
;
VarList : VarDef { $$ = 1; }
| VarList ',' VarDef { $$++; }
;
VarDef : IDENTIFIER { AddVar( $1 ); }
| IDENTIFIER INASSIGN Expression { AddVar( $1 ); PopId( $1 ); }
| IDENTIFIER '[' ExpList ']' { AddVar( $1 ); DimArray( $3 ); }
;
FieldsDef : FIELD { iVarScope =VS_FIELD; } FieldList Crlf { LineBody(); }
;
FieldList : IDENTIFIER { $$=FieldsCount(); AddVar( $1 ); }
| FieldList ',' IDENTIFIER { AddVar( $3 ); }
| FieldList IN IDENTIFIER { SetAlias( $3, $<iNumber>1 ); }
;
IdentList : IDENTIFIER {}
| IdentList ',' IDENTIFIER {}
;
ExecFlow : IfEndif
| DoCase
| DoWhile
| ForNext
| BeginSeq
;
IfEndif : IfBegin EndIf { JumpHere( $1 ); }
| IfBegin IfElse EndIf { JumpHere( $1 ); }
| IfBegin IfElseIf EndIf { JumpHere( $1 ); FixElseIfs( $2 ); }
| IfBegin IfElseIf IfElse EndIf { JumpHere( $1 ); FixElseIfs( $2 ); }
;
IfBegin : IF Expression Crlf { $$ = JumpFalse( 0 ); } IfStats
{ $$ = Jump( 0 ); JumpHere( $<iNumber>4 ); }
;
IfElse : ELSE Crlf IfStats
;
IfElseIf : ELSEIF Expression Crlf { $<iNumber>$ = JumpFalse( 0 ); }
IfStats { $$ = GenElseIf( 0, Jump( 0 ) ); JumpHere( $<iNumber>4 ); }
| IfElseIf ELSEIF Expression Crlf { $<iNumber>$ = JumpFalse( 0 ); }
IfStats { $$ = GenElseIf( $1, Jump( 0 ) ); JumpHere( $<iNumber>5 ); }
;
EndIf : ENDIF
| END
;
IfStats : /* no statements */
| Statements
;
DoCase : DoCaseBegin
Cases
EndCase { FixElseIfs( $2 ); }
| DoCaseBegin
Otherwise
EndCase
| DoCaseBegin
Cases
Otherwise
EndCase { FixElseIfs( $2 ); }
;
EndCase : ENDCASE
| END
;
DoCaseBegin : DOCASE Crlf
;
Cases : CASE Expression Crlf { $<iNumber>$ = JumpFalse( 0 ); Line(); } CaseStmts { $$ = GenElseIf( 0, Jump( 0 ) ); JumpHere( $<iNumber>4 ); Line(); }
| Cases CASE Expression Crlf { $<iNumber>$ = JumpFalse( 0 ); Line(); } CaseStmts { $$ = GenElseIf( $1, Jump( 0 ) ); JumpHere( $<iNumber>5 ); Line(); }
;
Otherwise : OTHERWISE Crlf CaseStmts
;
CaseStmts : /* no statements */
| Statements
;
DoWhile : WhileBegin Expression Crlf { $<lNumber>$ = JumpFalse( 0 ); }
{ Jump( $1 - functions.pLast->lPCodePos ); }
EndWhile { JumpHere( $<lNumber>4 ); }
| WhileBegin Expression Crlf { $<lNumber>$ = JumpFalse( 0 ); Line(); }
WhileStatements { Jump( $1 - functions.pLast->lPCodePos ); }
EndWhile { JumpHere( $<lNumber>4 ); }
;
WhileBegin : WHILE { $$ = functions.pLast->lPCodePos; }
;
WhileStatements : Statement
| WhileStatements Statement { Line(); }
;
EndWhile : END
| ENDDO
;
ForNext : FOR IDENTIFIER ForAssign Expression { PopId( $2 ); $<iNumber>$ = functions.pLast->lPCodePos; }
TO Expression { PushId( $2 ); }
StepExpr Crlf { GenPCode1( _FORTEST ); $<iNumber>$ = JumpTrue( 0 ); PushId( $2 ) }
ForStatements { GenPCode1( _PLUS ); PopId( $2 ); Jump( $<iNumber>5 - functions.pLast->lPCodePos ); JumpHere( $<iNumber>11 ); }
;
ForAssign : '='
| INASSIGN
;
StepExpr : /* default step expression */ { PushInteger( 1 ); }
| STEP Expression
;
ForStatements : ForStat NEXT
| ForStat NEXT IDENTIFIER
| NEXT
| NEXT IDENTIFIER
;
ForStat : Statements { Line(); }
;
BeginSeq : BEGINSEQ Crlf
RecoverSeq
END
| BEGINSEQ Crlf
Statements
RecoverSeq
END
;
RecoverSeq : /* no recover */
| RECOVER Crlf
| RECOVER Crlf Statements
| RECOVER USING IDENTIFIER Crlf
| RECOVER USING IDENTIFIER Crlf Statements
;
DoProc : DO IDENTIFIER { PushSymbol( $2, 1 ); PushNil(); Do( 0 ); }
| DO IDENTIFIER { PushSymbol( $2, 1 ); PushNil(); } WITH ArgList { Do( $5 ); }
;
Crlf : '\n'
| ';'
| '\n' Crlf
| ';' Crlf
;
%%
void yyerror( char * s )
{
printf( "\n%s at line %i\n", s, --iLine );
exit( 1 );
}
void * GenElseIf( void * pFirst, WORD wOffset )
{
PELSEIF pElseIf = ( PELSEIF ) OurMalloc( sizeof( _ELSEIF ) ), pLast;
pElseIf->wOffset = wOffset;
pElseIf->pNext = 0;
if( ! pFirst )
pFirst = pElseIf;
else
{
pLast = ( PELSEIF ) pFirst;
while( pLast->pNext )
pLast = pLast->pNext;
pLast->pNext = pElseIf;
}
return pFirst;
}
void GenError( int iError, char * szError1, char * szError2 )
{
char * szLine = ( char * ) OurMalloc( 160 ); /*2 lines of text */
printf( "\r%s(%i) ", files.pLast->szFileName, iLine );
printf( "Error C%i ", iError );
sprintf( szLine, _szErrors[ iError - 1 ], szError1, szError2 );
printf( "%s\n\n", szLine );
exit( 1 );
}
void EXTERNAL_LINKAGE close_on_exit( void )
{
PFILE pFile = files.pLast;
while( pFile )
{
printf( "\nClosing file: %s\n", pFile->szFileName );
fclose( pFile->handle );
pFile = (PFILE) pFile->pPrev;
}
}
int harbour_main( int argc, char * argv[] )
{
int iStatus = 0, iArg = 1;
char szFileName[ _POSIX_PATH_MAX ]; /* filename to parse */
char *szPath ="";
FILENAME *pFileName =NULL;
if( !_iQuiet )
printf( "Harbour compiler\nbuild %i Spring 1999\n", BUILD );
if( argc > 1 )
{
/* Command line options */
while( iArg < argc )
{
if( argv[ iArg ][ 0 ] == '/' || argv[ iArg ][ 0 ] == '-' )
{
switch( argv[ iArg ][ 1 ] )
{
case '1':
if( argv[ iArg ][ 2 ] == '0' )
_iRestrictSymbolLength = 1;
break;
case 'd':
case 'D': /* defines a Lex #define from the command line */
{
unsigned int i = 0;
char * szDefText = strdup( argv[ iArg ] + 2 );
while( i < strlen( szDefText ) && szDefText[ i ] != '=' )
i++;
if( szDefText[ i ] != '=' )
AddDefine( szDefText, 0 );
else
{
szDefText[ i ] = 0;
AddDefine( szDefText, szDefText + i + 1 );
}
free( szDefText );
}
break;
case 'g':
case 'G':
switch( argv[ iArg ][ 2 ] )
{
case 'c':
case 'C':
_iLanguage = LANG_C;
break;
case 'j':
case 'J':
_iLanguage = LANG_JAVA;
break;
case 'p':
case 'P':
_iLanguage = LANG_PASCAL;
break;
case 'r':
case 'R':
_iLanguage = LANG_RESOURCES;
break;
default:
printf( "\nUnsupported output language option\n" );
exit( 1 );
}
break;
case 'l':
case 'L':
_iLineNumbers = 0;
break;
case 'n':
case 'N':
_iStartProc = 0;
break;
case 'o':
case 'O':
szPath = argv[ iArg ]+2;
break;
case 'q':
case 'Q':
_iQuiet = 1;
break;
case 's':
case 'S':
_iSyntaxCheckOnly = 1;
break;
case 'y':
case 'Y':
yydebug = TRUE;
break;
case 'z':
case 'Z':
_iShortCuts = 0;
break;
default:
printf( "Invalid command line option: %s\n",
&argv[ iArg ][ 1 ] );
break;
}
}
else
pFileName =SplitFilename( argv[ iArg ] );
iArg++;
}
if( pFileName )
{
if( !pFileName->extension )
pFileName->extension =".prg";
MakeFilename( szFileName, pFileName );
}
else
{
PrintUsage( argv[ 0 ] );
return iStatus;
}
files.iFiles = 0; /* initialize support variables */
files.pLast = 0;
functions.iCount = 0;
functions.pFirst = 0;
functions.pLast = 0;
funcalls.iCount = 0;
funcalls.pFirst = 0;
funcalls.pLast = 0;
symbols.iCount = 0;
symbols.pFirst = 0;
symbols.pLast = 0;
_pInitFunc =NULL;
atexit( close_on_exit );
if( Include( szFileName ) )
{
FunDef( strupr( strdup( pFileName->name ) ), FS_PUBLIC, FUN_PROCEDURE );
yyparse();
FixReturns(); /* fix all previous function returns offsets */
fclose( yyin );
files.pLast =NULL;
if( ! _iSyntaxCheckOnly )
{
if( _pInitFunc )
{
PCOMSYMBOL pSym;
/* Fix the number of static variables */
_pInitFunc->pCode[ 1 ] =LOBYTE( _wStatics );
_pInitFunc->pCode[ 2 ] =HIBYTE( _wStatics );
_pInitFunc->wStaticsBase =_wStatics;
pSym =AddSymbol( _pInitFunc->szName );
pSym->cScope |= _pInitFunc->cScope;
functions.pLast->pNext = _pInitFunc;
++functions.iCount;
}
/* we create a the output file */
pFileName->path = szPath;
switch( _iLanguage )
{
case LANG_C:
pFileName->extension =".c";
MakeFilename( szFileName, pFileName );
GenCCode( szFileName, pFileName->name );
break;
case LANG_JAVA:
pFileName->extension =".java";
MakeFilename( szFileName, pFileName );
GenJava( szFileName, pFileName->name );
break;
case LANG_PASCAL:
pFileName->extension =".pas";
MakeFilename( szFileName, pFileName );
GenPascal( szFileName, pFileName->name );
break;
case LANG_RESOURCES:
pFileName->extension =".rc";
MakeFilename( szFileName, pFileName );
GenRC( szFileName, pFileName->name );
break;
}
}
}
else
{
printf( "Can't open input file: %s\n", szFileName );
iStatus = 1;
}
OurFree( pFileName );
}
else
PrintUsage( argv[ 0 ] );
return iStatus;
}
/*
* Prints available options
*/
void PrintUsage( char * szSelf )
{
printf( "Syntax: %s <file.prg> [options]\n"
"\nOptions: \n"
"\t/d<id>[=<val>]\t#define <id>\n"
"\t/g\t\tgenerated output language\n"
"\t\t\t /gc (C default) --> <file.c>\n"
"\t\t\t /gj (Java) --> <file.java>\n"
"\t\t\t /gp (Pascal) --> <file.pas>\n"
"\t\t\t /gr (Resources) --> <file.rc>\n"
"\t/l\t\tsuppress line number information\n"
"\t/n\t\tno implicit starting procedure\n"
"\t/o<path>\tobject file drive and/or path\n"
"\t/q\t\tquiet\n"
"\t/s\t\tsyntax check only\n"
"\t/y\t\ttrace lex & yacc activity\n"
"\t/z\t\tsupress .and. & .or. shortcutting\n"
"\t/10\t\trestrict symbol length to 10 characters\n"
, szSelf );
}
/*
* Split given filename into path, name and extension
*/
FILENAME *SplitFilename( char *szFilename )
{
FILENAME *pName =(FILENAME *)OurMalloc( sizeof(FILENAME) );
int iLen = strlen(szFilename);
int iSlashPos, iDotPos;
int iPos;
pName->path =pName->name =pName->extension =NULL;
iSlashPos =iLen-1;
iPos =0;
while( iSlashPos >= 0 && !IS_PATH_SEP(szFilename[ iSlashPos ]) )
--iSlashPos;
if( iSlashPos == 0 )
{
/* root path -> \filename */
pName->_buffer[ 0 ] =PATH_DELIMITER[ 0 ];
pName->_buffer[ 1 ] ='\x0';
pName->path =pName->_buffer;
iPos =2; /* first free position after the slash */
}
else if( iSlashPos > 0 )
{
/* path with separator -> path\filename */
memcpy( pName->_buffer, szFilename, iSlashPos );
pName->_buffer[ iSlashPos ] ='\x0';
pName->path =pName->_buffer;
iPos =iSlashPos +1; /* first free position after the slash */
}
iDotPos =iLen-1;
while( iDotPos > iSlashPos && szFilename[ iDotPos ] != '.' )
--iDotPos;
if( (iDotPos-iSlashPos) > 1 )
{
/* the dot was found
* and there is at least one character between a slash and a dot
*/
if( iDotPos == iLen-1 )
{
/* the dot is the last character -use it as extension name */
pName->extension =pName->_buffer+iPos;
pName->_buffer[ iPos++ ] ='.';
pName->_buffer[ iPos++ ] ='\x0';
}
else
{
pName->extension =pName->_buffer+iPos;
/* copy rest of the string with terminating ZERO character */
memcpy( pName->extension, szFilename+iDotPos+1, iLen-iDotPos );
iPos +=iLen-iDotPos;
}
}
else
/* there is no dot in the filename or it is '.filename' */
iDotPos =iLen;
pName->name =pName->_buffer+iPos;
memcpy( pName->name, szFilename+iSlashPos+1, iDotPos-iSlashPos-1 );
pName->name[ iDotPos-iSlashPos-1 ] ='\x0';
return pName;
}
/*
* This function joins path, name and extension into a string with a filename
*/
char *MakeFilename( char *szFileName, FILENAME *pFileName )
{
if( pFileName->path && pFileName->path[ 0 ] )
{
/* we have not empty path specified */
int iLen =strlen(pFileName->path);
strcpy( szFileName, pFileName->path );
/* if the path is a root directory then we don't need to add path separator */
if( !(IS_PATH_SEP(pFileName->path[ 0 ]) && pFileName->path[ 0 ] == '\x0') )
{
/* add the path separator only in cases:
* when a name doesn't start with it
* when the path doesn't end with it
*/
if( !( IS_PATH_SEP(pFileName->name[ 0 ]) || IS_PATH_SEP(pFileName->path[ iLen-1 ]) ) )
{
szFileName[ iLen++ ] =PATH_DELIMITER[ 0 ];
szFileName[ iLen ] ='\x0';
}
}
strcpy( szFileName+iLen, pFileName->name );
}
else
strcpy( szFileName, pFileName->name );
if( pFileName->extension )
{
int iLen =strlen(szFileName);
if( !(pFileName->extension[ 0 ] == '.' || pFileName->name[ iLen-1 ] == '.') )
{
/* add extension separator only when extansion doesn't contain it */
szFileName[ iLen++ ] ='.';
szFileName[ iLen ] ='\x0';
}
strcpy( szFileName+iLen, pFileName->extension );
}
return szFileName;
}
PFUNCTION AddFunCall( char * szFunctionName )
{
PFUNCTION pFunc = ( PFUNCTION ) OurMalloc( sizeof( _FUNC ) );
pFunc->szName = szFunctionName;
pFunc->cScope = 0;
pFunc->pNext = 0;
if( ! funcalls.iCount )
{
funcalls.pFirst = pFunc;
funcalls.pLast = pFunc;
}
else
{
( ( PFUNCTION ) funcalls.pLast )->pNext = pFunc;
funcalls.pLast = pFunc;
}
funcalls.iCount++;
return pFunc;
}
void AddExtern( char * szExternName ) /* defines a new extern name */
{
PEXTERN pExtern = ( PEXTERN ) OurMalloc( sizeof( _EXTERN ) ), pLast;
pExtern->szName = szExternName;
pExtern->pNext = 0;
if( pExterns == 0 )
pExterns = pExtern;
else
{
pLast = pExterns;
while( pLast->pNext )
pLast = pLast->pNext;
pLast->pNext = pExtern;
}
}
void AddVar( char * szVarName )
{
PVAR pVar, pLastVar;
PFUNCTION pFunc =functions.pLast;
if( ! _iStartProc && functions.iCount <= 1 && iVarScope == VS_LOCAL )
{
/* Variable declaration is outside of function/procedure body.
In this case only STATIC and PARAMETERS variables are allowed. */
--iLine;
GenError( ERR_OUTSIDE, NULL, NULL );
}
/* check if we are declaring local/static variable after some
* executable statements
* Note: FIELD and MEMVAR are executable statements
*/
if( (functions.pLast->bFlags & FUN_STATEMENTS) && !(iVarScope == VS_FIELD || iVarScope == VS_MEMVAR) )
{
--iLine;
GenError( ERR_FOLLOWS_EXEC, (iVarScope==VS_LOCAL?"LOCAL":"STATIC"), NULL );
}
/* When static variable is added then functions.pLast points to function
* that will initialise variables. The function where variable is being
* defined is stored in pOwner member.
*/
if( iVarScope == VS_STATIC )
{
pFunc =pFunc->pOwner;
/* Check if an illegal action was invoked during a static variable
* value initialization
*/
if( _pInitFunc->bFlags & FUN_ILLEGAL_INIT )
GenError( ERR_ILLEGAL_INIT, szVarName, pFunc->szName );
}
/* Check if a declaration of duplicated variable name is requested */
if( pFunc->szName )
{
/* variable defined in a function/procedure */
CheckDuplVars( pFunc->pFields, szVarName, iVarScope );
CheckDuplVars( pFunc->pStatics, szVarName, iVarScope );
}
else
/* variable defined in a codeblock */
iVarScope =VS_PARAMETER;
CheckDuplVars( pFunc->pLocals, szVarName, iVarScope );
pVar = ( PVAR ) OurMalloc( sizeof( VAR ) );
pVar->szName = szVarName;
pVar->szAlias = NULL;
pVar->pNext = NULL;
switch( iVarScope )
{
case VS_LOCAL:
case VS_PARAMETER:
if( ! pFunc->pLocals )
pFunc->pLocals = pVar;
else
{
pLastVar = pFunc->pLocals;
while( pLastVar->pNext )
pLastVar = pLastVar->pNext;
pLastVar->pNext = pVar;
}
if( iVarScope == VS_PARAMETER )
++functions.pLast->wParamCount;
break;
case VS_STATIC:
if( ! pFunc->pStatics )
pFunc->pStatics = pVar;
else
{
pLastVar = pFunc->pStatics;
while( pLastVar->pNext )
pLastVar = pLastVar->pNext;
pLastVar->pNext = pVar;
}
break;
case VS_FIELD:
if( ! pFunc->pFields )
pFunc->pFields = pVar;
else
{
pLastVar = pFunc->pFields;
while( pLastVar->pNext )
pLastVar = pLastVar->pNext;
pLastVar->pNext = pVar;
}
break;
}
}
PCOMSYMBOL AddSymbol( char * szSymbolName )
{
PCOMSYMBOL pSym = ( PCOMSYMBOL ) OurMalloc( sizeof( COMSYMBOL ) );
pSym->szName = szSymbolName;
pSym->cScope = 0;
pSym->pNext = 0;
if( ! symbols.iCount )
{
symbols.pFirst = pSym;
symbols.pLast = pSym;
}
else
{
( ( PCOMSYMBOL ) symbols.pLast )->pNext = pSym;
symbols.pLast = pSym;
}
symbols.iCount++;
return pSym;
}
int Include( char * szFileName )
{
PFILE pFile;
if( ! ( yyin = fopen( szFileName, "r" ) ) )
return 0;
if( ! _iQuiet )
printf( "\nparsing file %s\n", szFileName );
pFile = ( PFILE ) OurMalloc( sizeof( _FILE ) );
pFile->handle = yyin;
pFile->szFileName = szFileName;
pFile->pPrev = NULL;
if( ! files.iFiles )
files.pLast = pFile;
else
{
files.pLast->iLine = iLine;
iLine = 1;
pFile->pPrev = files.pLast;
files.pLast = pFile;
}
#ifdef __cplusplus
yy_switch_to_buffer( (YY_BUFFER_STATE) (pFile->pBuffer = yy_create_buffer( yyin, 8192 * 2 ) ) );
#else
yy_switch_to_buffer( (pFile->pBuffer = yy_create_buffer( yyin, 8192 * 2 ) ) );
#endif
files.iFiles++;
return 1;
}
int yywrap( void ) /* handles the EOF of the currently processed file */
{
void * pLast;
if( files.iFiles == 1 )
return 1; /* we have reached the main EOF */
else
{
pLast = files.pLast;
fclose( files.pLast->handle );
files.pLast = ( PFILE ) ( ( PFILE ) files.pLast )->pPrev;
iLine = files.pLast->iLine;
printf( "\nparsing file %s\n", files.pLast->szFileName );
#ifdef __cplusplus
yy_delete_buffer( (YY_BUFFER_STATE) ( ( PFILE ) pLast )->pBuffer );
#else
yy_delete_buffer( ( ( PFILE ) pLast )->pBuffer );
#endif
free( pLast );
files.iFiles--;
yyin = files.pLast->handle;
#ifdef __cplusplus
yy_switch_to_buffer( (YY_BUFFER_STATE) files.pLast->pBuffer );
#else
yy_switch_to_buffer( files.pLast->pBuffer );
#endif
return 0; /* we close the currently include file and continue */
}
}
void Duplicate( void )
{
GenPCode1( _DUPLICATE );
}
void DupPCode( WORD wStart ) /* duplicates the current generated pcode from an offset */
{
WORD w, wEnd = functions.pLast->lPCodePos - wStart;
for( w = 0; w < wEnd; w++ )
GenPCode1( functions.pLast->pCode[ wStart + w ] );
}
/*
* This function creates and initialises the _FUNC structure
*/
PFUNCTION FunctionNew( char *szName, char cScope )
{
PFUNCTION pFunc;
pFunc = ( PFUNCTION ) OurMalloc( sizeof( _FUNC ) );
pFunc->szName = szName;
pFunc->cScope = cScope;
pFunc->pLocals = 0;
pFunc->pStatics = 0;
pFunc->pFields = 0;
pFunc->pCode = 0;
pFunc->lPCodeSize = 0;
pFunc->lPCodePos = 0;
pFunc->pNext = 0;
pFunc->wParamCount = 0;
pFunc->wStaticsBase = _wStatics;
pFunc->pOwner = NULL;
pFunc->bFlags = 0;
return pFunc;
}
/*
* Stores a Clipper defined function/procedure
* szFunName - name of a function
* cScope - scope of a function
* iType - FUN_PROCEDURE if a procedure or 0
*/
void FunDef( char * szFunName, char cScope, int iType )
{
PCOMSYMBOL pSym;
PFUNCTION pFunc;
char * *pFunction;
if( ( pFunc = GetFunction( szFunName ) ) )
{
/* The name of a function/procedure is already defined */
if( pFunc != functions.pFirst || _iStartProc )
/* it is not a starting procedure that was automatically created */
GenError( ERR_FUNC_DUPL, szFunName, NULL );
}
pFunction =(char * *)RESERVED_FUNC( szFunName );
if( pFunction && !(functions.iCount==0 && !_iStartProc) )
{
/* We are ignoring it when it is the name of PRG file and we are
* not creating implicit starting procedure
*/
GenError( ERR_FUNC_RESERVED, *pFunction, szFunName );
}
FixReturns(); /* fix all previous function returns offsets */
if( !( pSym = GetSymbol( szFunName ) ) )
/* there is not a symbol on the symbol table for this function name */
pSym = AddSymbol( szFunName );
GenExterns(); /* generates EXTERN symbols names */
if( cScope == FS_PUBLIC )
pSym->cScope = FS_PUBLIC;
else
pSym->cScope |= cScope; /* we may have a non public function and a object message */
pFunc =FunctionNew( szFunName, cScope );
pFunc->bFlags |= iType;
if( functions.iCount == 0 )
{
functions.pFirst = pFunc;
functions.pLast = pFunc;
}
else
{
functions.pLast->pNext = pFunc;
functions.pLast = pFunc;
}
functions.iCount++;
GenPCode3( _FRAME, 0, 0 ); /* frame for locals and parameters */
GenPCode3( _SFRAME, 0, 0 ); /* frame for statics variables */
}
void GenJava( char *szFileName, char *szName )
{
printf( "\ngenerating Java language output...\n" );
printf( "%s -> not implemented yet! %s\n", szFileName, szName );
}
void GenPascal( char *szFileName, char *szName )
{
printf( "\ngenerating Pascal language output...\n" );
printf( "%s -> not implemented yet! %s\n", szFileName, szName );
}
void GenRC( char *szFileName, char *szName )
{
printf( "\ngenerating resources output...\n" );
printf( "%s -> not implemented yet! %s\n", szFileName, szName );
}
void GenCCode( char *szFileName, char *szName ) /* generates the C language output */
{
PFUNCTION pFunc = functions.pFirst, pFTemp;
PCOMSYMBOL pSym = symbols.pFirst;
WORD w, wLen, wSym, wVar;
WORD iNestedCodeblock = 0;
LONG lPCodePos;
char chr;
FILE * yyc; /* file handle for C output */
szName =szName; /* just to keep compiler silent */
if( ! ( yyc = fopen( szFileName, "wb" ) ) )
{
printf( "Error opening file %s\n", szFileName );
return;
}
if( ! _iQuiet )
printf( "\ngenerating C language output...\n" );
fprintf( yyc, "#include \"pcode.h\"\n\n" );
if( ! _iStartProc )
pFunc = pFunc->pNext; /* No implicit starting procedure */
/* write functions prototypes for PRG defined functions */
while( pFunc )
{
if ( pFunc->cScope & FS_STATIC || pFunc->cScope & FS_INIT ||
pFunc->cScope & FS_EXIT )
fprintf( yyc, "static " );
fprintf( yyc, "HARBOUR %s( void );\n", pFunc->szName );
pFunc = pFunc->pNext;
}
/* write functions prototypes for called functions outside this PRG */
pFunc = funcalls.pFirst;
while( pFunc )
{
if( ! ( pFTemp = GetFunction( pFunc->szName ) ) || pFTemp == functions.pFirst )
fprintf( yyc, "HARBOUR %s( void );\n", pFunc->szName );
pFunc = pFunc->pNext;
}
/* writes the symbol table */
fprintf( yyc, "\nstatic SYMBOL symbols[] = { " );
if( ! _iStartProc )
pSym = pSym->pNext; /* starting procedure is always the first symbol */
while( pSym )
{
fprintf( yyc, "{ \"%s\", ", pSym->szName );
if( pSym->cScope & FS_STATIC )
fprintf( yyc, "FS_STATIC" );
else if( pSym->cScope & FS_INIT )
fprintf( yyc, "FS_INIT" );
else if( pSym->cScope & FS_EXIT )
fprintf( yyc, "FS_EXIT" );
else
fprintf( yyc, "FS_PUBLIC" );
if( ( pSym->cScope != FS_MESSAGE ) && ( pSym->cScope & FS_MESSAGE ) ) /* only for non public symbols */
fprintf( yyc, " | FS_MESSAGE" );
/* specify the function address if it is a defined function or a
external called function */
if( ( pFTemp = GetFunction( pSym->szName ) ) ) /* is it a defined function ? */
fprintf( yyc, ", %s, 0 }", pFTemp->szName );
else
{
if( ( pFTemp = GetFuncall( pSym->szName ) ) )
fprintf( yyc, ", %s, 0 }", pFTemp->szName );
else
fprintf( yyc, ", 0, 0 }" );
}
if( pSym != symbols.pLast )
fprintf( yyc, ",\n " );
pSym = pSym->pNext;
}
fprintf( yyc, " };\n\n" );
fprintf( yyc, "#include <init.h>\n\n" );
/* Generate functions data
*/
pFunc = functions.pFirst;
if( ! _iStartProc )
pFunc = pFunc->pNext; /* No implicit starting procedure */
while( pFunc )
{
if( pFunc->cScope != FS_PUBLIC )
fprintf( yyc, "static " );
fprintf( yyc, "HARBOUR %s( void )\n{\n static BYTE pcode[]={\n", pFunc->szName );
lPCodePos = 0;
while( lPCodePos < pFunc->lPCodePos )
{
switch( pFunc->pCode[ lPCodePos ] )
{
case AND_:
fprintf( yyc, " AND_,\n" );
lPCodePos++;
break;
case _ARRAYAT:
fprintf( yyc, " _ARRAYAT,\n" );
lPCodePos++;
break;
case _ARRAYPUT:
fprintf( yyc, " _ARRAYPUT,\n" );
lPCodePos++;
break;
case _DEC:
fprintf( yyc, " _DEC,\n" );
lPCodePos++;
break;
case _DIMARRAY:
w = pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256;
fprintf( yyc, " _DIMARRAY, %i, %i,\t/* %i */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ], w );
lPCodePos += 3;
break;
case _DIVIDE:
fprintf( yyc, " _DIVIDE,\n" );
lPCodePos++;
break;
case _DO:
fprintf( yyc, " _DO, %i, %i,\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ] );
lPCodePos += 3;
break;
case _DUPLICATE:
fprintf( yyc, " _DUPLICATE,\n" );
lPCodePos++;
break;
case _EQUAL:
fprintf( yyc, " _EQUAL,\n" );
lPCodePos++;
break;
case _ENDBLOCK:
--iNestedCodeblock;
fprintf( yyc, " _ENDBLOCK,\n" );
lPCodePos++;
break;
case _FALSE:
fprintf( yyc, " _FALSE,\n" );
lPCodePos++;
break;
case _FORTEST: /* ER For tests. Step > 0 LESS */
/* Step < 0 GREATER */
fprintf( yyc, " _FORTEST,\n" );
lPCodePos++;
break;
case _FRAME:
if( pFunc->pCode[ lPCodePos + 1 ] || pFunc->pCode[ lPCodePos + 2 ] )
fprintf( yyc, " _FRAME, %i, %i,\t\t/* locals, params */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ] );
lPCodePos += 3;
break;
case _FUNCPTR:
fprintf( yyc, " _FUNCPTR,\n" );
lPCodePos++;
break;
case _FUNCTION:
fprintf( yyc, " _FUNCTION, %i, %i,\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ] );
lPCodePos += 3;
break;
case _GENARRAY:
w = pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256;
fprintf( yyc, " _GENARRAY, %i, %i,\t/* %i */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ], w );
lPCodePos += 3;
break;
case _GREATER:
fprintf( yyc, " _GREATER,\n" );
lPCodePos++;
break;
case _GREATEREQUAL:
fprintf( yyc, " _GREATEREQUAL,\n" );
lPCodePos++;
break;
case _INC:
fprintf( yyc, " _INC,\n" );
lPCodePos++;
break;
case _INSTRING:
fprintf( yyc, " _INSTRING,\n" );
lPCodePos++;
break;
case _JUMP:
if( (lPCodePos + 3) < pFunc->lPCodePos )
{
w = pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256;
fprintf( yyc, " _JUMP, %i, %i,\t/* %i (abs: %05li) */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ], w, lPCodePos + ( w ? w: 3 ) );
}
lPCodePos += 3;
break;
case _JUMPFALSE:
w = pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256;
fprintf( yyc, " _JUMPFALSE, %i, %i,\t/* %i (abs: %05li) */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ], w, lPCodePos + ( w ? w: 3 ) );
lPCodePos += 3;
break;
case _JUMPTRUE:
w = pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256;
fprintf( yyc, " _JUMPTRUE, %i, %i,\t/* %i (abs: %05li) */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ], w, lPCodePos + ( w ? w: 3 ) );
lPCodePos += 3;
break;
case _LESS:
fprintf( yyc, " _LESS,\n" );
lPCodePos++;
break;
case _LESSEQUAL:
fprintf( yyc, " _LESSEQUAL,\n" );
lPCodePos++;
break;
case _LINE:
fprintf( yyc, "/* %05li */", lPCodePos );
w = pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256;
fprintf( yyc, " _LINE, %i, %i,\t\t/* %i */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ], w );
lPCodePos += 3;
break;
case _MESSAGE:
wSym = pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256;
fprintf( yyc, " _MESSAGE, %i, %i, /* %s */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ],
GetSymbolOrd( wSym + ! _iStartProc )->szName );
lPCodePos += 3;
break;
case _MINUS:
fprintf( yyc, " _MINUS,\n" );
lPCodePos++;
break;
case _MODULUS:
fprintf( yyc, " _MODULUS,\n" );
lPCodePos++;
break;
case _MULT:
fprintf( yyc, " _MULT,\n" );
lPCodePos++;
break;
case _NEGATE:
fprintf( yyc, " _NEGATE,\n" );
lPCodePos++;
break;
case _NOT:
fprintf( yyc, " _NOT,\n" );
lPCodePos++;
break;
case _NOTEQUAL:
fprintf( yyc, " _NOTEQUAL,\n" );
lPCodePos++;
break;
case OR_:
fprintf( yyc, " OR_,\n" );
lPCodePos++;
break;
case _PLUS:
fprintf( yyc, " _PLUS,\n" );
lPCodePos++;
break;
case _POP:
fprintf( yyc, " _POP,\n" );
lPCodePos++;
break;
case _POPLOCAL:
{
SHORT wVar = * ( ( SHORT *) &(pFunc->pCode )[ lPCodePos + 1 ] );
/* Variable with negative order are local variables
* referenced in a codeblock -handle it with care
*/
if( iNestedCodeblock )
{
/* we are accesing variables within a codeblock */
/* the names of codeblock variable are lost */
if( wVar < 0 )
fprintf( yyc, " _POPLOCAL, %i, %i,\t/* localvar%i */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ],
-wVar );
else
fprintf( yyc, " _POPLOCAL, %i, %i,\t/* codeblockvar%i */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ],
wVar );
}
else
fprintf( yyc, " _POPLOCAL, %i, %i,\t/* %s */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ],
GetVar( pFunc->pLocals, wVar )->szName );
lPCodePos += 3;
}
break;
case _POPMEMVAR:
wVar = pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256;
fprintf( yyc, " _POPMEMVAR, %i, %i,\t/* %s */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ],
GetSymbolOrd( wVar + ! _iStartProc )->szName );
lPCodePos += 3;
break;
case _POPSTATIC:
{
PVAR pVar;
PFUNCTION pTmp = functions.pFirst;
wVar = pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256;
while( pTmp->pNext && pTmp->pNext->wStaticsBase < wVar )
pTmp =pTmp->pNext;
pVar = GetVar( pTmp->pStatics, wVar - pTmp->wStaticsBase );
fprintf( yyc, " _POPSTATIC, %i, %i,\t/* %s */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ],
pVar->szName );
lPCodePos += 3;
}
break;
case _POWER:
fprintf( yyc, " _POWER,\n" );
lPCodePos++;
break;
case _PUSHBLOCK:
++iNestedCodeblock;
fprintf( yyc, " _PUSHBLOCK, %i, %i,\t/* %i */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ],
pFunc->pCode[ lPCodePos + 1 ] +
pFunc->pCode[ lPCodePos + 2 ] * 256 );
w = * ( ( WORD *) &( pFunc->pCode [ lPCodePos + 3 ] ) );
fprintf( yyc, " %i, %i, \t/* number of local parameters (%i) */\n",
pFunc->pCode[ lPCodePos + 3 ],
pFunc->pCode[ lPCodePos + 4 ], w );
wVar = * ( ( WORD *) &( pFunc->pCode [ lPCodePos + 5 ] ) );
fprintf( yyc, " %i, %i, \t/* number of local variables (%i) */\n",
pFunc->pCode[ lPCodePos + 5 ],
pFunc->pCode[ lPCodePos + 6 ], wVar );
lPCodePos += 7; /* codeblock size + number of parameters + number of local variables */
/* create the table of referenced local variables */
while( wVar-- )
{
w = * ( ( WORD *) &( pFunc->pCode [ lPCodePos ] ) );
fprintf( yyc, " %i, %i, \t/* %s */\n",
pFunc->pCode[ lPCodePos ],
pFunc->pCode[ lPCodePos + 1 ],
GetVar( pFunc->pLocals, w )->szName );
lPCodePos +=2;
}
break;
case _PUSHDOUBLE:
{
int i;
++lPCodePos;
fprintf( yyc, " _PUSHDOUBLE, " );
for( i = 0; i < sizeof( double ); ++i )
fprintf( yyc, "%i, ", ( ( BYTE * ) pFunc->pCode )[ lPCodePos + i ] );
fprintf( yyc, "/* %f */\n",
*( ( double * ) &( pFunc->pCode[ lPCodePos ] ) ) );
lPCodePos += sizeof( double );
}
break;
case _PUSHINT:
fprintf( yyc, " _PUSHINT, %i, %i, /* %i */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ],
pFunc->pCode[ lPCodePos + 1 ] +
pFunc->pCode[ lPCodePos + 2 ] * 256 );
lPCodePos += 3;
break;
case _PUSHLOCAL:
{
SHORT wVar = * ( ( SHORT *) &(pFunc->pCode )[ lPCodePos + 1 ] );
/* Variable with negative order are local variables
* referenced in a codeblock -handle it with care
*/
if( iNestedCodeblock )
{
/* we are accesing variables within a codeblock */
/* the names of codeblock variable are lost */
if( wVar < 0 )
fprintf( yyc, " _PUSHLOCAL, %i, %i,\t/* localvar%i */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ],
-wVar );
else
fprintf( yyc, " _PUSHLOCAL, %i, %i,\t/* codeblockvar%i */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ],
wVar );
}
else
fprintf( yyc, " _PUSHLOCAL, %i, %i,\t/* %s */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ],
GetVar( pFunc->pLocals, wVar )->szName );
lPCodePos += 3;
}
break;
case _PUSHLOCALREF:
{
SHORT wVar = * ( ( SHORT *) &(pFunc->pCode )[ lPCodePos + 1 ] );
/* Variable with negative order are local variables
* referenced in a codeblock -handle it with care
*/
if( iNestedCodeblock )
{
/* we are accesing variables within a codeblock */
/* the names of codeblock variable are lost */
if( wVar < 0 )
fprintf( yyc, " _PUSHLOCALREF, %i, %i,\t/* localvar%i */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ],
-wVar );
else
fprintf( yyc, " _PUSHLOCALREF, %i, %i,\t/* codeblockvar%i */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ],
wVar );
}
else
fprintf( yyc, " _PUSHLOCALREF, %i, %i,\t/* %s */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ],
GetVar( pFunc->pLocals, wVar )->szName );
lPCodePos += 3;
}
break;
case _PUSHLONG:
fprintf( yyc, " _PUSHLONG, %i, %i, %i, %i, /* %li */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ],
pFunc->pCode[ lPCodePos + 3 ],
pFunc->pCode[ lPCodePos + 4 ],
*( ( long * ) &( pFunc->pCode[ lPCodePos + 1 ] ) ) );
lPCodePos +=( 1 + sizeof(long) );
break;
case _PUSHMEMVAR:
wVar = pFunc->pCode[ lPCodePos + 1 ] +
pFunc->pCode[ lPCodePos + 2 ] * 256;
fprintf( yyc, " _PUSHMEMVAR, %i, %i,\t/* %s */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ],
GetSymbolOrd( wVar + ! _iStartProc )->szName );
lPCodePos += 3;
break;
case _PUSHMEMVARREF:
wVar = pFunc->pCode[ lPCodePos + 1 ] +
pFunc->pCode[ lPCodePos + 2 ] * 256;
fprintf( yyc, " _PUSHMEMVARREF, %i, %i,\t/* %s */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ],
GetSymbolOrd( wVar + ! _iStartProc )->szName );
lPCodePos += 3;
break;
case _PUSHNIL:
fprintf( yyc, " _PUSHNIL,\n" );
lPCodePos++;
break;
case _PUSHSELF:
fprintf( yyc, " _PUSHSELF,\n" );
lPCodePos++;
break;
case _PUSHSTATIC:
{
PVAR pVar;
PFUNCTION pTmp = functions.pFirst;
wVar = pFunc->pCode[ lPCodePos + 1 ] +pFunc->pCode[ lPCodePos + 2 ] * 256;
while( pTmp->pNext && pTmp->pNext->wStaticsBase < wVar )
pTmp =pTmp->pNext;
pVar = GetVar( pTmp->pStatics, wVar - pTmp->wStaticsBase );
fprintf( yyc, " _PUSHSTATIC, %i, %i,\t/* %s */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ],
pVar->szName );
lPCodePos += 3;
}
break;
case _PUSHSTATICREF:
{
PVAR pVar;
PFUNCTION pTmp = functions.pFirst;
wVar = pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256;
while( pTmp->pNext && pTmp->pNext->wStaticsBase < wVar )
pTmp =pTmp->pNext;
pVar = GetVar( pTmp->pStatics, wVar - pTmp->wStaticsBase );
fprintf( yyc, " _PUSHSTATICREF, %i, %i,\t/* %s */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ],
pVar->szName );
lPCodePos += 3;
}
break;
case _PUSHSTR:
wLen = pFunc->pCode[ lPCodePos + 1 ] +
pFunc->pCode[ lPCodePos + 2 ] * 256;
fprintf( yyc, " _PUSHSTR, %i, %i, /* %i */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ], wLen );
lPCodePos +=3;
while( wLen-- )
{
chr = pFunc->pCode[ lPCodePos++ ];
if( chr == '\'' || chr == '\\')
fprintf( yyc, " \'\\%c\',", chr );
else
fprintf( yyc, " \'%c\',", chr );
}
fprintf( yyc, "\n" );
break;
case _PUSHSYM:
wSym = pFunc->pCode[ lPCodePos + 1 ] +
pFunc->pCode[ lPCodePos + 2 ] * 256;
fprintf( yyc, " _PUSHSYM, %i, %i, /* %s */\n",
pFunc->pCode[ lPCodePos + 1 ],
pFunc->pCode[ lPCodePos + 2 ],
GetSymbolOrd( wSym + ! _iStartProc )->szName );
lPCodePos += 3;
break;
case _RETVALUE:
fprintf( yyc, " _RETVALUE,\n" );
lPCodePos++;
break;
case _SFRAME:
/* we only generate it if there are statics used in this function */
if( pFunc->bFlags & FUN_USES_STATICS )
{
w = GetSymbolPos( _pInitFunc->szName ) - ( _iStartProc ? 1: 2 );
fprintf( yyc, " _SFRAME, %i, %i,\t\t/* symbol _INITSTATICS */\n",
LOBYTE( w ), HIBYTE( w ) );
}
lPCodePos += 3;
break;
case _STATICS:
{
w = GetSymbolPos( _pInitFunc->szName ) - ( _iStartProc ? 1: 2 );
fprintf( yyc, " _STATICS, %i, %i,\t\t/* symbol _INITSTATICS */\n",
LOBYTE( w ), HIBYTE( w ) );
lPCodePos += 3;
}
break;
case _TRUE:
fprintf( yyc, " _TRUE,\n" );
lPCodePos++;
break;
case _ZERO:
fprintf( yyc, " _ZERO,\n" );
lPCodePos++;
break;
default:
printf( "Incorrect pcode value!\n" );
lPCodePos = pFunc->lPCodePos;
break;
}
}
fprintf( yyc, "/* %05li */", lPCodePos );
fprintf( yyc, " _ENDPROC };\n\n" );
fprintf( yyc, " VirtualMachine( pcode, symbols );\n}\n\n" );
pFunc = pFunc->pNext;
}
fclose( yyc );
if( ! _iQuiet )
printf( "%s -> done!\n", szFileName );
}
void GenExterns( void ) /* generates the symbols for the EXTERN names */
{
PEXTERN pLast = pExterns, pDelete;
if( pExterns )
{
while( pLast )
{
PushSymbol( pLast->szName, 1 );
pLast = pLast->pNext;
}
pLast = pExterns;
pDelete = pExterns;
while( pLast )
{
pLast = pLast->pNext;
OurFree( pDelete );
pDelete = pLast;
}
pExterns = 0;
}
}
void GenReturn( WORD wOffset ) /* generates a return offset to later on fill it with the proper exiting pcode address */
{
PRETURN pReturn = ( PRETURN ) OurMalloc( sizeof( _RETURN ) ), pLast;
pReturn->wOffset = wOffset;
pReturn->pNext = 0;
if( ! pReturns )
pReturns = pReturn;
else
{
pLast = pReturns;
while( pLast->pNext )
pLast = pLast->pNext;
pLast->pNext = pReturn;
}
}
PFUNCTION GetFuncall( char * szFunctionName ) /* returns a previously called defined function */
{
PFUNCTION pFunc = funcalls.pFirst;
while( pFunc )
{
if( ! strcmp( pFunc->szName, szFunctionName ) )
return pFunc;
else
{
if( pFunc->pNext )
pFunc = pFunc->pNext;
else
return 0;
}
}
return 0;
}
PFUNCTION GetFunction( char * szFunctionName ) /* returns a previously defined function */
{
PFUNCTION pFunc = functions.pFirst;
while( pFunc )
{
if( ! strcmp( pFunc->szName, szFunctionName ) )
return pFunc;
else
{
if( pFunc->pNext )
pFunc = pFunc->pNext;
else
return 0;
}
}
return 0;
}
PVAR GetVar( PVAR pVars, WORD wOrder ) /* returns variable if defined or zero */
{
WORD w = 1;
while( pVars->pNext && w++ < wOrder )
pVars = pVars->pNext;
return pVars;
}
WORD GetVarPos( PVAR pVars, char * szVarName ) /* returns the order + 1 of a variable if defined or zero */
{
WORD wVar = 1;
while( pVars )
{
if( ! strcmp( pVars->szName, szVarName ) )
return wVar;
else
{
if( pVars->pNext )
{
pVars = pVars->pNext;
wVar++;
}
else
return 0;
}
}
return 0;
}
int GetLocalVarPos( char * szVarName ) /* returns the order + 1 of a variable if defined or zero */
{
int iVar;
PFUNCTION pFunc =functions.pLast;
if( pFunc->szName )
/* we are in a function/procedure -we don't need any tricks */
return GetVarPos( pFunc->pLocals, szVarName );
else
{
/* we are in a codeblock */
if( (iVar = GetVarPos( pFunc->pLocals, szVarName ) ) )
/* this a current codeblock parameter */
return iVar;
else
{
/* we have to check the list of nested codeblock up to a function
* where the codeblock is defined
*/
pFunc =pFunc->pOwner;
while( pFunc )
{
iVar =GetVarPos( pFunc->pLocals, szVarName );
if( iVar )
{
if( pFunc->pOwner )
/* this variable is defined in a parent codeblock
* It is not possible to access a parameter of a codeblock in which
* the current codeblock is defined
*/
GenError( ERR_OUTER_VAR, szVarName, NULL );
else
{
/* We want to access a local variable defined in a function that
* owns this codeblock. We cannot access this variable in a normal
* way because at runtime the stack base will point to local
* variables of EVAL function.
* The codeblock cannot have static variables then we can use this
* structure to store temporarily all referenced local variables
*/
pFunc =functions.pLast;
iVar =GetVarPos( pFunc->pStatics, szVarName );
if( !iVar )
{
/* this variable was not referenced yet - add it to the list */
PVAR pVar;
pVar =(PVAR) OurMalloc( sizeof(PVAR) );
pVar->szName =szVarName;
pVar->pNext =NULL;
iVar =1; /* first variable */
if( ! pFunc->pStatics )
pFunc->pStatics = pVar;
else
{
PVAR pLastVar = pFunc->pStatics;
++iVar; /* this will be at least second variable */
while( pLastVar->pNext )
{
pLastVar = pLastVar->pNext;
++iVar;
}
pLastVar->pNext = pVar;
}
}
/* Use negative order to signal that we are accessing a local
* variable from a codeblock
*/
return (-iVar);
}
}
pFunc =pFunc->pOwner;
}
}
}
return 0;
}
/*
* Gets position of passed static variables.
* All static variables are hold in a single array at runtime then positions
* are numbered for whole PRG module.
*/
int GetStaticVarPos( char *szVarName )
{
int iPos;
PFUNCTION pFunc = functions.pLast;
/* First we have to check if this name belongs to a static variable
* defined in current function
*/
if( pFunc->pOwner )
pFunc =pFunc->pOwner; /* we are in the static variable definition state */
iPos =GetVarPos( pFunc->pStatics, szVarName );
if( iPos )
return iPos + pFunc->wStaticsBase;
/* Next we have to check the list of global static variables
* Note: It is not possible to have global static variables when
* implicit starting procedure is defined
*/
if( !_iStartProc )
{
iPos =GetVarPos( functions.pFirst->pStatics, szVarName );
if( iPos )
return iPos;
}
return 0;
}
PCOMSYMBOL GetSymbol( char * szSymbolName ) /* returns a symbol pointer from the symbol table */
{
PCOMSYMBOL pSym = symbols.pFirst;
while( pSym )
{
if( ! strcmp( pSym->szName, szSymbolName ) && pSym != symbols.pFirst )
return pSym;
else
{
if( pSym->pNext )
pSym = pSym->pNext;
else
return 0;
}
}
return 0;
}
PCOMSYMBOL GetSymbolOrd( WORD wSymbol ) /* returns a symbol based on its index on the symbol table */
{
PCOMSYMBOL pSym = symbols.pFirst;
WORD w = 0;
while( w++ < wSymbol && pSym->pNext )
pSym = pSym->pNext;
return pSym;
}
WORD GetSymbolPos( char * szSymbolName ) /* return 0 if not found or order + 1 */
{
PCOMSYMBOL pSym = symbols.pFirst;
WORD wSymbol = 1;
while( pSym )
{
if( ! strcmp( pSym->szName, szSymbolName ) && pSym != symbols.pFirst )
return wSymbol;
else
{
if( pSym->pNext )
{
pSym = pSym->pNext;
wSymbol++;
}
else
return 0;
}
}
return 0;
}
void Inc( void )
{
GenPCode1( _INC );
}
WORD Jump( int iOffset )
{
GenPCode3( _JUMP, LOBYTE( iOffset ), HIBYTE( iOffset ) );
return functions.pLast->lPCodePos - 2;
}
WORD JumpFalse( int iOffset )
{
GenPCode3( _JUMPFALSE, LOBYTE( iOffset ), HIBYTE( iOffset ) );
return functions.pLast->lPCodePos - 2;
}
void JumpThere( int iOffset, WORD wTo )
{
BYTE * pCode = functions.pLast->pCode;
pCode[ ( WORD ) iOffset ] = LOBYTE( wTo - iOffset + 1 );
pCode[ ( WORD ) iOffset + 1 ] = HIBYTE( wTo - iOffset + 1 );
}
void JumpHere( int iOffset )
{
JumpThere( iOffset, functions.pLast->lPCodePos );
}
WORD JumpTrue( int iOffset )
{
GenPCode3( _JUMPTRUE, LOBYTE( iOffset ), HIBYTE( iOffset ) );
return functions.pLast->lPCodePos - 2;
}
void Line( void ) /* generates the pcode with the currently compiled source code line */
{
if( _iLineNumbers )
GenPCode3( _LINE, LOBYTE( iLine ), HIBYTE( iLine ) );
}
void LineBody( void ) /* generates the pcode with the currently compiled source code line */
{
/* This line can be placed inside a procedure or function only */
if( ! _iStartProc && functions.iCount <= 1 )
{
GenError( ERR_OUTSIDE, NULL, NULL );
}
functions.pLast->bFlags |= FUN_STATEMENTS;
if( _iLineNumbers )
GenPCode3( _LINE, LOBYTE( iLine ), HIBYTE( iLine ) );
}
void Message( char * szMsgName ) /* sends a message to an object */
{
WORD wSym = GetSymbolPos( szMsgName );
if( ! wSym ) /* the symbol was not found on the symbol table */
{
AddSymbol( szMsgName );
wSym = symbols.iCount;
}
GetSymbolOrd( wSym - 1 )->cScope = FS_MESSAGE;
wSym -= _iStartProc ? 1: 2;
GenPCode3( _MESSAGE, LOBYTE( wSym ), HIBYTE( wSym ) );
}
void PopId( char * szVarName ) /* generates the pcode to pop a value from the virtual machine stack onto a variable */
{
WORD wVar;
if( ( wVar = GetLocalVarPos( szVarName ) ) )
GenPCode3( _POPLOCAL, LOBYTE( wVar ), HIBYTE( wVar ) );
else if( ( wVar = GetStaticVarPos( szVarName ) ) )
GenPCode3( _POPSTATIC, LOBYTE( wVar ), HIBYTE( wVar ) );
else if( ( wVar = GetSymbolPos( szVarName ) - _iStartProc ? 1: 2 ) )
GenPCode3( _POPMEMVAR, LOBYTE( wVar ), HIBYTE( wVar ) );
else
{
AddSymbol( szVarName );
wVar = GetSymbolPos( szVarName ) - _iStartProc ? 1: 2;
GenPCode3( _POPMEMVAR, LOBYTE( wVar ), HIBYTE( wVar ) );
}
}
void PushId( char * szVarName ) /* generates the pcode to push a variable value to the virtual machine stack */
{
WORD wVar;
if( iVarScope == VS_STATIC )
{
/* Reffering to any variable is not allowed during initialization
* of static variable
*/
_pInitFunc->bFlags |= FUN_ILLEGAL_INIT;
}
if( ( wVar = GetLocalVarPos( szVarName ) ) )
GenPCode3( _PUSHLOCAL, LOBYTE( wVar ), HIBYTE( wVar ) );
else if( ( wVar = GetStaticVarPos( szVarName ) ) )
GenPCode3( _PUSHSTATIC, LOBYTE( wVar ), HIBYTE( wVar ) );
else if( ( wVar = GetSymbolPos( szVarName ) - _iStartProc ? 1: 2 ) )
GenPCode3( _PUSHMEMVAR, LOBYTE( wVar ), HIBYTE( wVar ) );
else
{
AddSymbol( szVarName );
wVar = GetSymbolPos( szVarName ) - _iStartProc ? 1: 2;
GenPCode3( _PUSHMEMVAR, LOBYTE( wVar ), HIBYTE( wVar ) );
}
}
void PushIdByRef( char * szVarName ) /* generates the pcode to push a variable by reference to the virtual machine stack */
{
WORD wVar;
if( iVarScope == VS_STATIC )
{
/* Reffering to any variable is not allowed during initialization
* of static variable
*/
_pInitFunc->bFlags |= FUN_ILLEGAL_INIT;
}
if( ( wVar = GetLocalVarPos( szVarName ) ) )
GenPCode3( _PUSHLOCALREF, LOBYTE( wVar ), HIBYTE( wVar ) );
else if( ( wVar = GetStaticVarPos( szVarName ) ) )
GenPCode3( _PUSHSTATICREF, LOBYTE( wVar ), HIBYTE( wVar ) );
else if( ( wVar = GetSymbolPos( szVarName ) - _iStartProc ? 1: 2) )
GenPCode3( _PUSHMEMVARREF, LOBYTE( wVar ), HIBYTE( wVar ) );
else
{
AddSymbol( szVarName );
wVar = GetSymbolPos( szVarName ) - _iStartProc ? 1: 2;
GenPCode3( _PUSHMEMVARREF, LOBYTE( wVar ), HIBYTE( wVar ) );
}
}
void PushLogical( int iTrueFalse ) /* pushes a logical value on the virtual machine stack */
{
if( iTrueFalse )
GenPCode1( _TRUE );
else
GenPCode1( _FALSE );
}
void PushNil( void )
{
GenPCode1( _PUSHNIL );
}
/* generates the pcode to push a double number on the virtual machine stack */
void PushDouble( double dNumber )
{
if( dNumber )
{
GenPCode1( _PUSHDOUBLE );
GenPCodeN( ( BYTE * ) &dNumber, sizeof( double ) );
}
else
GenPCode1( _ZERO );
}
/* generates the pcode to push a integer number on the virtual machine stack */
void PushInteger( int iNumber )
{
if( iNumber )
GenPCode3( _PUSHINT, LOBYTE( ( WORD ) iNumber ), HIBYTE( ( WORD ) iNumber ) );
else
GenPCode1( _ZERO );
}
/* generates the pcode to push a long number on the virtual machine stack */
void PushLong( long lNumber )
{
if( lNumber )
{
GenPCode1( _PUSHLONG );
GenPCode1( ( ( char * ) &lNumber )[ 0 ] );
GenPCode1( ( ( char * ) &lNumber )[ 1 ] );
GenPCode1( ( ( char * ) &lNumber )[ 2 ] );
GenPCode1( ( ( char * ) &lNumber )[ 3 ] );
}
else
GenPCode1( _ZERO );
}
/* generates the pcode to push a string on the virtual machine stack */
void PushString( char * szText )
{
WORD wStrLen = strlen( szText );
GenPCode3( _PUSHSTR, LOBYTE(wStrLen), HIBYTE(wStrLen) );
GenPCodeN( ( BYTE * ) szText, wStrLen );
}
/* generates the pcode to push a symbol on the virtual machine stack */
void PushSymbol( char * szSymbolName, int iIsFunction )
{
WORD wSym;
if( iIsFunction )
{
char * *pName = (char * *)RESERVED_FUNC( szSymbolName );
if( pName )
szSymbolName =*pName;
}
wSym = GetSymbolPos( szSymbolName ); /* returns 1, 2, ... */
if( wSym == 1 ) /* default module name procedure */
wSym = 0;
if( ! wSym ) /* the symbol was not found on the symbol table */
{
AddSymbol( szSymbolName );
wSym = symbols.iCount;
if( iIsFunction )
AddFunCall( szSymbolName );
}
else
{
if( iIsFunction && ! GetFuncall( szSymbolName ) )
AddFunCall( szSymbolName );
}
wSym -= _iStartProc ? 1: 2;
if( ! iIsFunction )
GetSymbolOrd( wSym )->cScope = FS_MESSAGE;
GenPCode3( _PUSHSYM, LOBYTE( wSym ), HIBYTE( wSym ) );
}
void CheckDuplVars( PVAR pVar, char * szVarName, int iVarScope )
{
while( pVar )
{
if( ! strcmp( pVar->szName, szVarName ) )
{
if( iVarScope != VS_PARAMETER )
--iLine;
GenError( ERR_VAR_DUPL, szVarName, NULL );
}
else
pVar =pVar->pNext;
}
}
void Dec( void )
{
GenPCode1( _DEC );
}
void DimArray( WORD wDimensions )
{
GenPCode3( _DIMARRAY, LOBYTE( wDimensions ), HIBYTE( wDimensions ) );
}
void Do( BYTE bParams )
{
GenPCode3( _DO, bParams, 0 );
}
void FixElseIfs( void * pFixElseIfs )
{
PELSEIF pFix = ( PELSEIF ) pFixElseIfs;
while( pFix )
{
JumpHere( pFix->wOffset );
pFix = pFix->pNext;
}
}
void FixReturns( void ) /* fixes all last defined function returns jumps offsets */
{
PRETURN pLast = pReturns, pDelete;
if( pReturns )
{
while( pLast )
{
JumpHere( pLast->wOffset );
pLast = pLast->pNext;
}
pLast = pReturns;
pDelete = pReturns;
while( pLast )
{
pLast = pLast->pNext;
OurFree( pDelete );
pDelete = pLast;
}
pReturns = 0;
}
}
void Function( BYTE bParams )
{
GenPCode3( _FUNCTION, bParams, 0 );
}
void GenArray( WORD wElements )
{
GenPCode3( _GENARRAY, LOBYTE( wElements ), HIBYTE( wElements ) );
}
void GenPCode1( BYTE byte )
{
PFUNCTION pFunc = functions.pLast; /* get the currently defined Clipper function */
if( ! pFunc->pCode ) /* has been created the memory block to hold the pcode ? */
{
pFunc->pCode = (BYTE *) OurMalloc( PCODE_CHUNK );
pFunc->lPCodeSize = PCODE_CHUNK;
pFunc->lPCodePos = 0;
}
else
if( ( pFunc->lPCodeSize - pFunc->lPCodePos ) < 1 )
pFunc->pCode = (BYTE *)OurRealloc( pFunc->pCode, pFunc->lPCodeSize += PCODE_CHUNK );
pFunc->pCode[ pFunc->lPCodePos++ ] = byte;
}
void GenPCode3( BYTE byte1, BYTE byte2, BYTE byte3 )
{
PFUNCTION pFunc = functions.pLast; /* get the currently defined Clipper function */
if( ! pFunc->pCode ) /* has been created the memory block to hold the pcode ? */
{
pFunc->pCode = (BYTE *) OurMalloc( PCODE_CHUNK );
pFunc->lPCodeSize = PCODE_CHUNK;
pFunc->lPCodePos = 0;
}
else
if( ( pFunc->lPCodeSize - pFunc->lPCodePos ) < 3 )
pFunc->pCode = (BYTE *) OurRealloc( pFunc->pCode, pFunc->lPCodeSize += PCODE_CHUNK );
pFunc->pCode[ pFunc->lPCodePos++ ] = byte1;
pFunc->pCode[ pFunc->lPCodePos++ ] = byte2;
pFunc->pCode[ pFunc->lPCodePos++ ] = byte3;
}
void GenPCodeN( BYTE * pBuffer, WORD wSize )
{
PFUNCTION pFunc = functions.pLast; /* get the currently defined Clipper function */
if( ! pFunc->pCode ) /* has been created the memory block to hold the pcode ? */
{
pFunc->lPCodeSize = ((wSize / PCODE_CHUNK) +1) * PCODE_CHUNK;
pFunc->pCode = (BYTE *) OurMalloc( pFunc->lPCodeSize );
pFunc->lPCodePos = 0;
}
else if( pFunc->lPCodePos + wSize > pFunc->lPCodeSize )
{
/* not enough free space in pcode buffer - increase it */
pFunc->lPCodeSize +=( ((wSize / PCODE_CHUNK) +1) * PCODE_CHUNK );
pFunc->pCode = (BYTE *) OurRealloc( pFunc->pCode, pFunc->lPCodeSize );
}
memcpy( pFunc->pCode+pFunc->lPCodePos, pBuffer, wSize );
pFunc->lPCodePos +=wSize;
}
char * SetData( char * szMsg ) /* generates an underscore-symbol name for a data assignment */
{
char * szResult = ( char * ) OurMalloc( strlen( szMsg ) + 2 );
strcpy( szResult, "_" );
strcat( szResult, szMsg );
return szResult;
}
void SetFrame( void ) /* generates the proper _FRAME values */
{
BYTE * pCode = functions.pLast->pCode;
PVAR pLocal = functions.pLast->pLocals;
BYTE bLocals = 0;
while( pLocal )
{
pLocal = pLocal->pNext;
bLocals++;
}
pCode[ 1 ] = bLocals - functions.pLast->wParamCount;
pCode[ 2 ] = functions.pLast->wParamCount;
}
/*
* Start a new fake-function that will hold pcodes for a codeblock
*/
void CodeBlockStart()
{
PFUNCTION pFunc;
pFunc =FunctionNew( NULL, FS_STATIC );
pFunc->pOwner = functions.pLast;
pFunc->wStaticsBase = functions.pLast->wStaticsBase;
functions.pLast = pFunc;
}
void CodeBlockEnd()
{
PFUNCTION pCodeblock; /* pointer to the current codeblock */
PFUNCTION pFunc; /* poiter to a function that owns a codeblock */
WORD wSize;
WORD wLocals = 0; /* number of referenced local variables */
WORD wPos;
PVAR pVar, pFree;
pCodeblock =functions.pLast;
/* return to pcode buffer of function/codeblock in which the current
* codeblock was defined
*/
functions.pLast =pCodeblock->pOwner;
/* find the function that owns the codeblock */
pFunc =pCodeblock->pOwner;
while( pFunc->pOwner )
pFunc =pFunc->pOwner;
/* generate a proper codeblock frame with a codeblock size and with
* a number of expected parameters
*/
/*QUESTION: would be 64kB enough for a codeblock size?
* we are assuming now a WORD for a size of codeblock
*/
/* Count the number of referenced local variables */
pVar =pCodeblock->pStatics;
while( pVar )
{
pVar =pVar->pNext;
++wLocals;
}
/*NOTE: 8 = _PUSHBLOCK + WORD(size) + WORD(wParams) + WORD(wLocals) +_ENDBLOCK */
wSize =( WORD ) pCodeblock->lPCodePos +8 +wLocals*2;
GenPCode3( _PUSHBLOCK, LOBYTE(wSize), HIBYTE(wSize) );
GenPCode1( LOBYTE(pCodeblock->wParamCount) );
GenPCode1( HIBYTE(pCodeblock->wParamCount) );
GenPCode1( LOBYTE(wLocals) );
GenPCode1( HIBYTE(wLocals) );
/* generate the table of referenced local variables */
pVar =pCodeblock->pStatics;
while( wLocals-- )
{
wPos =GetVarPos( pFunc->pLocals, pVar->szName );
GenPCode1( LOBYTE(wPos) );
GenPCode1( HIBYTE(wPos) );
pFree =pVar;
pVar =pVar->pNext;
OurFree( pFree->szName );
OurFree( pFree );
}
GenPCodeN( pCodeblock->pCode, pCodeblock->lPCodePos );
GenPCode1( _ENDBLOCK ); /* finish the codeblock */
/* this fake-function is no longer needed */
OurFree( pCodeblock->pCode )
pVar =pCodeblock->pLocals;
while( pVar )
{
/* free used variables */
pFree =pVar;
pVar =pVar->pNext;
OurFree( pFree->szName );
OurFree( pFree );
}
OurFree( pCodeblock );
}
/* Set the name of an alias for the list of previously declared FIELDs
*
* szAlias -> name of the alias
* iField -> position of the first FIELD name to change
*/
void SetAlias( char * szAlias, int iField )
{
PVAR pVar;
pVar = functions.pLast->pFields;
while( iField-- && pVar )
pVar = pVar->pNext;
while( pVar )
{
pVar->szAlias =szAlias;
pVar =pVar->pNext;
}
}
/* This functions counts the number of FIELD declaration in a function
* We will required this information in SetAlias function
*/
int FieldsCount()
{
int iFields = 0;
PVAR pVar = functions.pLast->pFields;
while( pVar )
{
++iFields;
pVar =pVar->pNext;
}
return iFields;
}
/*
* Start of definition of static variable
* We are using here the special function _pInitFunc which will store
* pcode needed to initialize all static variables declared in PRG module.
* pOwner member will point to a function where the static variable is
* declared:
* TODO: support for static variables in codeblock
*/
void StaticDefStart( void )
{
iVarScope =VS_STATIC;
Line();
functions.pLast->bFlags |= FUN_USES_STATICS;
if( ! _pInitFunc )
{
_pInitFunc =FunctionNew( "_INITSTATICS", FS_INIT );
_pInitFunc->pOwner =functions.pLast;
_pInitFunc->bFlags =FUN_USES_STATICS | FUN_PROCEDURE;
functions.pLast =_pInitFunc;
PushInteger( 1 ); /* the number of static variables is unknown now */
GenPCode3( _STATICS, 0, 0 );
GenPCode3( _SFRAME, 0, 0 ); /* frame for statics variables */
}
else
{
_pInitFunc->pOwner =functions.pLast;
functions.pLast =_pInitFunc;
}
}
/*
* End of definition of static variable
* Return to previously pcoded function.
*/
void StaticDefEnd( WORD wCount )
{
functions.pLast =_pInitFunc->pOwner;
_pInitFunc->pOwner =NULL;
_wStatics += wCount;
iVarScope =0;
}
/*
* This function checks if we are initializing a static variable.
* It should be called only in case when the parser have recognized any
* function or method invocation.
*/
void StaticAssign( void )
{
if( iVarScope == VS_STATIC )
_pInitFunc->bFlags |= FUN_ILLEGAL_INIT;
}
void * OurMalloc( LONG lSize )
{
void * pMem = malloc( lSize );
if( ! pMem )
yyerror( "\nCan't allocate memory!\n" );
return pMem;
}
void * OurRealloc( void * p, LONG lSize )
{
void * pMem = realloc( p, lSize );
if( ! pMem )
yyerror( "\nCan't reallocate memory!\n" );
return pMem;
}
#ifndef HAVE_STRUPR
char * strupr( char * p )
{
char * p1;
for ( p1 = p; * p1; p1++ )
* p1 = toupper( * p1 );
return( p );
}
#endif
Reference in New Issue View Git Blame Copy Permalink