Пример #1
0
ALERROR CCodeChain::RegisterPrimitive (PRIMITIVEPROCDEF *pDef, IPrimitiveImpl *pImpl)

//	RegisterPrimitive
//
//	Registers a primitive function implemented in C

	{
	ICCItem *pError;
	ICCItem *pDefinition;

	//	Create a primitive definition

	pDefinition = CreatePrimitive(pDef, pImpl);
	if (pDefinition->IsError())
		{
		pDefinition->Discard(this);
		return ERR_FAIL;
		}

	//	Add to global symbol table

	pError = m_pGlobalSymbols->AddEntry(this, pDefinition, pDefinition);
	if (pError->IsError())
		{
		pError->Discard(this);
		return ERR_FAIL;
		}

	//	Don't need these anymore; AddEntry keeps a reference

	pError->Discard(this);
	pDefinition->Discard(this);

	return NOERROR;
	}
Пример #2
0
ICCItem *fnAtmCreate (CEvalContext *pCtx, ICCItem *pArguments, DWORD dwData)

//	fnAtmCreate
//
//	Creates a new atom table
//
//	(atmAtomTable ((atom1 entry1) (atom2 entry2) ... (atomn entryn))) -> atmtable

	{
	CCodeChain *pCC = pCtx->pCC;
	ICCItem *pArgs;
	ICCItem *pAtomTable;
	ICCItem *pList;
	int i;

	//	Evaluate the argument

	pArgs = pCC->EvaluateArgs(pCtx, pArguments, CONSTLIT("l"));
	if (pArgs->IsError())
		return pArgs;

	//	Create the table

	pAtomTable = pCC->CreateAtomTable();
	if (pAtomTable->IsError())
		return pAtomTable;

	//	Add each entry

	pList = pArgs->Head(pCC);
	for (i = 0; i < pList->GetCount(); i++)
		{
		ICCItem *pPair = pList->GetElement(i);
		ICCItem *pResult;

		//	Make sure we have two elements

		if (pPair->GetCount() != 2)
			{
			pAtomTable->Discard(pCC);
			return pCC->CreateError(CONSTLIT("Invalid format for atom table entry:"), pPair);
			}

		//	Get the atom and the entry

		pResult = pAtomTable->AddEntry(pCC, pPair->GetElement(0), pPair->GetElement(1));
		if (pResult->IsError())
			{
			pAtomTable->Discard(pCC);
			return pResult;
			}

		pResult->Discard(pCC);
		}

	//	Done

	pArgs->Discard(pCC);
	return pAtomTable;
	}
Пример #3
0
ICCItem *CCAtomTable::StreamItem (CCodeChain *pCC, IWriteStream *pStream)

//	StreamItem
//
//	Stream the sub-class specific data

	{
	ALERROR error;
	int iCount;
	int i;

	//	Write out the count

	iCount = m_Table.GetCount();
	error = pStream->Write((char *)&iCount, sizeof(iCount), NULL);
	if (error)
		return pCC->CreateSystemError(error);

	//	Write out each of the items in the list

	for (i = 0; i < iCount; i++)
		{
		int iValue, iKey;
		ICCItem *pItem;
		ICCItem *pKey;
		ICCItem *pError;

		m_Table.GetEntry(i, &iKey, &iValue);
		pItem = (ICCItem *)iValue;

		//	Write out the key

		pKey = pCC->CreateInteger(iKey);
		if (pKey->IsError())
			return pKey;

		pError = pCC->StreamItem(pKey, pStream);
		pKey->Discard(pCC);
		if (pError->IsError())
			return pError;

		pError->Discard(pCC);

		//	Write out the value

		pError = pCC->StreamItem(pItem, pStream);
		if (pError->IsError())
			return pError;

		pError->Discard(pCC);

		//	Note that there is no need to discard pItem
		//	since we did not increase its refcount
		}

	return pCC->CreateTrue();
	}
Пример #4
0
ICCItem *CCSymbolTable::StreamItem (CCodeChain *pCC, IWriteStream *pStream)

