bool
SymbolTable::AddFunction(Symbol *symbol) {
const FunctionType *ft = dynamic_cast<const FunctionType *>(symbol->type);
assert(ft != NULL);
if (LookupFunction(symbol->name.c_str(), ft) != NULL)
// A function of the same name and type has already been added to
// the symbol table
return false;
functions[symbol->name].push_back(symbol);
return true;
}
bool
SymbolTable::AddFunction(Symbol *symbol) {
const FunctionType *ft = CastType<FunctionType>(symbol->type);
Assert(ft != NULL);
if (LookupFunction(symbol->name.c_str(), ft) != NULL)
// A function of the same name and type has already been added to
// the symbol table
return false;
std::vector<Symbol *> &funOverloads = functions[symbol->name];
funOverloads.push_back(symbol);
return true;
}
int yglTexExtSetup(void)
{
int res;
yglMakeCurrent(glCurrWin3d);
if(glCurrWin3d->hasTexExt >= 0) return glCurrWin3d->hasTexExt;
res = isExtensionSupported("GL_EXT_texture");
res= 1;
if(res) {
glCurrWin3d->hasTexExt= 1;
glCurrWin3d->myglBindTexture3D = (glBindTextureProc) LookupFunction("glBindTexture3DEXT");
} else {
glCurrWin3d->hasTexExt= 0;
glCurrWin3d->myglBindTexture3D = NULL;
}
return glCurrWin3d->hasTexExt;
}
ICCItem *CCodeChain::Eval (CEvalContext *pEvalCtx, ICCItem *pItem)
// Eval
//
// Evaluates the given item and returns a result
{
// Errors always evaluate to themselves
if (pItem->IsError())
return pItem->Reference();
// If this item is quoted, then return an unquoted item
if (pItem->IsQuoted())
{
// If this is a literal symbol table then we need to evaluate its
// values.
if (pItem->IsSymbolTable())
return EvalLiteralStruct(pEvalCtx, pItem);
// HACK: We clone the item so that when we try to modify a literal list we
// mody a copy instead of the original.
else
{
ICCItem *pResult = pItem->Clone(this);
pResult->ClearQuoted();
return pResult;
}
}
// Evaluate differently depending on whether or not
// this is an atom or a list. If it is an atom, either return
// the value or look up the atom in a symbol table. If the item
// is a list, try to evaluate as a function
else if (pItem->IsIdentifier())
return Lookup(pEvalCtx, pItem);
// If this is an expression (a list with multiple terms) then we
// try to evaluate it.
else if (pItem->IsExpression())
{
ICCItem *pFunctionName;
ICCItem *pFunction;
ICCItem *pArgs;
ICCItem *pResult;
// The first element of the list is the function
pFunctionName = pItem->Head(this);
// We must have a first element since this is a list (but not Nil)
ASSERT(pFunctionName);
// If this is an identifier, then look up the function
// in the global symbols
if (pFunctionName->IsIdentifier())
pFunction = LookupFunction(pEvalCtx, pFunctionName);
// Otherwise, evaluate it
else
pFunction = Eval(pEvalCtx, pFunctionName);
// If we get an error, return it
if (pFunction->IsError())
return pFunction;
// Make sure this is a function
if (!pFunction->IsFunction())
{
pFunction->Discard(this);
return CreateError(LITERAL("Function name expected"), pFunctionName);
}
// Get the arguments
pArgs = pItem->Tail(this);
// Do it
pResult = pFunction->Execute(pEvalCtx, pArgs);
// Handle error by appending the function call that failed
if (pResult->IsError())
{
CCString *pError = dynamic_cast<CCString *>(pResult);
if (pError)
{
CString sError = pError->GetValue();
if (!sError.IsBlank())
{
char *pPos = sError.GetASCIIZPointer() + sError.GetLength() - 1;
if (*pPos != '#')
{
sError.Append(strPatternSubst(CONSTLIT(" ### %s ###"), pItem->Print(this)));
pError->SetValue(sError);
}
}
}
}
// Done
pFunction->Discard(this);
pArgs->Discard(this);
return pResult;
}
// Anything else is a literal so we return it.
else
return pItem->Reference();
}