自学教程：C++ HB_COMP_EXPR_NEW函数代码示例

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