//	StreamItem
//
//	Stream the sub-class specific data

	{
	ALERROR error;
	int iCount;
	int i;

	//	Write out the count

	iCount = m_Symbols.GetCount();
	if (error = pStream->Write((char *)&iCount, sizeof(iCount), NULL))
		return pCC->CreateSystemError(error);

	//	Write out each of the items in the list

	for (i = 0; i < iCount; i++)
		{
		CString sKey = m_Symbols.GetKey(i);
		CObject *pValue = m_Symbols.GetValue(i);
		ICCItem *pItem = (ICCItem *)pValue;
		ICCItem *pKey;
		ICCItem *pError;

		//	Write out the key

		pKey = pCC->CreateString(sKey);
		if (pKey->IsError())
			return pKey;

		pError = pCC->StreamItem(pKey, pStream);
		pKey->Discard(pCC);
		if (pError->IsError())
			return pError;

		pError->Discard(pCC);

		//	Write out the value

		pError = pCC->StreamItem(pItem, pStream);
		if (pError->IsError())
			return pError;

		pError->Discard(pCC);

		//	Note that there is no need to discard pItem
		//	since we did not increase its refcount
		}

	return pCC->CreateTrue();
	}
Пример #5
0
ICCItem *CCodeChain::CreateFilledVector(double dScalar, TArray<int> vShape)

//	CreateFilledVector
//
//	Creates a vector filled with the given scalar

{
	int i;
	int iSize = 0;
	CCVector *pVector;
	ICCItem *pError;
	ICCItem *pItem;

	for (i = 0; i < vShape.GetCount(); i++)
	{
		if (i == 0)
			iSize = vShape[0];
		else
			iSize = iSize*vShape[i];
	};

	pItem = m_VectorPool.CreateItem(this);
	if (pItem->IsError())
		return pItem;
	pItem->Reset();
	pVector = dynamic_cast<CCVector *>(pItem);

	pVector->SetContext(this);
	pVector->SetShape(this, vShape);

	pError = pVector->SetDataArraySize(this, iSize);
	if (pError->IsError())
	{
		delete pVector;
		return pError;
	}

	TArray<double> vContentArray = pVector->GetDataArray();
	for (i = 0; i < iSize; i++)
	{
		vContentArray[i] = dScalar;
	};
	pVector->SetArrayData(this, vContentArray);

	
	pError->Discard(this);
	//	Done
	return pVector->Reference();
}
Пример #6
0
ICCItem *CCPrimitive::Execute (CEvalContext *pCtx, ICCItem *pArgs)

//	Execute
//
//	Executes the function and returns a result

	{
	bool bCustomArgEval = ((m_dwFlags & PPFLAG_CUSTOM_ARG_EVAL) ? true : false);

	//	Evaluate args, if necessary

	ICCItem *pEvalArgs;
	if (!bCustomArgEval)
		{
		pEvalArgs = pCtx->pCC->EvaluateArgs(pCtx, pArgs, m_sArgPattern);
		if (pEvalArgs->IsError())
			return pEvalArgs;
		}
	else
		pEvalArgs = pArgs;

	//	Invoke the function

	ICCItem *pResult;
	bool bReportError = false;
	try
		{
		pResult = m_pfFunction(pCtx, pEvalArgs, m_dwData);
		}
	catch (...)
		{
		bReportError = true;
		}

	//	Report error

	if (bReportError)
		{
		CString sArgs;
		try
			{
			sArgs = pEvalArgs->Print(pCtx->pCC);
			}
		catch (...)
			{
			sArgs = CONSTLIT("[invalid arg item]");
			}

		CString sError = strPatternSubst(CONSTLIT("Exception in %s; arg = %s"), m_sName, sArgs);
		pResult = pCtx->pCC->CreateError(sError, pEvalArgs);
		kernelDebugLogMessage(sError.GetASCIIZPointer());
		}

	//	Done

	if (!bCustomArgEval)
		pEvalArgs->Discard(pCtx->pCC);

	return pResult;
	}
