/* 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;
}
