gsmoper.cc

来自「Gambit 是一个游戏库理论软件」· CC 代码 · 共 2,227 行 · 第 1/5 页

#elif defined __BORLANDC__
  return new TextPortion("Windows 95/NT");
#else
  return new TextPortion("Unknown");
#endif
}
static Portion *GSM_Date(GSM &, Portion**)
{
  time_t now = time(0);
  gText AscTime = asctime(localtime(&now));
  return new TextPortion(AscTime.Mid(11, 1) +
			    AscTime.Mid(4, 21) + ", " + AscTime.Mid(8, 12));
}

static Portion *GSM_IsList(GSM &, Portion **param)
{
  return new BoolPortion(param[0]->Spec().ListDepth > 0);
}

void Init_gsmoper(GSM* gsm)
{
  gclFunction* FuncObj;

  static struct { char *sig; Portion *(*func)(GSM &, Portion **); } ftable[] =
    { { "And[x->BOOLEAN, y->BOOLEAN] =: BOOLEAN", GSM_And },
      { "Divide[x->NUMBER, y->NUMBER] =: NUMBER", GSM_Divide },
      { "Equal[x->BOOLEAN*, y->BOOLEAN*] =: BOOLEAN", GSM_Equal_Boolean },
      { "Equal[x->NUMBER*, y->NUMBER*] =: BOOLEAN", GSM_Equal_Number },
      { "Equal[x->TEXT*, y->TEXT*] =: BOOLEAN", GSM_Equal_Text },
      { "Equal[x->EFG*, y->EFG*] =: BOOLEAN", GSM_Equal_Efg },
      { "Equal[x->EFPLAYER*, y->EFPLAYER*] =: BOOLEAN", 
	GSM_Equal_EfPlayer },
      { "Equal[x->NODE*, y->NODE*] =: BOOLEAN", GSM_Equal_Node },
      { "Equal[x->INFOSET*, y->INFOSET*] =: BOOLEAN", GSM_Equal_Infoset },
      { "Equal[x->EFOUTCOME*, y->EFOUTCOME*] =: BOOLEAN",
	GSM_Equal_EfOutcome },
      { "Equal[x->ACTION*, y->ACTION*] =: BOOLEAN", GSM_Equal_Action },
      { "Equal[x->EFSUPPORT*, y->EFSUPPORT*] =: BOOLEAN", 
	GSM_Equal_EfSupport },
      { "Equal[x->BEHAV*, y->BEHAV*] =: BOOLEAN", GSM_Equal_Behav },
      { "Equal[x->NFG*, y->NFG*] =: BOOLEAN", GSM_Equal_Nfg },
      { "Equal[x->NFPLAYER*, y->NFPLAYER*] =: BOOLEAN",
	GSM_Equal_NfPlayer },
      { "Equal[x->STRATEGY*, y->STRATEGY*] =: BOOLEAN",
	GSM_Equal_Strategy },
      { "Equal[x->NFOUTCOME*, y->NFOUTCOME*] =: BOOLEAN",
	GSM_Equal_NfOutcome },
      { "Equal[x->NFSUPPORT*, y->NFSUPPORT*] =: BOOLEAN",
	GSM_Equal_NfSupport },
      { "Equal[x->MIXED*, y->MIXED*] =: BOOLEAN", GSM_Equal_Mixed },
      { "Exp[x->NUMBER] =: NUMBER", GSM_Exp },
      { "Float[x->NUMBER] =: NUMBER", GSM_Float },
      { "Greater[x->NUMBER, y->NUMBER] =: BOOLEAN", GSM_Greater_Number },
      { "Greater[x->TEXT, y->TEXT] =: BOOLEAN", GSM_Greater_Text },
      { "GreaterEqual[x->NUMBER, y->NUMBER] =: BOOLEAN", GSM_GreaterEqual_Number },
      { "GreaterEqual[x->TEXT, y->TEXT] =: BOOLEAN", GSM_GreaterEqual_Text },
      { "IntegerDivide[x->INTEGER, y->INTEGER] =: INTEGER", 
	GSM_IntegerDivide },
      { "Less[x->NUMBER, y->NUMBER] =: BOOLEAN", GSM_Less_Number },
      { "Less[x->TEXT, y->TEXT] =: BOOLEAN", GSM_Less_Text },
      { "LessEqual[x->NUMBER, y->NUMBER] =: BOOLEAN", GSM_LessEqual_Number },
      { "LessEqual[x->TEXT, y->TEXT] =: BOOLEAN", GSM_LessEqual_Text },
      { "Log[x->NUMBER] =: NUMBER", GSM_Log },
      { "Minus[x->NUMBER, y->NUMBER] =: NUMBER", GSM_Minus_Number },
      { "Minus[x->MIXED, y->MIXED] =: MIXED", GSM_Minus_Mixed },
      { "Minus[x->BEHAV, y->BEHAV] =: BEHAV", GSM_Minus_Behav },
      { "Modulus[x->INTEGER, y->INTEGER] =: INTEGER", GSM_Modulus },
      { "Negate[x->NUMBER] =: NUMBER", GSM_Negate },
      { "Not[x->BOOLEAN] =: BOOLEAN", GSM_Not },
      { "NotEqual[x->BOOLEAN*, y->BOOLEAN*] =: BOOLEAN", GSM_NotEqual_Boolean },
      { "NotEqual[x->NUMBER*, y->NUMBER*] =: BOOLEAN", GSM_NotEqual_Number },
      { "NotEqual[x->TEXT*, y->TEXT*] =: BOOLEAN", GSM_NotEqual_Text },
      { "NotEqual[x->EFG*, y->EFG*] =: BOOLEAN", GSM_NotEqual_Efg },
      { "NotEqual[x->EFPLAYER*, y->EFPLAYER*] =: BOOLEAN", 
	GSM_NotEqual_EfPlayer },
      { "NotEqual[x->NODE*, y->NODE*] =: BOOLEAN", GSM_NotEqual_Node },
      { "NotEqual[x->INFOSET*, y->INFOSET*] =: BOOLEAN", GSM_NotEqual_Infoset },
      { "NotEqual[x->EFOUTCOME*, y->EFOUTCOME*] =: BOOLEAN",
	GSM_NotEqual_EfOutcome },
      { "NotEqual[x->ACTION*, y->ACTION*] =: BOOLEAN", GSM_NotEqual_Action },
      { "NotEqual[x->EFSUPPORT*, y->EFSUPPORT*] =: BOOLEAN", 
	GSM_NotEqual_EfSupport },
      { "NotEqual[x->BEHAV*, y->BEHAV*] =: BOOLEAN", GSM_NotEqual_Behav },
      { "NotEqual[x->NFG*, y->NFG*] =: BOOLEAN", GSM_NotEqual_Nfg },
      { "NotEqual[x->NFPLAYER*, y->NFPLAYER*] =: BOOLEAN",
	GSM_NotEqual_NfPlayer },
      { "NotEqual[x->STRATEGY*, y->STRATEGY*] =: BOOLEAN",
	GSM_NotEqual_Strategy },
      { "NotEqual[x->NFOUTCOME*, y->NFOUTCOME*] =: BOOLEAN",
	GSM_NotEqual_NfOutcome },
      { "NotEqual[x->NFSUPPORT*, y->NFSUPPORT*] =: BOOLEAN",
	GSM_NotEqual_NfSupport },
      { "NotEqual[x->MIXED*, y->MIXED*] =: BOOLEAN", GSM_NotEqual_Mixed },
      { "Or[x->BOOLEAN, y->BOOLEAN] =: BOOLEAN", GSM_Or },
      { "Parentheses[x->ANYTYPE*] =: ANYTYPE", GSM_Parentheses },
      { "Plus[x->NUMBER, y->NUMBER] =: NUMBER", GSM_Plus_Number },
      { "Plus[x->TEXT, y->TEXT] =: TEXT", GSM_Plus_Text }, 
      { "Plus[x->MIXED, y->MIXED] =: MIXED", GSM_Plus_Mixed },
      { "Plus[x->BEHAV, y->BEHAV] =: BEHAV", GSM_Plus_Behav },
      { "Power[x->NUMBER, y->NUMBER] =: NUMBER", GSM_Power },
      { "Rational[x->NUMBER] =: NUMBER", GSM_Rational },
      { "Times[x->NUMBER, y->NUMBER] =: NUMBER", GSM_Times_Number },
      { "Times[x->NUMBER, y->MIXED] =: MIXED", GSM_Times_Mixed },
      { "Times[x->NUMBER, y->BEHAV] =: BEHAV", GSM_Times_Behav },
      { "Version[] =: TEXT", GSM_Version },
      { 0, 0 }
    };

  for (int i = 0; ftable[i].sig != 0; i++) {
    gsm->AddFunction(new gclFunction(*gsm, ftable[i].sig, ftable[i].func));
  }


  FuncObj = new gclFunction(*gsm, "Quit", 1);
  FuncObj->SetFuncInfo(0, gclSignature(GSM_Quit, porBOOLEAN, 1, 0,
				       funcNONLISTABLE));
  FuncObj->SetParamInfo(0, 0, gclParameter("value", porINTEGER,
					   new NumberPortion(0)));
  gsm->AddFunction(FuncObj);

  //-------------------- Streams -------------------------

  FuncObj = new gclFunction(*gsm, "Output", 1);
  FuncObj->SetFuncInfo(0, gclSignature(GSM_Output, porOUTPUT, 3));
  FuncObj->SetParamInfo(0, 0, gclParameter("file", porTEXT));
  FuncObj->SetParamInfo(0, 1, gclParameter("append", porBOOLEAN,
					    new BoolPortion( false )));
  FuncObj->SetParamInfo(0, 2, gclParameter("close", porBOOLEAN,
					    new BoolPortion( true )));
  gsm->AddFunction(FuncObj);
  
  FuncObj = new gclFunction(*gsm, "Input", 1);
  FuncObj->SetFuncInfo(0, gclSignature(GSM_Input, porINPUT, 1));
  FuncObj->SetParamInfo(0, 0, gclParameter("file", porTEXT));
  gsm->AddFunction(FuncObj);

  //------------------- Formatted Output -------------------

  GSM_SetWriteOptions();

  FuncObj = new gclFunction(*gsm, "Print", 2);
  FuncObj->SetFuncInfo(0, gclSignature(GSM_Print, porANYTYPE, 1, 0, funcNONLISTABLE));
  FuncObj->SetParamInfo(0, 0, gclParameter("x",
					    PortionSpec(porANYTYPE, 0, 
							porNULLSPEC)));

  FuncObj->SetFuncInfo(1, gclSignature(GSM_Print, PortionSpec(porANYTYPE, NLIST), 1, 0, funcNONLISTABLE));
  FuncObj->SetParamInfo(1, 0, gclParameter("x", 
					    PortionSpec(porANYTYPE, NLIST,
						      porNULLSPEC)));
  gsm->AddFunction(FuncObj);


  FuncObj = new gclFunction(*gsm, "Write", 4);
  FuncObj->SetFuncInfo(0, gclSignature(GSM_Write, 
				       porOUTPUT, 2, 0, funcNONLISTABLE));
  FuncObj->SetParamInfo(0, 0, gclParameter("output", porOUTPUT,
					    REQUIRED, BYREF));
  FuncObj->SetParamInfo(0, 1, gclParameter
			("x", porBOOLEAN | porNUMBER | porTEXT |
			 porMIXED | porBEHAV | porNFSUPPORT | porEFSUPPORT |
			 porSTRATEGY | porEFBASIS));
  
  FuncObj->SetFuncInfo(1, gclSignature(GSM_Write_Nfg, 
				       porOUTPUT, 2, 0, funcNONLISTABLE));
  FuncObj->SetParamInfo(1, 0, gclParameter("output", porOUTPUT,
					    REQUIRED, BYREF));
  FuncObj->SetParamInfo(1, 1, gclParameter("x", porNFG));
  
  FuncObj->SetFuncInfo(2, gclSignature(GSM_Write_Efg,
				       porOUTPUT, 2, 0, funcNONLISTABLE));
  FuncObj->SetParamInfo(2, 0, gclParameter("output", porOUTPUT,
					    REQUIRED, BYREF));
  FuncObj->SetParamInfo(2, 1, gclParameter("x", porEFG));

  FuncObj->SetFuncInfo(3, gclSignature(GSM_Write,
				       porOUTPUT, 2, 0, funcNONLISTABLE));
  FuncObj->SetParamInfo(3, 0, gclParameter("output", porOUTPUT,
					    REQUIRED, BYREF));
  FuncObj->SetParamInfo(3, 1, gclParameter
			("x", PortionSpec(porBOOLEAN | porNUMBER |
					  porTEXT | porMIXED | porBEHAV |
					  porNFSUPPORT | porEFSUPPORT, 1)));
  gsm->AddFunction(FuncObj);




  //---------------
  // *Format
  //---------------

  FuncObj = new gclFunction(*gsm, "ListFormat", 1);
  FuncObj->SetFuncInfo(0, gclSignature(GSM_ListFormat, porBOOLEAN, 4));
  FuncObj->SetParamInfo(0, 0, gclParameter
			("braces", porBOOLEAN,
			 _WriteListBraces.RefCopy(), BYREF));
  FuncObj->SetParamInfo(0, 1, gclParameter
			("commas", porBOOLEAN,
			 _WriteListCommas.RefCopy(), BYREF));
  FuncObj->SetParamInfo(0, 2, gclParameter
			("lf", porNUMBER,
			 _WriteListLF.RefCopy(), BYREF));
  FuncObj->SetParamInfo(0, 3, gclParameter
			("indent", porNUMBER,
			 _WriteListIndent.RefCopy(), BYREF ));
  gsm->AddFunction(FuncObj);

  FuncObj = new gclFunction(*gsm, "GetListFormat", 1);
  FuncObj->SetFuncInfo(0, gclSignature(GSM_GetListFormat, porBOOLEAN, 4));
  FuncObj->SetParamInfo(0, 0, gclParameter
			("braces", porBOOLEAN,
			 _WriteListBraces.RefCopy(), BYREF));
  FuncObj->SetParamInfo(0, 1, gclParameter
			("commas", porBOOLEAN,
			 _WriteListCommas.RefCopy(), BYREF));
  FuncObj->SetParamInfo(0, 2, gclParameter
			("lf", porNUMBER,
			 _WriteListLF.RefCopy(), BYREF));
  FuncObj->SetParamInfo(0, 3, gclParameter
			("indent", porNUMBER,
			 _WriteListIndent.RefCopy(), BYREF));
  gsm->AddFunction(FuncObj);


  FuncObj = new gclFunction(*gsm, "Format", 4);
  FuncObj->SetFuncInfo(0, gclSignature(GSM_NumberFormat, porNUMBER, 4));
  FuncObj->SetParamInfo(0, 0, gclParameter("x", porNUMBER) );
  FuncObj->SetParamInfo(0, 1, gclParameter
			("width", porNUMBER, 
			 _WriteWidth.RefCopy(), BYREF));
  FuncObj->SetParamInfo(0, 2, gclParameter
			("decimals", porNUMBER,
			 _WritePrecis.RefCopy(), BYREF));
  FuncObj->SetParamInfo(0, 3, gclParameter
			("expmode", porBOOLEAN,
			 _WriteExpmode.RefCopy(), BYREF));

  FuncObj->SetFuncInfo(1, gclSignature(GSM_TextFormat, porTEXT, 2));
  FuncObj->SetParamInfo(1, 0, gclParameter("x", porTEXT) );
  FuncObj->SetParamInfo(1, 1, gclParameter
			("quote", porBOOLEAN,
			 _WriteQuoted.RefCopy(), BYREF));

  FuncObj->SetFuncInfo(2, gclSignature(GSM_SolutionFormat,
				       porBEHAV | porMIXED, 3));
  FuncObj->SetParamInfo(2, 0, gclParameter("x", porBEHAV | porMIXED) );
  FuncObj->SetParamInfo(2, 1, gclParameter
			("info", porBOOLEAN,
			 _WriteSolutionInfo.RefCopy(), BYREF));
  FuncObj->SetParamInfo(2, 2, gclParameter("names", porBOOLEAN,
					   _WriteSolutionLabels.RefCopy(), BYREF));

  FuncObj->SetFuncInfo(3, gclSignature(GSM_GameFormat,
				       porEFG | porNFG, 2));
  FuncObj->SetParamInfo(3, 0, gclParameter("x", porEFG | porNFG));
  FuncObj->SetParamInfo(3, 1, gclParameter("decimals", porNUMBER,
					   _WriteGameDecimals.RefCopy(), BYREF));
  gsm->AddFunction(FuncObj);

  FuncObj = new gclFunction(*gsm, "GetFormat", 4);
  FuncObj->SetFuncInfo(0, gclSignature(GSM_GetNumberFormat, porNUMBER, 4));
  FuncObj->SetParamInfo(0, 0, gclParameter("x", porNUMBER) );
  FuncObj->SetParamInfo(0, 1, gclParameter
			("width", porNUMBER, 
			 _WriteWidth.RefCopy(), BYREF));
  FuncObj->SetParamInfo(0, 2, gclParameter
			("decimals", porNUMBER,
			 _WritePrecis.RefCopy(), BYREF));
  FuncObj->SetParamInfo(0, 3, gclParameter
			("expmode", porBOOLEAN,
			 _WriteExpmode.RefCopy(), BYREF));

  FuncObj->SetFuncInfo(1, gclSignature(GSM_GetTextFormat, porTEXT, 2));
  FuncObj->SetParamInfo(1, 0, gclParameter("x", porTEXT) );
  FuncObj->SetParamInfo(1, 1, gclParameter
			("quote", porBOOLEAN,
			 _WriteQuoted.RefCopy(), BYREF));

  FuncObj->SetFuncInfo(2, gclSignature(GSM_GetSolutionFormat,
				       porBEHAV | porMIXED, 3));
  FuncObj->SetParamInfo(2, 0, gclParameter("x", porBEHAV | porMIXED) );
  FuncObj->SetParamInfo(2, 1, gclParameter
			("info", porBOOLEAN,
			 _WriteSolutionInfo.RefCopy(), BYREF));
  FuncObj->SetParamInfo(2, 2, gclParameter("names", porBOOLEAN,
					   _WriteSolutionLabels.RefCopy(), BYREF));

  FuncObj->SetFuncInfo(3, gclSignature(GSM_GetGameFormat,
				       porEFG | porNFG, 2));
  FuncObj->SetParamInfo(3, 0, gclParameter("x", porEFG | porNFG));
  FuncObj->SetParamInfo(3, 1, gclParameter("decimals", porNUMBER,
					   _WriteGameDecimals.RefCopy(),
					   BYREF));
  gsm->AddFunction(FuncObj);



  //-------------------- Read --------------------------

  FuncObj = new gclFunction(*gsm, "Read", 7);

  FuncObj->SetFuncInfo(0, gclSignature(GSM_Read_Bool, 
				       porINPUT, 2, 0, funcNONLISTABLE));
  FuncObj->SetParamInfo(0, 0, gclParameter("input", porINPUT, 
					    REQUIRED, BYREF));
  FuncObj->SetParamInfo(0, 1, gclParameter("x", porBOOLEAN, 
					    REQUIRED, BYREF));

  FuncObj->SetFuncInfo(1, gclSignature(GSM_Read_List_Bool, 
				       porINPUT, 2, 0, funcNONLISTABLE));
  FuncObj->SetParamInfo(1, 0, gclParameter("input", porINPUT,
					    REQUIRED, BYREF));
  FuncObj->SetParamInfo(1, 1, gclParameter("x", PortionSpec(porBOOLEAN,1), 
					    REQUIRED, BYREF));

  FuncObj->SetFuncInfo(2, gclSignature(GSM_Read_Number,
				       porINPUT, 2, 0, funcNONLISTABLE));
  FuncObj->SetParamInfo(2, 0, gclParameter("input", porINPUT,
					    REQUIRED, BYREF));
  FuncObj->SetParamInfo(2, 1, gclParameter("x", porNUMBER,
					    REQUIRED, BYREF));
  
  FuncObj->SetFuncInfo(3, gclSignature(GSM_Read_List_Number,
				       porINPUT, 2, 0, funcNONLISTABLE));
  FuncObj->SetParamInfo(3, 0, gclParameter("input", porINPUT,
					    REQUIRED, BYREF));
  FuncObj->SetParamInfo(3, 1, gclParameter("x", PortionSpec(porNUMBER,1),
					    REQUIRED, BYREF));
  
  FuncObj->SetFuncInfo(4, gclSignature(GSM_Read_Text,
				       porINPUT, 2, 0, funcNONLISTABLE));
  FuncObj->SetParamInfo(4, 0, gclParameter("input", porINPUT,
					    REQUIRED, BYREF));
  FuncObj->SetParamInfo(4, 1, gclParameter("x", porTEXT,
					    REQUIRED, BYREF));
  
  FuncObj->SetFuncInfo(5, gclSignature(GSM_Read_List_Text,
				       porINPUT, 2, 0, funcNONLISTABLE));
  FuncObj->SetParamInfo(5, 0, gclParameter("input", porINPUT,
					    REQUIRED, BYREF));
  FuncObj->SetParamInfo(5, 1, gclParameter("x", PortionSpec(porTEXT,1),
					    REQUIRED, BYREF));

  FuncObj->SetFuncInfo(6, gclSignature(GSM_Read_Undefined, 
					porINPUT, 2, 0, funcNONLISTABLE));
  FuncObj->SetParamInfo(6, 0, gclParameter("input", porINPUT,
					   REQUIRED, BYREF));
  FuncObj->SetParamInfo(6, 1, gclParameter("x", porUNDEFINED, 
					   REQUIRED, BYREF));
  gsm->AddFunction(FuncObj);

  FuncObj = new gclFunction(*gsm, "ReadText", 2);
  FuncObj->SetFuncInfo(0, gclSignature(GSM_ReadText_Text,
				       porINPUT, 3, 0, funcNONLISTABLE));
  FuncObj->SetParamInfo(0, 0, gclParameter("input", porINPUT,
					    REQUIRED, BYREF));
  FuncObj->SetParamInfo(0, 1, gclParameter("x", porTEXT,
					    new TextPortion(""), BYREF));
  FuncObj->SetParamInfo(0, 2, gclParameter("until", porTEXT,
					    REQUIRED));
  FuncObj->SetFuncInfo(1, gclSignature(GSM_ReadText_Number,
				       porINPUT, 3, 0, funcNONLISTABLE));
  FuncObj->SetParamInfo(1, 0, gclParameter("input", porINPUT,
					    REQUIRED, BYREF));
  FuncObj->SetParamInfo(1, 1, gclParameter("x", porTEXT,
					    new TextPortion(""), BYREF));
  FuncObj->SetParamInfo(1, 2, gclParameter("n", porINTEGER,
					    REQUIRED));
  gsm->AddFunction(FuncObj);

  FuncObj = new gclFunction(*gsm, "IsEof", 1);
  FuncObj->SetFuncInfo(0, gclSignature(GSM_IsEof, porBOOLEAN, 1));
  FuncObj->SetParamInfo(0, 0, gclParameter("input", porINPUT));
  gsm->AddFunction(FuncObj);

  FuncObj = new gclFunction(*gsm, "IsDefined", 2);
  FuncObj->SetFuncInfo(0, gclSignature(GSM_IsDefined, porBOOLEAN, 1));
  FuncObj->SetParamInfo(0, 0, gclParameter("x", porANYTYPE));

  FuncObj->SetFuncInfo(1, gclSignature(GSM_IsDefined_Undefined, porBOOLEAN, 1));
  FuncObj->SetParamInfo(1, 0, gclParameter("x", porUNDEFINED));
  gsm->AddFunction(FuncObj);

  FuncObj = new gclFunction(*gsm, "Help", 1);
  FuncObj->SetFuncInfo(0, gclSignature(GSM_Help, PortionSpec(porTEXT, 1), 3));
  FuncObj->SetParamInfo(0, 0, gclParameter("x", porTEXT));
  FuncObj->SetParamInfo(0, 1, gclParameter("udf", porBOOLEAN,
					    new BoolPortion( true )));
  FuncObj->SetParamInfo(0, 2, gclParameter("bif", porBOOLEAN, 
					    new BoolPortion( true )));
  gsm->AddFunction(FuncObj);

  FuncObj = new gclFunction(*gsm, "Manual", 1);
  FuncObj->SetFuncInfo(0, gclSignature(GSM_Manual, porBOOLEAN, 2));
  FuncObj->SetParamInfo(0, 0, gclParameter("x", porTEXT));
  FuncObj->SetParamInfo(0, 1, gclParameter("y", porOUTPUT,
					    new OutputPortion(gsm->OutputStream())));
  gsm->AddFunction(FuncObj);
  
  FuncObj = new gclFunction(*gsm, "HelpVars", 1);
  FuncObj->SetFuncInfo(0, gclSignature(GSM_HelpVars, PortionSpec(porTEXT, 1),
				       1));
  FuncObj->SetParamInfo(0, 0, gclParameter("x", porTEXT));
  gsm->AddFunction(FuncObj);

  FuncObj = new gclFunction(*gsm, "Clear", 1);
  FuncObj->SetFuncInfo(0, gclSignature(GSM_Clear, porBOOLEAN, 0));
  gsm->AddFunction(FuncObj);


  FuncObj = new gclFunction(*gsm, "Assign", 1);
  FuncObj->SetFuncInfo(0, gclSignature(GSM_Assign, porANYTYPE, 2));
  FuncObj->SetParamInfo(0, 0, gclParameter("name", porTEXT));
  FuncObj->SetParamInfo(0, 1, gclParameter("value", porANYTYPE, 
					    REQUIRED, BYREF));
  gsm->AddFunction(FuncObj);

  FuncObj = new gclFunction(*gsm, "UnAssign", 1);
  FuncObj->SetFuncInfo(0, gclSignature(GSM_UnAssign, porBOOLEAN, 1));
  FuncObj->SetParamInfo(0, 0, gclParameter("name", porTEXT));
  gsm->AddFunction(FuncObj);

  FuncObj = new gclFunction(*gsm, "Date", 1);
  FuncObj->SetFuncInfo(0, gclSignature(GSM_Date, porTEXT, 0));
  gsm->AddFunction(FuncObj);


  FuncObj = new gclFunction(*gsm, "Randomize", 1);
  FuncObj->SetFuncInfo(0, gclSignature(GSM_Randomize, porNUMBER, 2));
  FuncObj->SetParamInfo(0, 0, gclParameter("x", porNUMBER));
  FuncObj->SetParamInfo(0, 1, gclParameter("seed", porNUMBER,
					    new NumberPortion(0)));
  gsm->AddFunction(FuncObj);

  FuncObj = new gclFunction(*gsm, "Precision", 1);
  FuncObj->SetFuncInfo(0, gclSignature(GSM_Precision, porPRECISION, 1));
  FuncObj->SetParamInfo(0, 0, gclParameter("x", porNUMBER));

  gsm->AddFunction(FuncObj);