Пример #7
0
ICCItem *CLWindowManager::CreateLWindow (CLWindowOptions *pOptions, CLSizeOptions *pSize, ICCItem *pController)

//	CLWindowManager
//
//	Create a new window

	{
	CLWindow *pNewWindow;
	ICCItem *pError;

	pNewWindow = new CLWindow(this);
	if (pNewWindow == NULL)
		return m_pCC->CreateMemoryError();

	//	Initialize

	pError = pNewWindow->CreateItem(m_pCC, pOptions, pSize, pController);
	if (pError->IsError())
		return pError;

	pError->Discard(m_pCC);

	//	Add the window to the window manager's list

	m_WindowList.AppendObject(pNewWindow, NULL);

	return pNewWindow->Reference();
	}
Пример #8
0
CString CreateDataFieldFromItemList (const TArray<CItem> &List)

//	CreateDataFieldFromItemList
//
//	Creates a data field string from a list of items

	{
	int i;
	CCodeChain &CC = g_pUniverse->GetCC();

	CMemoryWriteStream Output(10000);
	if (Output.Create() != NOERROR)
		return NULL_STR;

	Output.Write("='(", 3);
	for (i = 0; i < List.GetCount(); i++)
		{
		ICCItem *pItem = List[i].WriteToCCItem(CC);
		if (pItem->IsError())
			{
			pItem->Discard(&CC);
			return NULL_STR;
			}

		CString sItem = pItem->Print(&CC);
		Output.Write(sItem.GetASCIIZPointer(), sItem.GetLength());
		Output.Write(" ", 1);

		pItem->Discard(&CC);
		}
	Output.Write(")", 1);
	Output.Close();

	return CString(Output.GetPointer(), Output.GetLength());
	}
Пример #9
0
int CArmorClass::FireGetMaxHP (CItemCtx &ItemCtx, int iMaxHP) const

//	FireGetMaxHP
//
//	Fire GetMaxHP event

	{
	SEventHandlerDesc Event;
	if (FindEventHandlerArmorClass(evtGetMaxHP, &Event))
		{
		//	Setup arguments

		CCodeChainCtx Ctx;
		Ctx.SaveAndDefineSourceVar(ItemCtx.GetSource());
		Ctx.SaveAndDefineItemVar(ItemCtx);

		Ctx.DefineInteger(CONSTLIT("aMaxHP"), iMaxHP);

		ICCItem *pResult = Ctx.Run(Event);

		if (pResult->IsError())
			ItemCtx.GetSource()->ReportEventError(GET_MAX_HP_EVENT, pResult);
		else if (!pResult->IsNil())
			iMaxHP = Max(0, pResult->GetIntegerValue());

		Ctx.Discard(pResult);
		}

	return iMaxHP;
	}
Пример #10
0
ICCItem *fnCount (CEvalContext *pCtx, ICCItem *pArguments, DWORD dwData)

//	fnCount
//
//	Returns the number of elements in the list
//
//	(count list)

	{
	CCodeChain *pCC = pCtx->pCC;
	ICCItem *pArgs;
	ICCItem *pResult;
	ICCItem *pList;

	//	Evaluate the arguments and validate them

	pArgs = pCC->EvaluateArgs(pCtx, pArguments, CONSTLIT("l"));
	if (pArgs->IsError())
		return pArgs;

	//	The first argument is the list

	pList = pArgs->Head(pCC);
	pResult = pCC->CreateInteger(pList->GetCount());

	//	Done

	pArgs->Discard(pCC);
	return pResult;
	}
Пример #11
0
ICCItem *CMission::FireOnReward (ICCItem *pData)

//	FireOnReward
//
//	Fire <OnReward>
//
//	Callers are responsible for discarding the result, if not NULL.

	{
	SEventHandlerDesc Event;

	if (FindEventHandler(EVENT_ON_REWARD, &Event))
		{
		CCodeChainCtx Ctx;

		Ctx.SaveAndDefineSourceVar(this);
		Ctx.SaveAndDefineDataVar(pData);

		ICCItem *pResult = Ctx.Run(Event);
		if (pResult->IsError())
			{
			ReportEventError(EVENT_ON_REWARD, pResult);
			Ctx.Discard(pResult);
			return NULL;
			}

		return pResult;
		}

	return NULL;
	}
