Exemple #1
0
/*FUNCTION*/
pFixSizeMemoryObject memory_NewMortalArray(pMemoryObject pMo,
                                           pMortalList pMortal,
                                           long IndexLow,
                                           long IndexHigh
  ){
/*noverbatim
If the parameter T<pMortal> is T<NULL> the generated variable is not mortal.
CUT*/
  pFixSizeMemoryObject p;

  p = memory_NewArray(pMo,IndexLow,IndexHigh);
  if( p == NULL )return NULL;
  if( pMortal )
    memory_Mortalize(p,pMortal);
  return p;
  }
Exemple #2
0
/*FUNCTION*/
pFixSizeMemoryObject memory_CopyArray(pMemoryObject pMo,
                                      pFixSizeMemoryObject p
  ){
/*noverbatim
CUT*/
  long aLow,aHigh;
  pFixSizeMemoryObject result;
  long i;

  if( p == NULL )return NULL;
  if( p->vType != VTYPE_ARRAY )return NULL;
  aLow = p->ArrayLowLimit;
  aHigh = p->ArrayHighLimit;
  result = memory_NewArray(pMo,aLow,aHigh);
  if( result == NULL )return NULL;
  for( i=0 ; i <= aHigh-aLow ; i++ ){
    if( memory_IsUndef(p->Value.aValue[i]) )continue;
    switch(p->Value.aValue[i]->vType ){
      case VTYPE_ARRAY :
        result->Value.aValue[i] = memory_CopyArray(pMo,p->Value.aValue[i]);
        if( result->Value.aValue[i] == NULL )return NULL;
        continue;
      case VTYPE_LONG:
        result->Value.aValue[i] = memory_NewLong(pMo);
        if( result->Value.aValue[i] == NULL )return NULL;
        result->Value.aValue[i]->Value.lValue = p->Value.aValue[i]->Value.lValue;
        continue;
      case VTYPE_DOUBLE:
        result->Value.aValue[i] = memory_NewDouble(pMo);
        if( result->Value.aValue[i] == NULL )return NULL;
        result->Value.aValue[i]->Value.dValue = p->Value.aValue[i]->Value.dValue;
        continue;
      case VTYPE_STRING:
        result->Value.aValue[i] = memory_NewString(pMo,STRLEN(p->Value.aValue[i]));
        if( result->Value.aValue[i] == NULL )return NULL;
        memcpy(result->Value.aValue[i]->Value.pValue,
                    p->Value.aValue[i]->Value.pValue,STRLEN(p->Value.aValue[i]));
        continue;
      case VTYPE_REF:
        result->Value.aValue[i] = memory_NewRef(pMo);
        memory_SetRef(pMo,&(result->Value.aValue[i]),&(p->Value.aValue[i]));
        continue;
      }
    }
  return result;
  }
Exemple #3
0
/*FUNCTION*/
int hook_CallScribaFunction(pExecuteObject pEo,
                            unsigned long lStartNode,
                            pFixSizeMemoryObject *pArgument,
                            unsigned long NumberOfPassedArguments,
                            pFixSizeMemoryObject *pFunctionResult
  ){
/*noverbatim
CUT*/

  int iError;
  unsigned long SaveProgramCounter,SaveStepCounter;
  unsigned long SavefErrorGoto,SaveErrorGoto,SaveErrorResume;
  pFixSizeMemoryObject SaveLocalVariablesPointer;
  pFixSizeMemoryObject SaveFunctionResultPointer;
  MortalList _ThisCommandMortals=NULL;
  pMortalList _pThisCommandMortals = &_ThisCommandMortals;
  unsigned long _ActualNode=pEo->ProgramCounter;
  int iErrorCode;
  NODE nItem;
  unsigned long i;
  unsigned long NumberOfArguments;
  long Opcode;


  SaveLocalVariablesPointer = pEo->LocalVariables;
  SaveProgramCounter = pEo->ProgramCounter;
  pEo->ProgramCounter = lStartNode;
  if( pEo->ProgramCounter == 0 )return EXE_ERROR_USERFUN_UNDEFINED;

  SaveFunctionResultPointer = pEo->pFunctionResult;
  pEo->pFunctionResult = NULL;
  SaveStepCounter = pEo->lStepCounter;
  pEo->lStepCounter = 0;
  SaveErrorGoto = pEo->ErrorGoto;
  pEo->ErrorGoto = 0;
  SaveErrorResume = pEo->ErrorResume;
  pEo->ErrorResume = 0;
  SavefErrorGoto = pEo->fErrorGoto;
  pEo->fErrorGoto = ONERROR_NOTHING;

  nItem = pEo->CommandArray[pEo->ProgramCounter-1].Parameter.NodeList.actualm ;
  Opcode = pEo->CommandArray[nItem-1].OpCode;
  pEo->cLocalVariables = pEo->CommandArray[nItem-1].Parameter.CommandArgument.Argument.lLongValue;
  nItem = pEo->CommandArray[nItem-1].Parameter.CommandArgument.next;
  NumberOfArguments = pEo->CommandArray[nItem-1].Parameter.CommandArgument.Argument.lLongValue;
  nItem = pEo->CommandArray[nItem-1].Parameter.CommandArgument.next;
  nItem = pEo->CommandArray[nItem-1].Parameter.CommandArgument.Argument.lLongValue;

  if( pEo->cLocalVariables ){
    pEo->LocalVariables = memory_NewArray(pEo->pMo,1,pEo->cLocalVariables);
    if( pEo->LocalVariables == NULL )return COMMAND_ERROR_MEMORY_LOW;
    }else pEo->LocalVariables = NULL; /* it should have been null anyway */

  for( i=0 ; pArgument && i < NumberOfPassedArguments && i < NumberOfArguments ; i++ ){
     pEo->LocalVariables->Value.aValue[i]
        = memory_DupVar(pEo->pMo,
                        pArgument[i],
                        _pThisCommandMortals,
                        &iError);
     if( iError )return iError;
     }
  while( i < (unsigned)pEo->cLocalVariables ){
     pEo->LocalVariables->Value.aValue[i] = NULL;
     i++;
     }

  /* and finally we start to execute the function when executing the next command */
  pEo->lFunctionLevel++;
  /* some macros need this label */
// _FunctionFinishLabel: ;
  pEo->ProgramCounter = pEo->CommandArray[pEo->ProgramCounter-1].Parameter.NodeList.rest;
  execute_Execute_r(pEo,&iErrorCode);

  /* restore variables */

  pEo->lStepCounter = SaveStepCounter;
  if( pEo->LocalVariables )/* this is null if the function did not have arguments and no local variables */
    memory_ReleaseVariable(pEo->pMo,pEo->LocalVariables);
  pEo->ProgramCounter = SaveProgramCounter;
  pEo->LocalVariables = SaveLocalVariablesPointer;
  (*pFunctionResult) = pEo->pFunctionResult;
  pEo->pFunctionResult = SaveFunctionResultPointer;

  pEo->ErrorGoto = SaveErrorGoto;
  pEo->fErrorGoto = SavefErrorGoto;
  pEo->ErrorResume = SaveErrorResume;
  return iErrorCode;
  }