zdoom
/
gzdoom
mirror of https://github.com/ZDoom/gzdoom.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Allow multiple actions per frame 

- You can now call several actions from one frame by grouping them between
  curly braces. i.e. :
   POSS G 3 { A_Pain; A_Log("Ow! That hurt!"); }
  I will probably add an `if (something) { blah; blah; } else { wah; wah; }`
  construct later, but that's the extent of the munging I plan for DECORATE. The
  real work goes to the scripting language, not here. But if this branch is
  getting merged to master sooner than later, here's an immediate benefit
  from it right now.
This commit is contained in:
Randy Heit 2015-01-07 22:32:58 -06:00
parent 9044ac9503
commit 7d0faa5bd5
5 changed files with 209 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
src/thingdef/thingdef.cpp
View File

@ -289,17 +289,15 @@ static void FinishThingdef()
FStateTempCall *tcall = StateTempCalls[i];
VMFunction *func;
assert(tcall->Call != NULL);
if (tcall->Call->GetArgCount() == 0)
{
// There are no arguments, so we can call this function directly
// without wrapping it in an anonymous function.
func = tcall->Call->GetVMFunction();
}
else
assert(tcall->Code != NULL);
// Can we call this function directly without wrapping it in an
// anonymous function? e.g. Are we passing any parameters to it?
func = tcall->Code->GetDirectFunction();
if (func == NULL)
{
FCompileContext ctx(tcall->ActorClass);
tcall->Call->Resolve(ctx);
tcall->Code->Resolve(ctx);
VMFunctionBuilder buildit;
// Allocate registers used to pass parameters in.
@ -307,7 +305,7 @@ static void FinishThingdef()
buildit.Registers[REGT_POINTER].Get(3);
// Emit a tail call via FxVMFunctionCall
tcall->Call->Emit(&buildit, true);
tcall->Code->Emit(&buildit, true);
VMScriptFunction *sfunc = buildit.MakeFunction();
sfunc->NumArgs = NAP;
@ -322,8 +320,8 @@ static void FinishThingdef()
codesize += sfunc->CodeSize;
}
}
delete tcall->Call;
tcall->Call = NULL;
delete tcall->Code;
tcall->Code = NULL;
for (int k = 0; k < tcall->NumStates; ++k)
{
tcall->ActorClass->OwnedStates[tcall->FirstState + k].SetAction(func);

7
src/thingdef/thingdef.h
View File

@ -119,10 +119,10 @@ public:
struct FStateTempCall
{
FStateTempCall() : ActorClass(NULL), Call(NULL), FirstState(0), NumStates(0) {}
FStateTempCall() : ActorClass(NULL), Code(NULL), FirstState(0), NumStates(0) {}
PClassActor *ActorClass;
class FxVMFunctionCall *Call;
class FxTailable *Code;
int FirstState;
int NumStates;
};
@ -189,7 +189,8 @@ AFuncDesc *FindFunction(const char * string);
void ParseStates(FScanner &sc, PClassActor *actor, AActor *defaults, Baggage &bag);
void ParseFunctionParameters(FScanner &sc, PClassActor *cls, TArray<FxExpression *> &out_params,
PFunction *afd, FString statestring, FStateDefinitions *statedef);
bool ParseAction(FScanner &sc, FState state, FString statestring, FStateTempCall *tcall, Baggage &bag);
void ParseActions(FScanner &sc, FState state, FString statestring, FStateTempCall *tcall, Baggage &bag);
class FxVMFunctionCall *ParseAction(FScanner &sc, FState state, FString statestring, Baggage &bag);
PFunction *FindGlobalActionFunction(const char *name);

78
src/thingdef/thingdef_exp.h
View File

@ -782,28 +782,6 @@ public:
ExpEmit Emit(VMFunctionBuilder *build);
};
//==========================================================================
//
// FxVMFunctionCall
//
//==========================================================================
class FxVMFunctionCall : public FxExpression
{
PFunction *Function;
FArgumentList *ArgList;
PType *ReturnType;
public:
FxVMFunctionCall(PFunction *func, FArgumentList *args, const FScriptPosition &pos);
~FxVMFunctionCall();
FxExpression *Resolve(FCompileContext&);
virtual ExpEmit Emit(VMFunctionBuilder *build);
ExpEmit Emit(VMFunctionBuilder *build, bool tailcall);
unsigned GetArgCount() { return ArgList == NULL ? 0 : ArgList->Size(); }
VMFunction *GetVMFunction() { return Function->Variants[0].Implementation; }
};
//==========================================================================
//
// FxGlobalFunctionCall
@ -823,6 +801,62 @@ public:
ExpEmit Emit(VMFunctionBuilder *build);
};
//==========================================================================
//
// FxTailable
//
// An expression that can produce a tail call
//
//==========================================================================
class FxTailable : public FxExpression
{
public:
FxTailable(const FScriptPosition &pos) : FxExpression(pos) {}
virtual ExpEmit Emit(VMFunctionBuilder *build, bool tailcall) = 0;
ExpEmit Emit(VMFunctionBuilder *build);
virtual VMFunction *GetDirectFunction();
};
//==========================================================================
//
// FxVMFunctionCall
//
//==========================================================================
class FxVMFunctionCall : public FxTailable
{
PFunction *Function;
FArgumentList *ArgList;
PType *ReturnType;
public:
FxVMFunctionCall(PFunction *func, FArgumentList *args, const FScriptPosition &pos);
~FxVMFunctionCall();
FxExpression *Resolve(FCompileContext&);
ExpEmit Emit(VMFunctionBuilder *build, bool tailcall);
unsigned GetArgCount() { return ArgList == NULL ? 0 : ArgList->Size(); }
VMFunction *GetVMFunction() { return Function->Variants[0].Implementation; }
VMFunction *GetDirectFunction();
};
//==========================================================================
//
// FxSequence
//
//==========================================================================
class FxSequence : public FxTailable
{
TDeletingArray<FxTailable *> Expressions;
public:
FxSequence(const FScriptPosition &pos) : FxTailable(pos) {}
FxExpression *Resolve(FCompileContext&);
ExpEmit Emit(VMFunctionBuilder *build, bool tailcall);
void Add(FxTailable *expr) { Expressions.Push(expr); }
VMFunction *GetDirectFunction();
};
//==========================================================================
//