Пример #12
0
ICCItem *fnSubst (CEvalContext *pCtx, ICCItem *pArguments, DWORD dwData)

//	fnSubst
//
//	Substitutes string parameters
//
//	(subst string arg1 arg2 ... argn)

	{
	CCodeChain *pCC = pCtx->pCC;
	ICCItem *pArgs;

	//	Evaluate the arguments and validate them

	pArgs = pCC->EvaluateArgs(pCtx, pArguments, CONSTLIT("s*"));
	if (pArgs->IsError())
		return pArgs;

	CString sPattern = pArgs->GetElement(0)->GetStringValue();

	//	Do the substitution

	char szResult[4096];
	char *pPos = sPattern.GetASCIIZPointer();
	char *pDest = szResult;
	char *pEndDest = szResult + sizeof(szResult) - 1;

	while (*pPos != '\0' && pDest < pEndDest)
		{
		if (*pPos == '%')
			{
			pPos++;

			int iArg = strParseInt(pPos, 0, &pPos, NULL);
			if (iArg > 0)
				{
				CString sParam = pArgs->GetElement(iArg)->GetStringValue();
				char *pParam = sParam.GetASCIIZPointer();

				while (*pParam != '\0' && pDest < pEndDest)
					*pDest++ = *pParam++;

				pPos++;
				}
			else
				{
				if (*pPos == '%')
					*pDest++ = *pPos++;
				}
			}
		else
			*pDest++ = *pPos++;
		}

	//	Done

	*pDest = '\0';
	pArgs->Discard(pCC);
	return pCC->CreateString(CString(szResult));
	}
Пример #13
0
ICCItem *CCLambda::Clone (CCodeChain *pCC)

//	Clone
//
//	Clone this item

	{
	ICCItem *pNew;
	CCLambda *pClone;

	pNew = pCC->CreateLambda(NULL, FALSE);
	if (pNew->IsError())
		return pNew;

	pClone = dynamic_cast<CCLambda *>(pNew);

	pClone->CloneItem(this);

	if (m_pArgList)
		pClone->m_pArgList = m_pArgList->Reference();
	else
		pClone->m_pArgList = NULL;

	if (m_pCode)
		pClone->m_pCode = m_pCode->Reference();
	else
		pClone->m_pCode = NULL;

	return pClone;
	}
Пример #14
0
ICCItem *CCodeChain::CreateVectorOld (int iSize)

//	CreateVectorOld
//
//	Creates a vector of the given number of elements

	{
	CCVectorOld *pVector;
	ICCItem *pError;

	pVector = new CCVectorOld(this);
	if (pVector == NULL)
		return CreateMemoryError();

	pError = pVector->SetSize(this, iSize);
	if (pError->IsError())
		{
		delete pVector;
		return pError;
		}

	pError->Discard(this);

	//	Done

	return pVector->Reference();
	}
Пример #15
0
ICCItem *fnShuffle (CEvalContext *pCtx, ICCItem *pArgs, DWORD dwData)

//	fnShuffle
//
//	Shuffles a list randomly

	{
	int i;
	CCodeChain *pCC = pCtx->pCC;

	if (pArgs->GetElement(0)->IsNil())
		return pCC->CreateNil();

	//	Create a destination list

	ICCItem *pResult = pCC->CreateLinkedList();
	if (pResult->IsError())
		return pResult;

	CCLinkedList *pList = (CCLinkedList *)pResult;

	//	Copy the list

	ICCItem *pSource = pArgs->GetElement(0);
	for (i = 0; i < pSource->GetCount(); i++)
		pList->Append(pCC, pSource->GetElement(i), NULL);

	//	Shuffle the new list

	pList->Shuffle(pCC);

	//	Done

	return pResult;
	}
