/* Creates a new literal hash { key1=>val1, key2=>val2, ... keyN=>valN } * 'pHashList' is a list of hash items */ PHB_EXPR hb_compExprNewHash( PHB_EXPR pHashList, HB_COMP_DECL ) { PHB_EXPR pExpr; HB_TRACE( HB_TR_DEBUG, ( "hb_compExprNewHash()" ) ); if( pHashList ) pHashList->ExprType = HB_ET_HASH; /* change type from ET_LIST */ else { pHashList = HB_COMP_EXPR_NEW( HB_ET_HASH ); pHashList->value.asList.pExprList = NULL; } pHashList->ValType = HB_EV_HASH; pHashList->nLength = 0; pHashList->value.asList.reference = HB_FALSE; pHashList->value.asList.pIndex = NULL; /* * replace all EO_NONE expressions with ET_NIL expressions and * calculate the list length */ pExpr = pHashList->value.asList.pExprList; while( pExpr ) { if( pExpr->ExprType == HB_ET_NONE ) pExpr->ExprType = HB_ET_NIL; pExpr = pExpr->pNext; ++pHashList->nLength; } return pHashList; }
/* Creates new macro send expression * : &<msg> -> ( expression ) */ PHB_EXPR hb_compExprNewMacroSend( PHB_EXPR pMessage, HB_COMP_DECL ) { PHB_EXPR pExpr; HB_TRACE( HB_TR_DEBUG, ( "hb_compExprNewMacroSend(%p,%p)", pMessage, HB_COMP_PARAM ) ); pExpr = HB_COMP_EXPR_NEW( HB_ET_SEND ); pExpr->value.asMessage.pObject = NULL; pExpr->value.asMessage.pParms = NULL; pExpr->value.asMessage.szMessage = NULL; pExpr->value.asMessage.pMessage = pMessage; pExpr->nLength = 0; if( pMessage->ExprType == HB_ET_MACRO ) { /* Signal that macro compiler have to generate a pcode that will * return function name as symbol instead of usual value */ pMessage->value.asMacro.SubType = HB_ET_MACRO_SYMBOL; } return pExpr; }
PHB_EXPR hb_compExprNewEqual( PHB_EXPR pLeftExpr, HB_COMP_DECL ) { PHB_EXPR pExpr = HB_COMP_EXPR_NEW( HB_EO_EQUAL ); pExpr->value.asOperator.pLeft = pLeftExpr; pExpr->value.asOperator.pRight = NULL; return pExpr; }
PHB_EXPR hb_compExprNewPreDec( PHB_EXPR pLeftExpr, HB_COMP_DECL ) { PHB_EXPR pExpr = HB_COMP_EXPR_NEW( HB_EO_PREDEC ); pExpr->value.asOperator.pLeft = pLeftExpr; pExpr->value.asOperator.pRight = NULL; return pExpr; }
PHB_EXPR hb_compExprNewMultEq( PHB_EXPR pLeftExpr, HB_COMP_DECL ) { PHB_EXPR pExpr = HB_COMP_EXPR_NEW( HB_EO_MULTEQ ); pExpr->value.asOperator.pLeft = pLeftExpr; pExpr->value.asOperator.pRight = NULL; return pExpr; }
/* Create a new symbol used in an alias expressions */ PHB_EXPR hb_compExprNewAlias( const char * szName, HB_COMP_DECL ) { PHB_EXPR pExpr; HB_TRACE( HB_TR_DEBUG, ( "hb_compExprNewAlias(%s,%p)", szName, HB_COMP_PARAM ) ); pExpr = HB_COMP_EXPR_NEW( HB_ET_ALIAS ); pExpr->value.asSymbol.name = szName; return pExpr; }
PHB_EXPR hb_compExprNewVar( const char * szName, HB_COMP_DECL ) { PHB_EXPR pExpr; HB_TRACE( HB_TR_DEBUG, ( "hb_compExprNewVar(%s,%p)", szName, ( void * ) HB_COMP_PARAM ) ); pExpr = HB_COMP_EXPR_NEW( HB_ET_VARIABLE ); pExpr->value.asSymbol.name = szName; return pExpr; }
PHB_EXPR hb_compExprNewSelf( HB_COMP_DECL ) { PHB_EXPR pExpr; HB_TRACE( HB_TR_DEBUG, ( "hb_compExprNewSelf(%p)", HB_COMP_PARAM ) ); pExpr = HB_COMP_EXPR_NEW( HB_ET_SELF ); pExpr->ValType = HB_EV_OBJECT; return pExpr; }
/* Creates a list of function call arguments */ PHB_EXPR hb_compExprNewArgList( PHB_EXPR pFirstItem, HB_COMP_DECL ) { PHB_EXPR pExpr; HB_TRACE( HB_TR_DEBUG, ( "hb_compExprNewArgList()" ) ); pExpr = HB_COMP_EXPR_NEW( HB_ET_ARGLIST ); pExpr->value.asList.pExprList = pFirstItem; pExpr->value.asList.reference = HB_FALSE; return pExpr; }
/* Creates a reference to variable arguments */ PHB_EXPR hb_compExprNewArgRef( HB_COMP_DECL ) { PHB_EXPR pExpr; HB_TRACE( HB_TR_DEBUG, ( "hb_compExprNewArgRef()" ) ); pExpr = HB_COMP_EXPR_NEW( HB_ET_ARGLIST ); pExpr->value.asList.pExprList = NULL; pExpr->value.asList.reference = HB_TRUE; return pExpr; }
PHB_EXPR hb_compExprNewNil( HB_COMP_DECL ) { PHB_EXPR pExpr; HB_TRACE( HB_TR_DEBUG, ( "hb_compExprNewNil(%p)", HB_COMP_PARAM ) ); pExpr = HB_COMP_EXPR_NEW( HB_ET_NIL ); pExpr->ValType = HB_EV_NIL; return pExpr; }
PHB_EXPR hb_compExprNewRef( PHB_EXPR pRefer, HB_COMP_DECL ) { PHB_EXPR pExpr; HB_TRACE( HB_TR_DEBUG, ( "hb_compExprNewRef(%p,%p)", pRefer, HB_COMP_PARAM ) ); pExpr = HB_COMP_EXPR_NEW( HB_ET_REFERENCE ); pExpr->value.asReference = pRefer; pExpr->ValType = HB_EV_VARREF; return pExpr; }
PHB_EXPR hb_compExprNewVarRef( const char * szVarName, HB_COMP_DECL ) { PHB_EXPR pExpr; HB_TRACE( HB_TR_DEBUG, ( "hb_compExprNewVarRef(%s,%p)", szVarName, HB_COMP_PARAM ) ); pExpr = HB_COMP_EXPR_NEW( HB_ET_VARREF ); pExpr->value.asSymbol.name = szVarName; pExpr->ValType = HB_EV_VARREF; return pExpr; }
/* Create a new symbol used in function calls */ PHB_EXPR hb_compExprNewFunName( const char * szName, HB_COMP_DECL ) { PHB_EXPR pExpr; HB_TRACE( HB_TR_DEBUG, ( "hb_compExprNewFunName(%s,%p)", szName, HB_COMP_PARAM ) ); pExpr = HB_COMP_EXPR_NEW( HB_ET_FUNNAME ); pExpr->value.asSymbol.name = hb_compGetFuncID( szName, &pExpr->value.asSymbol.funcid, &pExpr->value.asSymbol.flags ); return pExpr; }
/* Handles (expression := expression) syntax */ PHB_EXPR hb_compExprAssign( PHB_EXPR pLeftExpr, PHB_EXPR pRightExpr, HB_COMP_DECL ) { PHB_EXPR pExpr; HB_TRACE( HB_TR_DEBUG, ( "hb_compExprAssign()" ) ); pExpr = HB_COMP_EXPR_NEW( HB_EO_ASSIGN ); pExpr->value.asOperator.pLeft = pLeftExpr; pExpr->value.asOperator.pRight = pRightExpr; return pExpr; }
PHB_EXPR hb_compExprNewLogical( int iValue, HB_COMP_DECL ) { PHB_EXPR pExpr; HB_TRACE( HB_TR_DEBUG, ( "hb_compExprNewLogical(%i,%p)", iValue, HB_COMP_PARAM ) ); pExpr = HB_COMP_EXPR_NEW( HB_ET_LOGICAL ); pExpr->value.asLogical = iValue; pExpr->ValType = HB_EV_LOGICAL; return pExpr; }
/* Creates a set/get codeblock for passed expression used in __GET * * {| ~1 | iif( ~1 == NIL, <pExpr>, <pExpr> := ~1 ) } * * NOTE: "~1" is not a valid variable name so there will be no collisions */ PHB_EXPR hb_compExprSetGetBlock( PHB_EXPR pExpr, HB_COMP_DECL ) { PHB_EXPR pSet; /* create setget expression: IIF( var==NIL, <pExpr>, <pExpr>:=var ) */ pSet = HB_COMP_EXPR_NEW( HB_ET_SETGET ); pSet->value.asSetGet.pVar = hb_compExprNewVar( "~1", HB_COMP_PARAM ); pSet->value.asSetGet.pExpr = pExpr; /* create a codeblock */ return hb_compExprAddCodeblockExpr( hb_compExprCBVarAdd( hb_compExprNewCodeBlock( NULL, 0, 0, HB_COMP_PARAM ), "~1", ' ', HB_COMP_PARAM ), pSet ); }
PHB_EXPR hb_compExprNewTimeStamp( long lDate, long lTime, HB_COMP_DECL ) { PHB_EXPR pExpr; HB_TRACE( HB_TR_DEBUG, ( "hb_compExprNewTimeStamp(%ld, %ld, %p)", lDate, lTime, HB_COMP_PARAM ) ); pExpr = HB_COMP_EXPR_NEW( HB_ET_TIMESTAMP ); pExpr->value.asDate.lDate = lDate; pExpr->value.asDate.lTime = lTime; pExpr->ValType = HB_EV_TIMESTAMP; return pExpr; }
PHB_EXPR hb_compExprNewFunRef( const char * szFunName, HB_COMP_DECL ) { PHB_EXPR pExpr; HB_TRACE( HB_TR_DEBUG, ( "hb_compExprNewFunRef(%s,%p)", szFunName, ( void * ) HB_COMP_PARAM ) ); pExpr = HB_COMP_EXPR_NEW( HB_ET_FUNREF ); pExpr->value.asSymbol.name = hb_compGetFuncID( szFunName, &pExpr->value.asSymbol.funcid, &pExpr->value.asSymbol.flags ); pExpr->ValType = HB_EV_FUNREF; return pExpr; }
/* It initializes static variable. * It is called in the following context: * STATIC sVar := expression * * pLeftExpr - is a variable name * pRightExpr - can be an expression of any type */ PHB_EXPR hb_compExprAssignStatic( PHB_EXPR pLeftExpr, PHB_EXPR pRightExpr, HB_COMP_DECL ) { PHB_EXPR pExpr; HB_TRACE( HB_TR_DEBUG, ( "hb_compExprAssignStatic()" ) ); pExpr = HB_COMP_EXPR_NEW( HB_EO_ASSIGN ); pExpr->value.asOperator.pLeft = pLeftExpr; /* Try to reduce the assigned value */ pRightExpr = HB_EXPR_USE( pRightExpr, HB_EA_REDUCE ); /* When -kc switch is used expression list is not stripped * in reduce operation */ if( ! HB_SUPPORT_HARBOUR ) pRightExpr = hb_compExprListStrip( pRightExpr, HB_COMP_PARAM ); pExpr->value.asOperator.pRight = pRightExpr; if( pRightExpr->ExprType == HB_ET_ARGLIST ) { /* HB_ET_ARGLIST is used in case of STATIC var[dim1, dim2, dimN] * was used - we have to check if all array dimensions are * constant values */ hb_compExprCheckStaticListInitializers( pLeftExpr, pRightExpr, HB_COMP_PARAM ); } else if( pRightExpr->ExprType == HB_ET_ARRAY ) { /* { elem1, elem2, elemN } was used as initializer * Scan an array for illegal initializers. * An array item have to be a const value too. */ hb_compExprCheckStaticListInitializers( pLeftExpr, pRightExpr, HB_COMP_PARAM ); } else if( pRightExpr->ExprType == HB_ET_HASH ) { /* { idx1=>var1, idx2=>var2, idxN=>varN } was used as initializer * Scan a hash array for illegal initializers. * A hash item have to be a const value too. */ hb_compExprCheckStaticListInitializers( pLeftExpr, pRightExpr, HB_COMP_PARAM ); } else { hb_compExprCheckStaticInitializer( pLeftExpr, pRightExpr, HB_COMP_PARAM ); } return pExpr; }
PHB_EXPR hb_compExprNewDate( long lDate, HB_COMP_DECL ) { PHB_EXPR pExpr; HB_TRACE( HB_TR_DEBUG, ( "hb_compExprNewDate(%ld, %p)", lDate, HB_COMP_PARAM ) ); pExpr = HB_COMP_EXPR_NEW( HB_ET_DATE ); pExpr->value.asDate.lDate = lDate; pExpr->value.asDate.lTime = 0; pExpr->ValType = HB_EV_DATE; return pExpr; }
/* Create a new declaration of PUBLIC or PRIVATE variable. * * szName is a string with variable name if 'PUBLIC varname' context * pMacroVar is a macro expression if 'PUBLIC &varname' context */ PHB_EXPR hb_compExprNewRTVar( const char * szName, PHB_EXPR pMacroVar, HB_COMP_DECL ) { PHB_EXPR pExpr; HB_TRACE( HB_TR_DEBUG, ( "hb_compExprNewRTVar(%s, %p, %p)", szName, pMacroVar, HB_COMP_PARAM ) ); pExpr = HB_COMP_EXPR_NEW( HB_ET_RTVAR ); pExpr->value.asRTVar.szName = szName; pExpr->value.asRTVar.pMacro = pMacroVar; if( pMacroVar ) pMacroVar->value.asMacro.SubType = HB_ET_MACRO_SYMBOL; return pExpr; }
PHB_EXPR hb_compExprNewString( const char * szValue, HB_SIZE nLen, HB_BOOL fDealloc, HB_COMP_DECL ) { PHB_EXPR pExpr; HB_TRACE( HB_TR_DEBUG, ( "hb_compExprNewString(%s)", szValue ) ); pExpr = HB_COMP_EXPR_NEW( HB_ET_STRING ); pExpr->value.asString.string = ( char * ) szValue; pExpr->value.asString.dealloc = fDealloc; pExpr->nLength = nLen; pExpr->ValType = HB_EV_STRING; return pExpr; }
PHB_EXPR hb_compExprNewLong( HB_MAXINT nValue, HB_COMP_DECL ) { PHB_EXPR pExpr; HB_TRACE( HB_TR_DEBUG, ( "hb_compExprNewLong(%" PFHL "d, %p)", nValue, HB_COMP_PARAM ) ); pExpr = HB_COMP_EXPR_NEW( HB_ET_NUMERIC ); pExpr->value.asNum.val.l = nValue; pExpr->value.asNum.bWidth = HB_DEFAULT_WIDTH; pExpr->value.asNum.bDec = 0; pExpr->value.asNum.NumType = HB_ET_LONG; pExpr->ValType = HB_EV_NUMERIC; return pExpr; }
PHB_EXPR hb_compExprNewCodeBlock( char * string, HB_SIZE nLen, int iFlags, HB_COMP_DECL ) { PHB_EXPR pExpr; HB_TRACE( HB_TR_DEBUG, ( "hb_compExprNewCodeBlock(%s,%" HB_PFS "u,%d,%p)", string, nLen, iFlags, HB_COMP_PARAM ) ); pExpr = HB_COMP_EXPR_NEW( HB_ET_CODEBLOCK ); pExpr->value.asCodeblock.pExprList = NULL; pExpr->value.asCodeblock.pLocals = NULL; /* this will hold local variables declarations */ pExpr->ValType = HB_EV_CODEBLOCK; pExpr->value.asCodeblock.flags = ( HB_USHORT ) iFlags; pExpr->value.asCodeblock.string = string; pExpr->nLength = nLen; return pExpr; }
/* Creates new send expression * : <msgid> -> ( expression ) */ PHB_EXPR hb_compExprNewSend( const char * szMessage, HB_COMP_DECL ) { PHB_EXPR pExpr; HB_TRACE( HB_TR_DEBUG, ( "hb_compExprNewSend(%s,%p)", szMessage, HB_COMP_PARAM ) ); pExpr = HB_COMP_EXPR_NEW( HB_ET_SEND ); pExpr->value.asMessage.pObject = NULL; pExpr->value.asMessage.pParms = NULL; pExpr->value.asMessage.szMessage = szMessage; pExpr->value.asMessage.pMessage = NULL; pExpr->nLength = 0; return pExpr; }
PHB_EXPR hb_compExprNewDouble( double dValue, HB_BYTE ucWidth, HB_BYTE ucDec, HB_COMP_DECL ) { PHB_EXPR pExpr; HB_TRACE( HB_TR_DEBUG, ( "hb_compExprNewDouble(%f, %i, %p)", dValue, ucDec, HB_COMP_PARAM ) ); pExpr = HB_COMP_EXPR_NEW( HB_ET_NUMERIC ); pExpr->value.asNum.val.d = dValue; pExpr->value.asNum.bWidth = ucWidth; pExpr->value.asNum.bDec = ucDec; pExpr->value.asNum.NumType = HB_ET_DOUBLE; pExpr->ValType = HB_EV_NUMERIC; return pExpr; }
PHB_EXPR hb_compExprNewNot( PHB_EXPR pNotExpr, HB_COMP_DECL ) { PHB_EXPR pExpr; if( pNotExpr->ExprType == HB_ET_LOGICAL ) { pNotExpr->value.asLogical = ! pNotExpr->value.asLogical; pExpr = pNotExpr; } else { pExpr = HB_COMP_EXPR_NEW( HB_EO_NOT ); pExpr->value.asOperator.pLeft = pNotExpr; pExpr->value.asOperator.pRight = NULL; } return pExpr; }
/* Creates new macro expression */ PHB_EXPR hb_compExprNewMacro( PHB_EXPR pMacroExpr, unsigned char cMacroOp, const char * szName, HB_COMP_DECL ) { PHB_EXPR pExpr; pExpr = HB_COMP_EXPR_NEW( HB_ET_MACRO ); if( szName ) { HB_TRACE( HB_TR_DEBUG, ( "hb_compExprNewMacro(%s)", szName ) ); /* Macro variable is used: &identifier * or macro text: [text]&variable[more_macro_text] */ /* * NOTE: Clipper assumes that all variables used in macro expressions * are memvar variables * NOTE: Clipper pushes the complete macro expression converted * to string in case complex expression is used, e.g. * My&var.1 * is pushed as: * "MY&VAR.1" */ pExpr->value.asMacro.cMacroOp = cMacroOp; /* '&' if variable or 0 if text */ pExpr->value.asMacro.szMacro = szName; /* variable name or macro text */ pExpr->value.asMacro.pExprList = NULL; /* this is not a parenthesized expressions */ pExpr->value.asMacro.SubType = HB_ET_MACRO_VAR; } else { HB_TRACE( HB_TR_DEBUG, ( "hb_compExprNewMacro(&)" ) ); /* Macro expression: &( expression_list ) */ pExpr->value.asMacro.cMacroOp = 0; pExpr->value.asMacro.szMacro = NULL; /* this is used to distinguish &(...) from &ident */ pExpr->value.asMacro.pExprList = pMacroExpr; pExpr->value.asMacro.SubType = HB_ET_MACRO_EXPR; } return pExpr; }
/* Creates new aliased variable * aliasexpr -> identifier */ PHB_EXPR hb_compExprNewAliasVar( PHB_EXPR pAlias, PHB_EXPR pVariable, HB_COMP_DECL ) { PHB_EXPR pExpr; HB_TRACE( HB_TR_DEBUG, ( "hb_compExprNewAliasVar()" ) ); pExpr = HB_COMP_EXPR_NEW( HB_ET_ALIASVAR ); pExpr->value.asAlias.pAlias = pAlias; pExpr->value.asAlias.pVar = pVariable; pExpr->value.asAlias.pExpList = NULL; /* macro expressions in alias context require a special handling */ if( pAlias->ExprType == HB_ET_MACRO ) pAlias->value.asMacro.SubType = HB_ET_MACRO_ALIASED; if( pVariable->ExprType == HB_ET_MACRO ) pVariable->value.asMacro.SubType = HB_ET_MACRO_ALIASED; return pExpr; }