108
src/thingdef/thingdef_expression.cpp
View File

@ -3004,6 +3004,28 @@ ExpEmit FxActionSpecialCall::Emit(VMFunctionBuilder *build)
return dest;
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxTailable::Emit(VMFunctionBuilder *build)
{
return Emit(build, false);
}
//==========================================================================
//
//
//
//==========================================================================
VMFunction *FxTailable::GetDirectFunction()
{
return NULL;
}
//==========================================================================
//
// FxVMFunctionCall
@ -3011,7 +3033,7 @@ ExpEmit FxActionSpecialCall::Emit(VMFunctionBuilder *build)
//==========================================================================
FxVMFunctionCall::FxVMFunctionCall(PFunction *func, FArgumentList *args, const FScriptPosition &pos)
: FxExpression(pos)
: FxTailable(pos)
{
Function = func;
ArgList = args;
@ -3082,15 +3104,10 @@ FxExpression *FxVMFunctionCall::Resolve(FCompileContext& ctx)
//
//==========================================================================
ExpEmit FxVMFunctionCall::Emit(VMFunctionBuilder *build)
{
return Emit(build, false);
}
ExpEmit FxVMFunctionCall::Emit(VMFunctionBuilder *build, bool tailcall)
{
assert(build->Registers[REGT_POINTER].GetMostUsed() >= 3);
int count = ArgList->Size();
int count = GetArgCount();
// Emit code to pass implied parameters
if (Function->Flags & VARF_Method)
@ -3105,9 +3122,12 @@ ExpEmit FxVMFunctionCall::Emit(VMFunctionBuilder *build, bool tailcall)
count += 2;
}
// Emit code to pass explicit parameters
for (unsigned i = 0; i < ArgList->Size(); ++i)
if (ArgList != NULL)
{
(*ArgList)[i]->Emit(build);
for (unsigned i = 0; i < ArgList->Size(); ++i)
{
(*ArgList)[i]->Emit(build);
}
}
// Get a constant register for this function
int funcaddr = build->GetConstantAddress(Function->Variants[0].Implementation, ATAG_OBJECT);
@ -3132,6 +3152,24 @@ ExpEmit FxVMFunctionCall::Emit(VMFunctionBuilder *build, bool tailcall)
}
}
//==========================================================================
//
// FxVMFunctionCall :: GetDirectFunction
//
// If the function is not passed any explicit arguments, returns the
// function. Otherwise returns NULL.
//
//==========================================================================
VMFunction *FxVMFunctionCall::GetDirectFunction()
{
if (GetArgCount() == 0)
{
return GetVMFunction();
}
return NULL;
}
//==========================================================================
//
//
@ -3221,6 +3259,58 @@ ExpEmit FxGlobalFunctionCall::Emit(VMFunctionBuilder *build)
return v;
}
//==========================================================================
//
// FxSequence :: Resolve
//
//==========================================================================
FxExpression *FxSequence::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
for (unsigned i = 0; i < Expressions.Size(); ++i)
{
if (NULL == (Expressions[i] = static_cast<FxTailable *>(Expressions[i]->Resolve(ctx))))
{
delete this;
return NULL;
}
}
return this;
}
//==========================================================================
//
// FxSequence :: Emit
//
//==========================================================================
ExpEmit FxSequence::Emit(VMFunctionBuilder *build, bool tailcall)
{
for (unsigned i = 0; i < Expressions.Size(); ++i)
{
ExpEmit v = Expressions[i]->Emit(build, tailcall ? i == Expressions.Size()-1 : false);
// Throw away any result. We don't care about it.
v.Free(build);
}
return ExpEmit();
}
//==========================================================================
//
// FxSequence :: GetDirectFunction
//
//==========================================================================
VMFunction *FxSequence::GetDirectFunction()
{
if (Expressions.Size() == 1)
{
return Expressions[0]->GetDirectFunction();
}
return NULL;
}
//==========================================================================
//
//==========================================================================