Пример #16
0
ICCItem *CCodeChain::StreamItem (ICCItem *pItem, IWriteStream *pStream)

//	StreamItem
//
//	Save the item to an open stream

	{
	ALERROR error;
	DWORD dwClass;
	ICCItem *pError;

	//	Save out the object class

	dwClass = pItem->GetClass()->GetObjID();
	if (error = pStream->Write((char *)&dwClass, sizeof(dwClass), NULL))
		return CreateSystemError(error);

	//	Let the object save itself

	pError = pItem->Stream(this, pStream);
	if (pError->IsError())
		return pError;

	pError->Discard(this);

	//	Done

	return CreateTrue();
	}
Пример #17
0
ICCItem *CreateListFromBinary (CCodeChain &CC, void const *pvSource, int iLengthBytes)

//	CreateListFromBinary
//
//	Creates a code chain list from a block of memory

	{
	ICCItem *pResult = CC.CreateLinkedList();
	if (pResult->IsError())
		return pResult;

	CCLinkedList *pList = (CCLinkedList *)pResult;

	//	CItem is two DWORD long

	DWORD *pSource = (DWORD *)pvSource;
	int iCount = AlignUp(iLengthBytes, sizeof(DWORD)) / sizeof(DWORD);

	for (int i = 0; i < iCount; i++)
		{
		ICCItem *pInt = CC.CreateInteger(*pSource++);
		pList->Append(&CC, pInt, NULL);
		pInt->Discard(&CC);
		}

	return pResult;
	}
Пример #18
0
ICCItem *CCodeChain::LookupGlobal (const CString &sGlobal, LPVOID pExternalCtx)

//	LookupGlobal
//
//	Returns the binding for this item

	{
	CEvalContext EvalCtx;
	ICCItem *pItem;
	ICCItem *pResult;

	//	Set up the context

	EvalCtx.pCC = this;
	EvalCtx.pLexicalSymbols = m_pGlobalSymbols;
	EvalCtx.pLocalSymbols = NULL;
	EvalCtx.pExternalCtx = pExternalCtx;

	//	Create a variable

	pItem = CreateString(sGlobal);
	if (pItem->IsError())
		return pItem;

	pResult = Lookup(&EvalCtx, pItem);
	pItem->Discard(this);
	return pResult;
	}
Пример #19
0
ICCItem *fnLambda (CEvalContext *pCtx, ICCItem *pArguments, DWORD dwData)

//	fnLambda
//
//	Lambda expression
//
//	(lambda (args...) code)

	{
	CCodeChain *pCC = pCtx->pCC;
	ICCItem *pItem;
	CCLambda *pLambda;

	//	Create a lambda expression based on this list

	pItem = pCC->CreateLambda(pArguments, TRUE);
	if (pItem->IsError())
		return pItem;

	pLambda = dynamic_cast<CCLambda *>(pItem);

	//	Done

	return pLambda;
	}
Пример #20
0
ICCItem *fnAppend (CEvalContext *pCtx, ICCItem *pArgs, DWORD dwData)

//	fnAppend
//
//	Appends two or more elements together

	{
	int i, j;
	CCodeChain *pCC = pCtx->pCC;

	//	Create a new list to store the result in

	ICCItem *pResult = pCC->CreateLinkedList();
	if (pResult->IsError())
		return pResult;

	CCLinkedList *pList = (CCLinkedList *)pResult;

	//	Loop over all arguments and add to result list

	for (i = 0; i < pArgs->GetCount(); i++)
		{
		ICCItem *pItem = pArgs->GetElement(i);

		for (j = 0; j < pItem->GetCount(); j++)
			pList->Append(pCC, pItem->GetElement(j), NULL);
		}

	//	Done

	return pResult;
	}
Пример #21
0
ALERROR CCodeChain::DefineGlobal (const CString &sVar, ICCItem *pValue)

