static void ParseActionDef (FScanner &sc, PClassActor *cls)
{
unsigned int error = 0;
FName funcname;
TArray<PType *> rets;
if (sc.LumpNum == -1 || Wads.GetLumpFile(sc.LumpNum) > 0)
{
sc.ScriptMessage ("Action functions can only be imported by internal class and actor definitions!");
FScriptPosition::ErrorCounter++;
}
sc.MustGetToken(TK_Native);
// check for a return value
do
{
if (sc.CheckToken(TK_Int) || sc.CheckToken(TK_Bool))
{
rets.Push(TypeSInt32);
}
else if (sc.CheckToken(TK_State))
{
rets.Push(TypeState);
}
else if (sc.CheckToken(TK_Float))
{
rets.Push(TypeFloat64);
}
}
while (sc.CheckToken(','));
sc.MustGetToken(TK_Identifier);
funcname = sc.String;
ParseFunctionDef(sc, cls, funcname, rets, VARF_Method | VARF_Action);
}
/*
================
ParseDefs
Called at the outer layer and when a local statement is hit
================
*/
void Compiler::ParseDefs( void )
{
str name;
type_t *type;
if ( lex.pr_token_type == tt_preprocessor )
{
if ( lex.Check( "#include" ) )
{
if ( pr_scope )
{
lex.ParseError( "#include can only be used globally." );
}
if ( ( lex.pr_token_type != tt_immediate ) || ( lex.pr_immediate_type != &type_string ) )
{
lex.ParseError( "Expected quoted filename" );
}
program.Compile( lex.pr_immediate_string );
lex.Lex();
return;
}
else
{
lex.ParseError( "Unknown preprocessor command" );
}
return;
}
type = lex.ParseType();
name = lex.ParseName();
// check for a function prototype or declaraction
if ( lex.Check( "(" ) )
{
ParseFunctionDef( type, name.c_str() );
}
else
{
ParseVariableDef( type, name.c_str() );
while( lex.Check( "," ) )
{
name = lex.ParseName();
ParseVariableDef( type, name.c_str() );
}
lex.Expect( ";" );
}
}
static void ParseNativeFunction(FScanner &sc, PClassActor *cls)
{
TArray<PType *> rets(1);
if (sc.LumpNum == -1 || Wads.GetLumpFile(sc.LumpNum) > 0)
{
sc.ScriptMessage ("functions can only be declared by native actors!");
FScriptPosition::ErrorCounter++;
}
// Read the type and make sure it's int or float.
sc.MustGetAnyToken();
switch (sc.TokenType)
{
case TK_Int:
case TK_Bool:
rets.Push(TypeSInt32);
break;
case TK_Float:
rets.Push(TypeFloat64);
break;
case TK_Angle_t:
rets.Push(TypeAngle);
break;
case TK_Fixed_t:
rets.Push(TypeFixed);
break;
case TK_State:
rets.Push(TypeState);
break;
case TK_Identifier:
rets.Push(NewPointer(RUNTIME_CLASS(DObject)));
// Todo: Object type
sc.ScriptError("Object type variables not implemented yet!");
break;
default:
sc.ScriptError("Invalid return type %s", sc.String);
return;
}
sc.MustGetToken(TK_Identifier);
ParseFunctionDef(sc, cls, sc.String, rets, VARF_Method);
}
void CO_ParseDefs (void)
{
int i;
const char *name;
def_t *def;
type_t *type;
int elementCount;
gofs_t offset;
type = PR_ParseType();
if (type == &type_union)
{
if (pr_scope)
{
PR_ParseError("unions must be global");
}
ParseUnion();
return;
}
if (pr_scope && (type->type == ev_field || type->type == ev_function))
{
PR_ParseError("fields and functions must be global");
}
do
{
name = PR_ParseName();
if (TK_CHECK(TK_LPAREN))
{
ParseCStyleFunctionDef(name, type);
return;
}
elementCount = 0;
if (TK_CHECK(TK_LBRACKET))
{
def = GetArrayDef(name, type, &elementCount);
}
else
{
def = PR_GetDef(type, name, pr_scope, true);
}
// Check for initialization
if (TK_CHECK(TK_ASSIGN))
{
if (def->initialized)
{
PR_ParseError("'%s' : redefinition", name);
}
if (type->type == ev_field)
{
PR_ParseError("fields cannot be initialized");
}
if (elementCount != 0)
{
LX_Require("{");
i = 0;
offset = def->ofs;
do
{
if (pr_token_type != tt_immediate)
{
PR_ParseError("immediate type required for %s", name);
}
if (pr_immediate_type->type != type->type)
{
PR_ParseError("wrong immediate type for %s", name);
}
memcpy(pr_globals+offset, &pr_immediate, 4*type_size[pr_immediate_type->type]);
offset += type_size[pr_immediate_type->type];
i++;
LX_Fetch();
} while (TK_CHECK(TK_COMMA));
LX_Require("}");
if (i != elementCount)
{
PR_ParseError("element count mismatch in array"
" initialization");
}
def->initialized = 1;
continue;
}
else if (type->type == ev_function)
{
ParseFunctionDef(def, type);
continue;
}
else if (pr_immediate_type != type)
{
PR_ParseError("wrong immediate type for %s", name);
}
def->initialized = 1;
memcpy(pr_globals+def->ofs, &pr_immediate, 4*type_size[pr_immediate_type->type]);
LX_Fetch();
}
else if (elementCount != 0 && type->type != ev_field)
{
memset(pr_globals+def->ofs, 0, elementCount*4*type_size[type->type]);
def->initialized = 1;
}
} while (TK_CHECK(TK_COMMA));
LX_Require(";");
}