52
src/thingdef/thingdef_states.cpp
View File

@ -314,10 +314,8 @@ do_stop:
continue;
}
if (ParseAction(sc, state, statestring, tcall, bag))
{
goto endofstate;
}
ParseActions(sc, state, statestring, tcall, bag);
goto endofstate;
}
sc.UnGet();
endofstate:
@ -327,7 +325,7 @@ endofstate:
sc.ScriptError ("Invalid frame character string '%s'", statestring.GetChars());
count = -count;
}
if (tcall->Call != NULL)
if (tcall->Code != NULL)
{
tcall->ActorClass = actor;
tcall->FirstState = bag.statedef.GetStateCount() - count;
@ -348,21 +346,51 @@ endofstate:
sc.SetEscape(true); // re-enable escape sequences
}
//==========================================================================
//
// ParseActions
//
//==========================================================================
void ParseActions(FScanner &sc, FState state, FString statestring, FStateTempCall *tcall, Baggage &bag)
{
// If it's not a '{', then it should be a single action.
// Otherwise, it's a sequence of actions.
if (!sc.Compare("{"))
{
tcall->Code = ParseAction(sc, state, statestring, bag);
return;
}
FxSequence *seq = new FxSequence(sc);
sc.MustGetString();
while (!sc.Compare("}"))
{
FxVMFunctionCall *call = ParseAction(sc, state, statestring, bag);
seq->Add(call);
sc.MustGetStringName(";");
sc.MustGetString();
}
tcall->Code = seq;
}
//==========================================================================
//
// ParseAction
//
//==========================================================================
bool ParseAction(FScanner &sc, FState state, FString statestring, FStateTempCall *tcall, Baggage &bag)
FxVMFunctionCall *ParseAction(FScanner &sc, FState state, FString statestring, Baggage &bag)
{
FxVMFunctionCall *call;
// Make the action name lowercase
strlwr (sc.String);
tcall->Call = DoActionSpecials(sc, state, bag);
if (tcall->Call != NULL)
call = DoActionSpecials(sc, state, bag);
if (call != NULL)
{
return true;
return call;
}
PFunction *afd = dyn_cast<PFunction>(bag.Info->Symbols.FindSymbol(FName(sc.String, true), true));
@ -370,15 +398,15 @@ bool ParseAction(FScanner &sc, FState state, FString statestring, FStateTempCall
{
FArgumentList *args = new FArgumentList;
ParseFunctionParameters(sc, bag.Info, *args, afd, statestring, &bag.statedef);
tcall->Call = new FxVMFunctionCall(afd, args->Size() > 0 ? args : NULL, sc);
call = new FxVMFunctionCall(afd, args->Size() > 0 ? args : NULL, sc);
if (args->Size() == 0)
{
delete args;
}
return true;
return call;
}
sc.ScriptError("Invalid state parameter %s\n", sc.String);
return false;
return NULL;
}
//==========================================================================