//	DefineGlobal
//
//	Defines a global variable programmatically

	{
	ALERROR error;

	//	Create a string item

	ICCItem *pVar = CreateString(sVar);

	//	Add the symbol

	ICCItem *pError;
	pError = m_pGlobalSymbols->AddEntry(this, pVar, pValue);
	pVar->Discard(this);

	//	Check for error

	if (pError->IsError())
		error = ERR_FAIL;
	else
		error = NOERROR;

	pError->Discard(this);

	return error;
	}
Пример #22
0
ICCItem *CCLambda::StreamItem (CCodeChain *pCC, IWriteStream *pStream)

//	StreamItem
//
//	Stream the sub-class specific data

	{
	ICCItem *pError;

	//	If we don't have both of these, then it is because we're trying
	//	to save an uninitialized lambda structure

	ASSERT(m_pArgList);
	ASSERT(m_pCode);

	//	Write out the argument list

	pError = pCC->StreamItem(m_pArgList, pStream);
	if (pError->IsError())
		return pError;

	pError->Discard(pCC);

	//	Write out the code

	return pCC->StreamItem(m_pCode, pStream);
	}
Пример #23
0
ICCItem *fnStrCapitalize (CEvalContext *pCtx, ICCItem *pArguments, DWORD dwData)

//	fnStrCapitalize
//
//	Capitalizes the string
//
//	(strCapitalize string) -> string

	{
	CCodeChain *pCC = pCtx->pCC;
	ICCItem *pArgs;

	//	Evaluate the arguments and validate them

	pArgs = pCC->EvaluateArgs(pCtx, pArguments, CONSTLIT("s"));
	if (pArgs->IsError())
		return pArgs;

	CString sString = pArgs->GetElement(0)->GetStringValue();
	pArgs->Discard(pCC);

	//	Done

	sString.Capitalize(CString::capFirstLetter);
	return pCC->CreateString(sString);
	}
Пример #24
0
int CShieldClass::FireGetMaxHP (CInstalledDevice *pDevice, CSpaceObject *pSource, int iMaxHP) const

//	FireGetMaxHP
//
//	Fire GetMaxHP event

	{
	SEventHandlerDesc Event;
	if (FindEventHandlerShieldClass(evtGetMaxHP, &Event))
		{
		ASSERT(pSource);
		ASSERT(pDevice);

		CCodeChainCtx Ctx;

		Ctx.SaveAndDefineSourceVar(pSource);
		Ctx.SaveAndDefineItemVar(pSource->GetItemForDevice(pDevice));
		Ctx.DefineInteger(CONSTLIT("aMaxHP"), iMaxHP);

		ICCItem *pResult = Ctx.Run(Event);
		if (pResult->IsError())
			pSource->ReportEventError(GET_MAX_HP_EVENT, pResult);
		else if (!pResult->IsNil())
			iMaxHP = Max(0, pResult->GetIntegerValue());

		Ctx.Discard(pResult);
		}

	return iMaxHP;
	}
Пример #25
0
ICCItem *fnVecCreate (CEvalContext *pCtx, ICCItem *pArguments, DWORD dwData)

//	fnVecCreate
//
//	Creates a new vector of a given size
//
//	(vecVector size) -> vector
//
//	All elements of the vector are initialized to 0

	{
	CCodeChain *pCC = pCtx->pCC;
	ICCItem *pArgs;
	ICCItem *pVector;

	//	Evaluate the argument

	pArgs = pCC->EvaluateArgs(pCtx, pArguments, CONSTLIT("i"));
	if (pArgs->IsError())
		return pArgs;

	//	Create the table

	pVector = pCC->CreateVector(pArgs->Head(pCC)->GetIntegerValue());

	//	Done

	pArgs->Discard(pCC);
	return pVector;
	}
Пример #26
0
bool IDockScreenDisplay::EvalBool (const CString &sCode, bool *retbResult, CString *retsError)

//	EvalBool
//
//	Evaluates the given string

	{
	CCodeChainCtx Ctx;
	Ctx.SetScreen(m_pDockScreen);
	Ctx.SaveAndDefineSourceVar(m_pLocation);
	Ctx.SaveAndDefineDataVar(m_pData);

	char *pPos = sCode.GetPointer();
	ICCItem *pExp = Ctx.Link(sCode, 1, NULL);

	ICCItem *pResult = Ctx.Run(pExp);	//	LATER:Event
	Ctx.Discard(pExp);

	if (pResult->IsError())
		{
		*retsError = pResult->GetStringValue();
		Ctx.Discard(pResult);
		return false;
		}

	*retbResult = !pResult->IsNil();
	Ctx.Discard(pResult);

	return true;
	}
Пример #27
0
ICCItem *fnCat (CEvalContext *pCtx, ICCItem *pArguments, DWORD dwData)

//	fnCat
//
//	Concatenates the given strings
//
//	(cat string1 string2 ... stringn)

	{
	CCodeChain *pCC = pCtx->pCC;
	ICCItem *pArgs;
	ICCItem *pResult;
	CString sResult;
	int i;

	//	Evaluate the arguments and validate them

	pArgs = pCC->EvaluateArgs(pCtx, pArguments, CONSTLIT("*"));
	if (pArgs->IsError())
		return pArgs;

	//	Append each of the items

	for (i = 0; i < pArgs->GetCount(); i++)
		sResult.Append(pArgs->GetElement(i)->GetStringValue());

	pResult = pCC->CreateString(sResult);

	//	Done

	pArgs->Discard(pCC);
	return pResult;
	}
Пример #28
0
COverlayType *CDeviceClass::FireGetOverlayType (CItemCtx &ItemCtx) const

//	FireGetOverlayType
//
//	Fire GetOverlayType event

	{
	SEventHandlerDesc Event;
	if (FindEventHandlerDeviceClass(evtGetOverlayType, &Event))
		{
		//	Setup arguments

		CCodeChainCtx Ctx;
		Ctx.SaveAndDefineSourceVar(ItemCtx.GetSource());
		Ctx.SaveAndDefineItemVar(ItemCtx);

		ICCItem *pResult = Ctx.Run(Event);

		DWORD dwUNID = 0;
		if (pResult->IsError())
			ItemCtx.GetSource()->ReportEventError(GET_OVERLAY_TYPE_EVENT, pResult);
		else if (!pResult->IsNil())
			dwUNID = pResult->GetIntegerValue();

		Ctx.Discard(pResult);

		//	Done

		return COverlayType::AsType(g_pUniverse->FindDesignType(dwUNID));
		}
	else
		return GetOverlayType();
	}
Пример #29
0
ICCItem *fnEval (CEvalContext *pCtx, ICCItem *pArguments, DWORD dwData)

//	fnEval
//
//	Evaluates an expression
//
//	(eval exp)

	{
	CCodeChain *pCC = pCtx->pCC;
	ICCItem *pArgs;
	ICCItem *pResult;

	//	Evaluate the arguments and validate them

	pArgs = pCC->EvaluateArgs(pCtx, pArguments, CONSTLIT("v"));
	if (pArgs->IsError())
		return pArgs;

	pResult = pCC->Eval(pCtx, pArgs->GetElement(0));

	//	Done

	pArgs->Discard(pCC);
	return pResult;
	}
Пример #30
0
ICCItem *CMission::FireOnDeclined (void)

//	FireOnDeclined
//
//	Fire <OnDeclined>. We return the result of the event, which might contain
//	instructions for the mission screen.
//
//	Callers are responsible for discarding the result, if not NULL.

	{
	SEventHandlerDesc Event;

	if (FindEventHandler(EVENT_ON_DECLINED, &Event))
		{
		CCodeChainCtx Ctx;

		Ctx.SaveAndDefineSourceVar(this);

		ICCItem *pResult = Ctx.Run(Event);
		if (pResult->IsError())
			{
			ReportEventError(EVENT_ON_DECLINED, pResult);
			Ctx.Discard(pResult);
			return NULL;
			}

		return pResult;
		}

	return NULL;
	}