zdoom/qzdoom
0
0
Fork 0
mirror of https://github.com/ZDoom/qzdoom.git synced 2024-12-14 14:31:53 +00:00
Code Issues Projects Releases Packages Wiki Activity
qzdoom/src/scripting/thingdef.cpp

539 lines
18 KiB
C++
Raw Normal View History

Normalize line endings
2016-03-01 15:47:10 +00:00
/*
** thingdef.cpp
**
** Actor definitions
**
**---------------------------------------------------------------------------
** Copyright 2002-2008 Christoph Oelckers
** Copyright 2004-2008 Randy Heit
** All rights reserved.
**
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions
** are met:
**
** 1. Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** 2. Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in the
** documentation and/or other materials provided with the distribution.
** 3. The name of the author may not be used to endorse or promote products
** derived from this software without specific prior written permission.
** 4. When not used as part of ZDoom or a ZDoom derivative, this code will be
** covered by the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 2 of the License, or (at
** your option) any later version.
**
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**---------------------------------------------------------------------------
**
*/
#include "gi.h"
#include "actor.h"
#include "r_defs.h"
#include "a_pickups.h"
#include "cmdlib.h"
#include "p_lnspec.h"
#include "decallib.h"
#include "p_local.h"
- scriptified the rest of the weapon pieces.
2017-01-18 17:46:24 +00:00
#include "a_weapons.h"
Normalize line endings
2016-03-01 15:47:10 +00:00
#include "p_conversation.h"
#include "v_text.h"
- moved a few things around to have them into better fitting places.
2017-02-08 11:24:08 +00:00
#include "backend/codegen.h"
Normalize line endings
2016-03-01 15:47:10 +00:00
#include "stats.h"
- moved the 'Finalize' methods back into a single function in the parser code. It has been like this initially but was changed when ZDoom gained an overly complicated polymorphic class descriptor object that required a lot of support code. All these complications have long been removed but these methods remained. Since they prevent a class from being moved to the script side entirely they had to be removed. This was the last major blocker to make Weapon a purely scripted class, the only remaining native method is Serialize which is of no concern for the coming work.
2018-11-25 07:16:18 +00:00
#include "info.h"
#include "thingdef.h"
Normalize line endings
2016-03-01 15:47:10 +00:00
// EXTERNAL FUNCTION PROTOTYPES --------------------------------------------
void InitThingdef();
// STATIC FUNCTION PROTOTYPES --------------------------------------------
- added compile time checks for bad state links and state label references. - preserve a state's source line information for the postprocessing phase so that the checker can output more useful information. - added missing check for weapon psprites to DPSprite::SetState.
2016-11-15 10:21:08 +00:00
static TMap<FState *, FScriptPosition> StateSourceLines;
static FScriptPosition unknownstatesource("unknown file", 0);
- moved the 'Finalize' methods back into a single function in the parser code. It has been like this initially but was changed when ZDoom gained an overly complicated polymorphic class descriptor object that required a lot of support code. All these complications have long been removed but these methods remained. Since they prevent a class from being moved to the script side entirely they had to be removed. This was the last major blocker to make Weapon a purely scripted class, the only remaining native method is Serialize which is of no concern for the coming work.
2018-11-25 07:16:18 +00:00
//==========================================================================
//
// PClassActor :: Finalize
//
// Installs the parsed states and does some sanity checking
//
//==========================================================================
void FinalizeClass(PClass *ccls, FStateDefinitions &statedef)
{
if (!ccls->IsDescendantOf(NAME_Actor)) return;
auto cls = static_cast<PClassActor*>(ccls);
try
{
statedef.FinishStates(cls);
}
catch (CRecoverableError &)
{
statedef.MakeStateDefines(nullptr);
throw;
}
auto def = GetDefaultByType(cls);
statedef.InstallStates(cls, def);
statedef.MakeStateDefines(nullptr);
if (cls->IsDescendantOf(NAME_Inventory))
{
def->flags |= MF_SPECIAL;
}
if (cls->IsDescendantOf(NAME_Weapon))
{
FState *ready = def->FindState(NAME_Ready);
FState *select = def->FindState(NAME_Select);
FState *deselect = def->FindState(NAME_Deselect);
FState *fire = def->FindState(NAME_Fire);
auto TypeName = cls->TypeName;
// Consider any weapon without any valid state abstract and don't output a warning
// This is for creating base classes for weapon groups that only set up some properties.
if (ready || select || deselect || fire)
{
if (!ready)
{
I_Error("Weapon %s doesn't define a ready state.", TypeName.GetChars());
}
if (!select)
{
I_Error("Weapon %s doesn't define a select state.", TypeName.GetChars());
}
if (!deselect)
{
I_Error("Weapon %s doesn't define a deselect state.", TypeName.GetChars());
}
if (!fire)
{
I_Error("Weapon %s doesn't define a fire state.", TypeName.GetChars());
}
}
}
}
- added compile time checks for bad state links and state label references. - preserve a state's source line information for the postprocessing phase so that the checker can output more useful information. - added missing check for weapon psprites to DPSprite::SetState.
2016-11-15 10:21:08 +00:00
//==========================================================================
//
// Saves the state's source lines for error messages during postprocessing
//
//==========================================================================
void SaveStateSourceLines(FState *firststate, TArray<FScriptPosition> &positions)
{
for (unsigned i = 0; i < positions.Size(); i++)
{
StateSourceLines[firststate + i] = positions[i];
}
}
FScriptPosition & GetStateSource(FState *state)
{
auto check = StateSourceLines.CheckKey(state);
return check ? *check : unknownstatesource;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
- separated the code generation from the DECORATE parser and cleaned up the interface to the code generator. Most importantly, the VMScriptFunctions are now preallocated when being added to the list of functions to compile and will be filled in later by the code generator. This allowed the removal of some ugly maintenance code.
2016-10-12 22:53:59 +00:00
// SetImplicitArgs
//
// Adds the parameters implied by the function flags.
Normalize line endings
2016-03-01 15:47:10 +00:00
//
//==========================================================================
- make PClass not inherit from PStruct. Having these two types related can cause problems with detection in the compiler because for some parts they need quite different handling. Common handling for the fields has been moved into PSymbolTable but overall redundancy was quite minor as both types share surprisingly little functionality.
2017-04-12 15:21:13 +00:00
void SetImplicitArgs(TArray<PType *> *args, TArray<uint32_t> *argflags, TArray<FName> *argnames, PContainerType *cls, uint32_t funcflags, int useflags)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- separated the code generation from the DECORATE parser and cleaned up the interface to the code generator. Most importantly, the VMScriptFunctions are now preallocated when being added to the list of functions to compile and will be filled in later by the code generator. This allowed the removal of some ugly maintenance code.
2016-10-12 22:53:59 +00:00
// Must be called before adding any other arguments.
- more preparations to compile functions: * Allow PFunction to work without a VMFunction being attached. * The Variant for a function must store the prototype itself instead of relying on the VMFunction it points to. Otherwise it would not be possible to reference a prototype during compilation of the function because it does not exist yet. * Give the variant a list of the function's argument's names, because these are also needed to compile the function. * create an anonymous function symbol when the function gets registered to the builder. At this point we have all the needed information to set it up correctly, but later this is no longer the case. This is the most convenient info to have here because it contains everything that's needed to compile the function in the proper context, so it has to be present when starting compilation. * added some preparations to implement special handling for weapons and custom inventory items, which can run action functions in another actor's context. This part is not active yet but the basics are present in SetImplicitArgs.
2016-10-15 12:36:08 +00:00
assert(args == nullptr || args->Size() == 0);
assert(argflags == nullptr || argflags->Size() == 0);
Normalize line endings
2016-03-01 15:47:10 +00:00
- separated the code generation from the DECORATE parser and cleaned up the interface to the code generator. Most importantly, the VMScriptFunctions are now preallocated when being added to the list of functions to compile and will be filled in later by the code generator. This allowed the removal of some ugly maintenance code.
2016-10-12 22:53:59 +00:00
if (funcflags & VARF_Method)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- separated the code generation from the DECORATE parser and cleaned up the interface to the code generator. Most importantly, the VMScriptFunctions are now preallocated when being added to the list of functions to compile and will be filled in later by the code generator. This allowed the removal of some ugly maintenance code.
2016-10-12 22:53:59 +00:00
// implied self pointer
- declared most native getters in Actor as const. - made the self pointer of const functions readonly. This seems to work fine. Both calling a non-const function and trying to assign a value to a member fail with an error message.
2017-03-04 11:43:07 +00:00
if (args != nullptr) args->Push(NewPointer(cls, !!(funcflags & VARF_ReadOnly)));
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
if (argflags != nullptr) argflags->Push(VARF_Implicit | VARF_ReadOnly);
- more preparations to compile functions: * Allow PFunction to work without a VMFunction being attached. * The Variant for a function must store the prototype itself instead of relying on the VMFunction it points to. Otherwise it would not be possible to reference a prototype during compilation of the function because it does not exist yet. * Give the variant a list of the function's argument's names, because these are also needed to compile the function. * create an anonymous function symbol when the function gets registered to the builder. At this point we have all the needed information to set it up correctly, but later this is no longer the case. This is the most convenient info to have here because it contains everything that's needed to compile the function in the proper context, so it has to be present when starting compilation. * added some preparations to implement special handling for weapons and custom inventory items, which can run action functions in another actor's context. This part is not active yet but the basics are present in SetImplicitArgs.
2016-10-15 12:36:08 +00:00
if (argnames != nullptr) argnames->Push(NAME_self);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- separated the code generation from the DECORATE parser and cleaned up the interface to the code generator. Most importantly, the VMScriptFunctions are now preallocated when being added to the list of functions to compile and will be filled in later by the code generator. This allowed the removal of some ugly maintenance code.
2016-10-12 22:53:59 +00:00
if (funcflags & VARF_Action)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- declared most native getters in Actor as const. - made the self pointer of const functions readonly. This seems to work fine. Both calling a non-const function and trying to assign a value to a member fail with an error message.
2017-03-04 11:43:07 +00:00
assert(!(funcflags & VARF_ReadOnly));
- separated the code generation from the DECORATE parser and cleaned up the interface to the code generator. Most importantly, the VMScriptFunctions are now preallocated when being added to the list of functions to compile and will be filled in later by the code generator. This allowed the removal of some ugly maintenance code.
2016-10-12 22:53:59 +00:00
// implied caller and callingstate pointers
- more preparations to compile functions: * Allow PFunction to work without a VMFunction being attached. * The Variant for a function must store the prototype itself instead of relying on the VMFunction it points to. Otherwise it would not be possible to reference a prototype during compilation of the function because it does not exist yet. * Give the variant a list of the function's argument's names, because these are also needed to compile the function. * create an anonymous function symbol when the function gets registered to the builder. At this point we have all the needed information to set it up correctly, but later this is no longer the case. This is the most convenient info to have here because it contains everything that's needed to compile the function in the proper context, so it has to be present when starting compilation. * added some preparations to implement special handling for weapons and custom inventory items, which can run action functions in another actor's context. This part is not active yet but the basics are present in SetImplicitArgs.
2016-10-15 12:36:08 +00:00
if (args != nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- added compile time checks for bad state links and state label references. - preserve a state's source line information for the postprocessing phase so that the checker can output more useful information. - added missing check for weapon psprites to DPSprite::SetState.
2016-11-15 10:21:08 +00:00
// Special treatment for weapons and CustomInventory flagged functions: 'self' is not the defining class but the actual user of the item, so this pointer must be of type 'Actor'
if (useflags & (SUF_WEAPON|SUF_ITEM))
- more preparations to compile functions: * Allow PFunction to work without a VMFunction being attached. * The Variant for a function must store the prototype itself instead of relying on the VMFunction it points to. Otherwise it would not be possible to reference a prototype during compilation of the function because it does not exist yet. * Give the variant a list of the function's argument's names, because these are also needed to compile the function. * create an anonymous function symbol when the function gets registered to the builder. At this point we have all the needed information to set it up correctly, but later this is no longer the case. This is the most convenient info to have here because it contains everything that's needed to compile the function in the proper context, so it has to be present when starting compilation. * added some preparations to implement special handling for weapons and custom inventory items, which can run action functions in another actor's context. This part is not active yet but the basics are present in SetImplicitArgs.
2016-10-15 12:36:08 +00:00
{
- pass the current function to the compile context instead of just the containing class.
2016-10-15 15:40:27 +00:00
args->Insert(0, NewPointer(RUNTIME_CLASS(AActor))); // this must go in before the real pointer to the containing class.
- more preparations to compile functions: * Allow PFunction to work without a VMFunction being attached. * The Variant for a function must store the prototype itself instead of relying on the VMFunction it points to. Otherwise it would not be possible to reference a prototype during compilation of the function because it does not exist yet. * Give the variant a list of the function's argument's names, because these are also needed to compile the function. * create an anonymous function symbol when the function gets registered to the builder. At this point we have all the needed information to set it up correctly, but later this is no longer the case. This is the most convenient info to have here because it contains everything that's needed to compile the function in the proper context, so it has to be present when starting compilation. * added some preparations to implement special handling for weapons and custom inventory items, which can run action functions in another actor's context. This part is not active yet but the basics are present in SetImplicitArgs.
2016-10-15 12:36:08 +00:00
}
- Added AStateProvider class which is used to define the special action function behavior of weapons and custom inventorys. The class itself does not do anything, but the compiler will use it to set up the action function prototypes differently which in turn will be used to do type checking during code generation.
2016-10-15 13:10:48 +00:00
else
- more preparations to compile functions: * Allow PFunction to work without a VMFunction being attached. * The Variant for a function must store the prototype itself instead of relying on the VMFunction it points to. Otherwise it would not be possible to reference a prototype during compilation of the function because it does not exist yet. * Give the variant a list of the function's argument's names, because these are also needed to compile the function. * create an anonymous function symbol when the function gets registered to the builder. At this point we have all the needed information to set it up correctly, but later this is no longer the case. This is the most convenient info to have here because it contains everything that's needed to compile the function in the proper context, so it has to be present when starting compilation. * added some preparations to implement special handling for weapons and custom inventory items, which can run action functions in another actor's context. This part is not active yet but the basics are present in SetImplicitArgs.
2016-10-15 12:36:08 +00:00
{
- pass the current function to the compile context instead of just the containing class.
2016-10-15 15:40:27 +00:00
args->Push(NewPointer(cls));
- more preparations to compile functions: * Allow PFunction to work without a VMFunction being attached. * The Variant for a function must store the prototype itself instead of relying on the VMFunction it points to. Otherwise it would not be possible to reference a prototype during compilation of the function because it does not exist yet. * Give the variant a list of the function's argument's names, because these are also needed to compile the function. * create an anonymous function symbol when the function gets registered to the builder. At this point we have all the needed information to set it up correctly, but later this is no longer the case. This is the most convenient info to have here because it contains everything that's needed to compile the function in the proper context, so it has to be present when starting compilation. * added some preparations to implement special handling for weapons and custom inventory items, which can run action functions in another actor's context. This part is not active yet but the basics are present in SetImplicitArgs.
2016-10-15 12:36:08 +00:00
}
- implemented pass-by-reference arguments - so far only for memory based variables. - changed Dehacked weapon function lookup to check the symbol table instead of directly referencing the VM functions. Once scriptified these pointers will no longer be available. - removed all special ATAGs from the VM. While well intentioned any pointer tagged with them is basically unusable because it'd trigger asserts all over the place. - scriptified A_Punch for testing pass-by-reference parameters and stack variables.
2016-11-19 00:23:56 +00:00
args->Push(NewPointer(NewStruct("FStateParamInfo", nullptr)));
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- more preparations to compile functions: * Allow PFunction to work without a VMFunction being attached. * The Variant for a function must store the prototype itself instead of relying on the VMFunction it points to. Otherwise it would not be possible to reference a prototype during compilation of the function because it does not exist yet. * Give the variant a list of the function's argument's names, because these are also needed to compile the function. * create an anonymous function symbol when the function gets registered to the builder. At this point we have all the needed information to set it up correctly, but later this is no longer the case. This is the most convenient info to have here because it contains everything that's needed to compile the function in the proper context, so it has to be present when starting compilation. * added some preparations to implement special handling for weapons and custom inventory items, which can run action functions in another actor's context. This part is not active yet but the basics are present in SetImplicitArgs.
2016-10-15 12:36:08 +00:00
if (argflags != nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
argflags->Push(VARF_Implicit | VARF_ReadOnly);
argflags->Push(VARF_Implicit | VARF_ReadOnly);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- more preparations to compile functions: * Allow PFunction to work without a VMFunction being attached. * The Variant for a function must store the prototype itself instead of relying on the VMFunction it points to. Otherwise it would not be possible to reference a prototype during compilation of the function because it does not exist yet. * Give the variant a list of the function's argument's names, because these are also needed to compile the function. * create an anonymous function symbol when the function gets registered to the builder. At this point we have all the needed information to set it up correctly, but later this is no longer the case. This is the most convenient info to have here because it contains everything that's needed to compile the function in the proper context, so it has to be present when starting compilation. * added some preparations to implement special handling for weapons and custom inventory items, which can run action functions in another actor's context. This part is not active yet but the basics are present in SetImplicitArgs.
2016-10-15 12:36:08 +00:00
if (argnames != nullptr)
{
argnames->Push(NAME_invoker);
argnames->Push(NAME_stateinfo);
}
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
- more preparations to compile functions: * Allow PFunction to work without a VMFunction being attached. * The Variant for a function must store the prototype itself instead of relying on the VMFunction it points to. Otherwise it would not be possible to reference a prototype during compilation of the function because it does not exist yet. * Give the variant a list of the function's argument's names, because these are also needed to compile the function. * create an anonymous function symbol when the function gets registered to the builder. At this point we have all the needed information to set it up correctly, but later this is no longer the case. This is the most convenient info to have here because it contains everything that's needed to compile the function in the proper context, so it has to be present when starting compilation. * added some preparations to implement special handling for weapons and custom inventory items, which can run action functions in another actor's context. This part is not active yet but the basics are present in SetImplicitArgs.
2016-10-15 12:36:08 +00:00
//==========================================================================
//
// CreateAnonymousFunction
//
// Creates a function symbol for an anonymous function
// This contains actual info about the implied variables which is needed
// during code generation.
//
//==========================================================================
- make PClass not inherit from PStruct. Having these two types related can cause problems with detection in the compiler because for some parts they need quite different handling. Common handling for the fields has been moved into PSymbolTable but overall redundancy was quite minor as both types share surprisingly little functionality.
2017-04-12 15:21:13 +00:00
PFunction *CreateAnonymousFunction(PContainerType *containingclass, PType *returntype, int flags)
- more preparations to compile functions: * Allow PFunction to work without a VMFunction being attached. * The Variant for a function must store the prototype itself instead of relying on the VMFunction it points to. Otherwise it would not be possible to reference a prototype during compilation of the function because it does not exist yet. * Give the variant a list of the function's argument's names, because these are also needed to compile the function. * create an anonymous function symbol when the function gets registered to the builder. At this point we have all the needed information to set it up correctly, but later this is no longer the case. This is the most convenient info to have here because it contains everything that's needed to compile the function in the proper context, so it has to be present when starting compilation. * added some preparations to implement special handling for weapons and custom inventory items, which can run action functions in another actor's context. This part is not active yet but the basics are present in SetImplicitArgs.
2016-10-15 12:36:08 +00:00
{
- fixed issues with Dehacked's ad-hoc script code generation * The functions had no prototype and caused crashes. * even after creating a prototype it didn't work because CreateAnonymousFunction was set up incorrectly for the case where a known return type was given.
2018-12-03 11:24:55 +00:00
TArray<PType *> rets;
- more preparations to compile functions: * Allow PFunction to work without a VMFunction being attached. * The Variant for a function must store the prototype itself instead of relying on the VMFunction it points to. Otherwise it would not be possible to reference a prototype during compilation of the function because it does not exist yet. * Give the variant a list of the function's argument's names, because these are also needed to compile the function. * create an anonymous function symbol when the function gets registered to the builder. At this point we have all the needed information to set it up correctly, but later this is no longer the case. This is the most convenient info to have here because it contains everything that's needed to compile the function in the proper context, so it has to be present when starting compilation. * added some preparations to implement special handling for weapons and custom inventory items, which can run action functions in another actor's context. This part is not active yet but the basics are present in SetImplicitArgs.
2016-10-15 12:36:08 +00:00
TArray<PType *> args;
TArray<uint32_t> argflags;
TArray<FName> argnames;
- added compile time checks for bad state links and state label references. - preserve a state's source line information for the postprocessing phase so that the checker can output more useful information. - added missing check for weapon psprites to DPSprite::SetState.
2016-11-15 10:21:08 +00:00
// Functions that only get flagged for actors do not need the additional two context parameters.
int fflags = (flags& (SUF_OVERLAY | SUF_WEAPON | SUF_ITEM)) ? VARF_Action | VARF_Method : VARF_Method;
Dynamic virtualscope checking. May yet be buggy.
2017-02-18 04:27:28 +00:00
// [ZZ] give anonymous functions the scope of their class
// (just give them VARF_Play, whatever)
fflags |= VARF_Play;
- fixed issues with Dehacked's ad-hoc script code generation * The functions had no prototype and caused crashes. * even after creating a prototype it didn't work because CreateAnonymousFunction was set up incorrectly for the case where a known return type was given.
2018-12-03 11:24:55 +00:00
if (returntype) rets.Push(returntype);
- added compile time checks for bad state links and state label references. - preserve a state's source line information for the postprocessing phase so that the checker can output more useful information. - added missing check for weapon psprites to DPSprite::SetState.
2016-11-15 10:21:08 +00:00
SetImplicitArgs(&args, &argflags, &argnames, containingclass, fflags, flags);
- more preparations to compile functions: * Allow PFunction to work without a VMFunction being attached. * The Variant for a function must store the prototype itself instead of relying on the VMFunction it points to. Otherwise it would not be possible to reference a prototype during compilation of the function because it does not exist yet. * Give the variant a list of the function's argument's names, because these are also needed to compile the function. * create an anonymous function symbol when the function gets registered to the builder. At this point we have all the needed information to set it up correctly, but later this is no longer the case. This is the most convenient info to have here because it contains everything that's needed to compile the function in the proper context, so it has to be present when starting compilation. * added some preparations to implement special handling for weapons and custom inventory items, which can run action functions in another actor's context. This part is not active yet but the basics are present in SetImplicitArgs.
2016-10-15 12:36:08 +00:00
- block direct use of 'new' for DObjects. This is to ensure that the Class pointer can be set right on creation. ZDoom had always depended on handling this lazily which poses some problems for the VM. So now there is a variadic Create<classtype> function taking care of that, but to ensure that it gets used, direct access to the new operator has been blocked. This also neccessitated making DArgs a regular object because they get created before the type system is up. Since the few uses of DArgs are easily controllable this wasn't a big issue. - did a bit of optimization on the bots' decision making whether to pick up a health item or not.
2017-04-14 11:31:58 +00:00
PFunction *sym = Create<PFunction>(containingclass, NAME_None); // anonymous functions do not have names.
- implemented usage restrictions for action functions.
2016-11-15 20:38:12 +00:00
sym->AddVariant(NewPrototype(rets, args), argflags, argnames, nullptr, fflags, flags);
- more preparations to compile functions: * Allow PFunction to work without a VMFunction being attached. * The Variant for a function must store the prototype itself instead of relying on the VMFunction it points to. Otherwise it would not be possible to reference a prototype during compilation of the function because it does not exist yet. * Give the variant a list of the function's argument's names, because these are also needed to compile the function. * create an anonymous function symbol when the function gets registered to the builder. At this point we have all the needed information to set it up correctly, but later this is no longer the case. This is the most convenient info to have here because it contains everything that's needed to compile the function in the proper context, so it has to be present when starting compilation. * added some preparations to implement special handling for weapons and custom inventory items, which can run action functions in another actor's context. This part is not active yet but the basics are present in SetImplicitArgs.
2016-10-15 12:36:08 +00:00
return sym;
}
- added FindClassMemberFunction which retrieves a function symbol and performs some verification. - removed Self parameter from FxFunctionCall. Actual member function calls through an object require quite different handling so lumping these two together makes no sense. - added a workaround to deal with ACS_NamedExecuteWithResult to both the compiler and FindClassMemberFunction. The way the ZScript compiler sets this up means that it will call the builtin, not the actual action function, so the parser needs to do some explicit check to get past the same-named action function. - pass a proper self pointer to FxActionSpecial. Although it's still not being used, propagating design shortcuts through several function levels is a very, very bad idea.
2016-10-15 18:16:44 +00:00
//==========================================================================
//
// FindClassMemberFunction
//
// Looks for a name in a class's symbol table and outputs appropriate messages
//
//==========================================================================
- fixed code emission for constant ZScript function arguments
2019-01-23 21:37:16 +00:00
PFunction *FindClassMemberFunction(PContainerType *selfcls, PContainerType *funccls, FName name, FScriptPosition &sc, bool *error, const VersionInfo &version, bool nodeprecated)
- added FindClassMemberFunction which retrieves a function symbol and performs some verification. - removed Self parameter from FxFunctionCall. Actual member function calls through an object require quite different handling so lumping these two together makes no sense. - added a workaround to deal with ACS_NamedExecuteWithResult to both the compiler and FindClassMemberFunction. The way the ZScript compiler sets this up means that it will call the builtin, not the actual action function, so the parser needs to do some explicit check to get past the same-named action function. - pass a proper self pointer to FxActionSpecial. Although it's still not being used, propagating design shortcuts through several function levels is a very, very bad idea.
2016-10-15 18:16:44 +00:00
{
// Skip ACS_NamedExecuteWithResult. Anything calling this should use the builtin instead.
if (name == NAME_ACS_NamedExecuteWithResult) return nullptr;
PSymbolTable *symtable;
auto symbol = selfcls->Symbols.FindSymbolInTable(name, symtable);
auto funcsym = dyn_cast<PFunction>(symbol);
if (symbol != nullptr)
{
- removed all RTTI checks for the types.
2017-04-13 13:13:14 +00:00
auto cls_ctx = PType::toClass(funccls);
auto cls_target = funcsym ? PType::toClass(funcsym->OwningClass) : nullptr;
- added FindClassMemberFunction which retrieves a function symbol and performs some verification. - removed Self parameter from FxFunctionCall. Actual member function calls through an object require quite different handling so lumping these two together makes no sense. - added a workaround to deal with ACS_NamedExecuteWithResult to both the compiler and FindClassMemberFunction. The way the ZScript compiler sets this up means that it will call the builtin, not the actual action function, so the parser needs to do some explicit check to get past the same-named action function. - pass a proper self pointer to FxActionSpecial. Although it's still not being used, propagating design shortcuts through several function levels is a very, very bad idea.
2016-10-15 18:16:44 +00:00
if (funcsym == nullptr)
{
- P_UndoPlayerMorph scriptified. Not tested yet and still missing a new native interface.
2018-11-24 07:17:30 +00:00
if (PClass::FindClass(name)) return nullptr; // Special case when a class's member variable hides a global class name. This should still work.
- added FindClassMemberFunction which retrieves a function symbol and performs some verification. - removed Self parameter from FxFunctionCall. Actual member function calls through an object require quite different handling so lumping these two together makes no sense. - added a workaround to deal with ACS_NamedExecuteWithResult to both the compiler and FindClassMemberFunction. The way the ZScript compiler sets this up means that it will call the builtin, not the actual action function, so the parser needs to do some explicit check to get past the same-named action function. - pass a proper self pointer to FxActionSpecial. Although it's still not being used, propagating design shortcuts through several function levels is a very, very bad idea.
2016-10-15 18:16:44 +00:00
sc.Message(MSG_ERROR, "%s is not a member function of %s", name.GetChars(), selfcls->TypeName.GetChars());
}
Class abstractness should be inherited
2017-02-16 00:31:20 +00:00
else if ((funcsym->Variants[0].Flags & VARF_Private) && symtable != &funccls->Symbols)
- added FindClassMemberFunction which retrieves a function symbol and performs some verification. - removed Self parameter from FxFunctionCall. Actual member function calls through an object require quite different handling so lumping these two together makes no sense. - added a workaround to deal with ACS_NamedExecuteWithResult to both the compiler and FindClassMemberFunction. The way the ZScript compiler sets this up means that it will call the builtin, not the actual action function, so the parser needs to do some explicit check to get past the same-named action function. - pass a proper self pointer to FxActionSpecial. Although it's still not being used, propagating design shortcuts through several function levels is a very, very bad idea.
2016-10-15 18:16:44 +00:00
{
// private access is only allowed if the symbol table belongs to the class in which the current function is being defined.
sc.Message(MSG_ERROR, "%s is declared private and not accessible", symbol->SymbolName.GetChars());
}
- separated class descriptors from VM types. Combining these two groups of data has been the cause of many hard to detect errors because it allowed liberal casting between types that are used for completely different things.
2017-04-12 20:46:49 +00:00
else if ((funcsym->Variants[0].Flags & VARF_Protected) && symtable != &funccls->Symbols && (!cls_ctx || !cls_target || !cls_ctx->Descriptor->IsDescendantOf(cls_target->Descriptor)))
Protected on methods of StaticEventHandler is completely useless
2017-03-04 22:52:43 +00:00
{
sc.Message(MSG_ERROR, "%s is declared protected and not accessible", symbol->SymbolName.GetChars());
}
- fixed code emission for constant ZScript function arguments
2019-01-23 21:37:16 +00:00
// ZScript will skip this because it prints its own message.
else if ((funcsym->Variants[0].Flags & VARF_Deprecated) && funcsym->mVersion <= version && !nodeprecated)
- added FindClassMemberFunction which retrieves a function symbol and performs some verification. - removed Self parameter from FxFunctionCall. Actual member function calls through an object require quite different handling so lumping these two together makes no sense. - added a workaround to deal with ACS_NamedExecuteWithResult to both the compiler and FindClassMemberFunction. The way the ZScript compiler sets this up means that it will call the builtin, not the actual action function, so the parser needs to do some explicit check to get past the same-named action function. - pass a proper self pointer to FxActionSpecial. Although it's still not being used, propagating design shortcuts through several function levels is a very, very bad idea.
2016-10-15 18:16:44 +00:00
{
sc.Message(MSG_WARNING, "Call to deprecated function %s", symbol->SymbolName.GetChars());
}
}
// return nullptr if the name cannot be found in the symbol table so that the calling code can do other checks.
return funcsym;
}
- removed the FxDamageValue hack and implemented it properly using FxReturnStatement. - added handling of damage functions for ZScript.
2016-10-26 12:04:49 +00:00
//==========================================================================
//
// CreateDamageFunction
//
// creates a damage function from the given expression
//
//==========================================================================
- implemented version checks for compile-time type determination and for class inheritance. Note that in this system, DECORATE counts as version 2.0, so any data that should be available to DECORATE should not use version restriction.
2017-03-05 16:58:55 +00:00
void CreateDamageFunction(PNamespace *OutNamespace, const VersionInfo &ver, PClassActor *info, AActor *defaults, FxExpression *id, bool fromDecorate, int lumpnum)
- removed the FxDamageValue hack and implemented it properly using FxReturnStatement. - added handling of damage functions for ZScript.
2016-10-26 12:04:49 +00:00
{
if (id == nullptr)
{
defaults->DamageFunc = nullptr;
}
else
{
auto dmg = new FxReturnStatement(new FxIntCast(id, true), id->ScriptPosition);
- separated class descriptors from VM types. Combining these two groups of data has been the cause of many hard to detect errors because it allowed liberal casting between types that are used for completely different things.
2017-04-12 20:46:49 +00:00
auto funcsym = CreateAnonymousFunction(info->VMType, TypeSInt32, 0);
- implemented version checks for compile-time type determination and for class inheritance. Note that in this system, DECORATE counts as version 2.0, so any data that should be available to DECORATE should not use version restriction.
2017-03-05 16:58:55 +00:00
defaults->DamageFunc = FunctionBuildList.AddFunction(OutNamespace, ver, funcsym, dmg, FStringf("%s.DamageFunction", info->TypeName.GetChars()), fromDecorate, -1, 0, lumpnum);
- removed the FxDamageValue hack and implemented it properly using FxReturnStatement. - added handling of damage functions for ZScript.
2016-10-26 12:04:49 +00:00
}
}
- try to preserve a bit more information about incorrect use of user variables to print more meaningful error messages. This is not complete yet and will need integration with the previous commit.
2016-11-13 11:02:41 +00:00
//==========================================================================
//
// CheckForUnsafeStates
//
// Performs a quick analysis to find potentially bad states.
// This is not perfect because it cannot track jumps by function.
// For such cases a runtime check in the relevant places is also present.
//
//==========================================================================
- added compile time checks for bad state links and state label references. - preserve a state's source line information for the postprocessing phase so that the checker can output more useful information. - added missing check for weapon psprites to DPSprite::SetState.
2016-11-15 10:21:08 +00:00
static void CheckForUnsafeStates(PClassActor *obj)
- try to preserve a bit more information about incorrect use of user variables to print more meaningful error messages. This is not complete yet and will need integration with the previous commit.
2016-11-13 11:02:41 +00:00
{
static ENamedName weaponstates[] = { NAME_Ready, NAME_Deselect, NAME_Select, NAME_Fire, NAME_AltFire, NAME_Hold, NAME_AltHold, NAME_Flash, NAME_AltFlash, NAME_None };
static ENamedName pickupstates[] = { NAME_Pickup, NAME_Drop, NAME_Use, NAME_None };
TMap<FState *, bool> checked;
ENamedName *test;
- removed all remaining native components of the weapon class.
2018-11-25 09:00:55 +00:00
auto cwtype = PClass::FindActor(NAME_Weapon);
if (obj->IsDescendantOf(cwtype))
- try to preserve a bit more information about incorrect use of user variables to print more meaningful error messages. This is not complete yet and will need integration with the previous commit.
2016-11-13 11:02:41 +00:00
{
- removed all remaining native components of the weapon class.
2018-11-25 09:00:55 +00:00
if (obj->Size == cwtype->Size) return; // This class cannot have user variables.
- try to preserve a bit more information about incorrect use of user variables to print more meaningful error messages. This is not complete yet and will need integration with the previous commit.
2016-11-13 11:02:41 +00:00
test = weaponstates;
}
- partial scriptification of AInventory. - scriptification of CustomInventory.
2017-01-19 18:14:22 +00:00
else
- try to preserve a bit more information about incorrect use of user variables to print more meaningful error messages. This is not complete yet and will need integration with the previous commit.
2016-11-13 11:02:41 +00:00
{
- partial scriptification of AInventory. - scriptification of CustomInventory.
2017-01-19 18:14:22 +00:00
auto citype = PClass::FindActor(NAME_CustomInventory);
if (obj->IsDescendantOf(citype))
{
if (obj->Size == citype->Size) return; // This class cannot have user variables.
test = pickupstates;
}
- removed AStateProvider from native code. The only place still referencing it was CallStateChain, so this has been made a static function now instead of a class method.
2018-11-25 09:09:06 +00:00
else return; // something else derived from StateProvider. We do not know what this may be.
- try to preserve a bit more information about incorrect use of user variables to print more meaningful error messages. This is not complete yet and will need integration with the previous commit.
2016-11-13 11:02:41 +00:00
}
for (; *test != NAME_None; test++)
{
FState *state = obj->FindState(*test);
while (state != nullptr && checked.CheckKey(state) == nullptr) // have we checked this state already. If yes, we can stop checking the current chain.
{
checked[state] = true;
if (state->ActionFunc && state->ActionFunc->Unsafe)
{
// If an unsafe function (i.e. one that accesses user variables) is being detected, print a warning once and remove the bogus function. We may not call it because that would inevitably crash.
- fixed redundant reallocation of constructable meta fields. - some optimization of access to OwnedStates in old DECORATE. - consolidate all places that print a state name into a subfunction. - allocate states from the ClassDataAllocator memory arena. States do not need to be freed separately from the rest of the static class data.
2017-04-11 19:48:41 +00:00
GetStateSource(state).Message(MSG_ERROR, TEXTCOLOR_RED "Unsafe state call in state %s which accesses user variables, reached by %s.%s.\n",
Fixed build with Clang Fixed bunch of compilation errors: cannot pass non-trivial object of type 'FString' to variadic method; expected type from format string was 'char *' [-Wnon-pod-varargs] Fixed linker erorr: g_doomedmap.cpp.o: In function `InitActorNumsFromMapinfo()': src/g_doomedmap.cpp: undefined reference to `PClass::FindActor(FName)'
2017-04-13 07:17:11 +00:00
FState::StaticGetStateName(state).GetChars(), obj->TypeName.GetChars(), FName(*test).GetChars());
- try to preserve a bit more information about incorrect use of user variables to print more meaningful error messages. This is not complete yet and will need integration with the previous commit.
2016-11-13 11:02:41 +00:00
}
state = state->NextState;
}
}
- added compile time checks for bad state links and state label references. - preserve a state's source line information for the postprocessing phase so that the checker can output more useful information. - added missing check for weapon psprites to DPSprite::SetState.
2016-11-15 10:21:08 +00:00
}
//==========================================================================
//
// CheckStates
//
// Checks if states link to ones with proper restrictions
// Checks that all base labels refer a string with proper restrictions.
// For these cases a runtime check in the relevant places is also present.
//
//==========================================================================
static void CheckLabel(PClassActor *obj, FStateLabel *slb, int useflag, FName statename, const char *descript)
{
auto state = slb->State;
if (state != nullptr)
{
if (!(state->UseFlags & useflag))
{
- fixed redundant reallocation of constructable meta fields. - some optimization of access to OwnedStates in old DECORATE. - consolidate all places that print a state name into a subfunction. - allocate states from the ClassDataAllocator memory arena. States do not need to be freed separately from the rest of the static class data.
2017-04-11 19:48:41 +00:00
GetStateSource(state).Message(MSG_ERROR, TEXTCOLOR_RED "%s references state %s as %s state, but this state is not flagged for use as %s.\n",
Fixed build with Clang Fixed bunch of compilation errors: cannot pass non-trivial object of type 'FString' to variadic method; expected type from format string was 'char *' [-Wnon-pod-varargs] Fixed linker erorr: g_doomedmap.cpp.o: In function `InitActorNumsFromMapinfo()': src/g_doomedmap.cpp: undefined reference to `PClass::FindActor(FName)'
2017-04-13 07:17:11 +00:00
obj->TypeName.GetChars(), FState::StaticGetStateName(state).GetChars(), statename.GetChars(), descript);
- added compile time checks for bad state links and state label references. - preserve a state's source line information for the postprocessing phase so that the checker can output more useful information. - added missing check for weapon psprites to DPSprite::SetState.
2016-11-15 10:21:08 +00:00
}
}
if (slb->Children != nullptr)
{
for (int i = 0; i < slb->Children->NumLabels; i++)
{
auto state = slb->Children->Labels[i].State;
CheckLabel(obj, &slb->Children->Labels[i], useflag, statename, descript);
}
}
}
static void CheckStateLabels(PClassActor *obj, ENamedName *test, int useflag, const char *descript)
{
- moved all remaining fields from PClassActor to FActorInfo. - added a few access functions for FActorInfo variables. With PClassActor now empty the class descriptors can finally be converted back to static data outside the class hierarchy, like they were before the scripting merge, and untangle the game data from VM internals.
2017-04-11 22:07:41 +00:00
FStateLabels *labels = obj->GetStateLabels();
- added compile time checks for bad state links and state label references. - preserve a state's source line information for the postprocessing phase so that the checker can output more useful information. - added missing check for weapon psprites to DPSprite::SetState.
2016-11-15 10:21:08 +00:00
for (; *test != NAME_None; test++)
{
auto label = labels->FindLabel(*test);
if (label != nullptr)
{
CheckLabel(obj, label, useflag, *test, descript);
}
}
}
static void CheckStates(PClassActor *obj)
{
static ENamedName actorstates[] = { NAME_Spawn, NAME_See, NAME_Melee, NAME_Missile, NAME_Pain, NAME_Death, NAME_Wound, NAME_Raise, NAME_Yes, NAME_No, NAME_Greetings, NAME_None };
static ENamedName weaponstates[] = { NAME_Ready, NAME_Deselect, NAME_Select, NAME_Fire, NAME_AltFire, NAME_Hold, NAME_AltHold, NAME_Flash, NAME_AltFlash, NAME_None };
static ENamedName pickupstates[] = { NAME_Pickup, NAME_Drop, NAME_Use, NAME_None };
TMap<FState *, bool> checked;
CheckStateLabels(obj, actorstates, SUF_ACTOR, "actor sprites");
- optimized the FName versions of IsDescendantOf and IsKindOf. These can be done without first looking up the class type itself.
2017-02-08 14:47:22 +00:00
if (obj->IsDescendantOf(NAME_Weapon))
- added compile time checks for bad state links and state label references. - preserve a state's source line information for the postprocessing phase so that the checker can output more useful information. - added missing check for weapon psprites to DPSprite::SetState.
2016-11-15 10:21:08 +00:00
{
CheckStateLabels(obj, weaponstates, SUF_WEAPON, "weapon sprites");
}
- optimized the FName versions of IsDescendantOf and IsKindOf. These can be done without first looking up the class type itself.
2017-02-08 14:47:22 +00:00
else if (obj->IsDescendantOf(NAME_CustomInventory))
- added compile time checks for bad state links and state label references. - preserve a state's source line information for the postprocessing phase so that the checker can output more useful information. - added missing check for weapon psprites to DPSprite::SetState.
2016-11-15 10:21:08 +00:00
{
CheckStateLabels(obj, pickupstates, SUF_ITEM, "CustomInventory state chain");
}
- moved all remaining fields from PClassActor to FActorInfo. - added a few access functions for FActorInfo variables. With PClassActor now empty the class descriptors can finally be converted back to static data outside the class hierarchy, like they were before the scripting merge, and untangle the game data from VM internals.
2017-04-11 22:07:41 +00:00
for (unsigned i = 0; i < obj->GetStateCount(); i++)
- added compile time checks for bad state links and state label references. - preserve a state's source line information for the postprocessing phase so that the checker can output more useful information. - added missing check for weapon psprites to DPSprite::SetState.
2016-11-15 10:21:08 +00:00
{
- moved all remaining fields from PClassActor to FActorInfo. - added a few access functions for FActorInfo variables. With PClassActor now empty the class descriptors can finally be converted back to static data outside the class hierarchy, like they were before the scripting merge, and untangle the game data from VM internals.
2017-04-11 22:07:41 +00:00
auto state = obj->GetStates() + i;
- added compile time checks for bad state links and state label references. - preserve a state's source line information for the postprocessing phase so that the checker can output more useful information. - added missing check for weapon psprites to DPSprite::SetState.
2016-11-15 10:21:08 +00:00
if (state->NextState && (state->UseFlags & state->NextState->UseFlags) != state->UseFlags)
{
- moved OwnedStates and NumOwnedStates out of PClassActor.
2017-04-11 20:44:35 +00:00
GetStateSource(state).Message(MSG_ERROR, TEXTCOLOR_RED "State %s links to a state with incompatible restrictions.\n",
Fixed build with Clang Fixed bunch of compilation errors: cannot pass non-trivial object of type 'FString' to variadic method; expected type from format string was 'char *' [-Wnon-pod-varargs] Fixed linker erorr: g_doomedmap.cpp.o: In function `InitActorNumsFromMapinfo()': src/g_doomedmap.cpp: undefined reference to `PClass::FindActor(FName)'
2017-04-13 07:17:11 +00:00
FState::StaticGetStateName(state).GetChars());
- added compile time checks for bad state links and state label references. - preserve a state's source line information for the postprocessing phase so that the checker can output more useful information. - added missing check for weapon psprites to DPSprite::SetState.
2016-11-15 10:21:08 +00:00
}
}
- try to preserve a bit more information about incorrect use of user variables to print more meaningful error messages. This is not complete yet and will need integration with the previous commit.
2016-11-13 11:02:41 +00:00
}
- added validation for presence of drop item classes https://forum.zdoom.org/viewtopic.php?t=65307
2019-07-11 08:07:09 +00:00
void CheckDropItems(const PClassActor *const obj)
{
const FDropItem *dropItem = obj->ActorInfo()->DropItems;
while (dropItem != nullptr)
{
if (dropItem->Name != NAME_None)
{
const char *const dropItemName = dropItem->Name.GetChars();
if (dropItemName[0] != '\0' && PClass::FindClass(dropItem->Name) == nullptr)
{
Printf(TEXTCOLOR_ORANGE "Undefined drop item class %s referenced from actor %s\n", dropItemName, obj->TypeName.GetChars());
FScriptPosition::WarnCounter++;
}
}
dropItem = dropItem->Next;
}
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// LoadActors
//
// Called from FActor::StaticInit()
//
//==========================================================================
- started to make ZScript parser work on real-life data. It will now read a lump named ZSCRIPT which is a list of filenames to be compiled. - place generated symbols into GlobalSymbols instead of a scratch table that will be discarded right away. - allow the state object to change source file scanners (I hope this works, but the old implementation was unable to do more than one with with a parse state so I had to change it.) - It can now parse constants.txt and insert everything in it into the global symbol table and make subsequent DECORATE compile properly.
2016-10-07 23:05:27 +00:00
void ParseScripts();
- separated the code generation from the DECORATE parser and cleaned up the interface to the code generator. Most importantly, the VMScriptFunctions are now preallocated when being added to the list of functions to compile and will be filled in later by the code generator. This allowed the removal of some ugly maintenance code.
2016-10-12 22:53:59 +00:00
void ParseAllDecorate();
- separated class descriptors from VM types. Combining these two groups of data has been the cause of many hard to detect errors because it allowed liberal casting between types that are used for completely different things.
2017-04-12 20:46:49 +00:00
void SynthesizeFlagFields();
Normalize line endings
2016-03-01 15:47:10 +00:00
- removed an assert from APowerMorph::EndEffect. With some recent changes to DestroyAllInventory it appears that the asserted condition no longer is true at this point when ending a game. - fixed: When replacing a tentative class, the pointers in the morph objects were not replaced. Instead of adding more ReplaceClassRef methods I chose to integrate this part into the PointerSubstitution mechanism and delete ReplaceClassRef entirely. The code had some oversights anyway that would have caused problems, now that non-actors can be created.
2016-11-30 23:05:23 +00:00
void LoadActors()
Normalize line endings
2016-03-01 15:47:10 +00:00
{
cycle_t timer;
timer.Reset(); timer.Clock();
- separated the code generation from the DECORATE parser and cleaned up the interface to the code generator. Most importantly, the VMScriptFunctions are now preallocated when being added to the list of functions to compile and will be filled in later by the code generator. This allowed the removal of some ugly maintenance code.
2016-10-12 22:53:59 +00:00
FScriptPosition::ResetErrorCounter();
Normalize line endings
2016-03-01 15:47:10 +00:00
InitThingdef();
- fixed: Deprecation messages should never appear in DECORATE. - removed some console message spam.
2016-10-26 11:22:36 +00:00
FScriptPosition::StrictErrors = true;
- started to make ZScript parser work on real-life data. It will now read a lump named ZSCRIPT which is a list of filenames to be compiled. - place generated symbols into GlobalSymbols instead of a scratch table that will be discarded right away. - allow the state object to change source file scanners (I hope this works, but the old implementation was unable to do more than one with with a parse state so I had to change it.) - It can now parse constants.txt and insert everything in it into the global symbol table and make subsequent DECORATE compile properly.
2016-10-07 23:05:27 +00:00
ParseScripts();
- count errors in the parser and abort afterward if there were some. - use FScriptPosition's error counter throughout the compiler so that there is only one counter for everything, not two. Parts of the compiler use FScriptPosition, so this is easier to handle than having a separate counter in the compiler class. It also avoids having to pass the compiler object to any function where an error may be output. The TreeNodes contain sufficient data to be converted to an FScriptPosition and using that for error message formatting.
2016-10-15 10:15:25 +00:00
- fixed: Deprecation messages should never appear in DECORATE. - removed some console message spam.
2016-10-26 11:22:36 +00:00
FScriptPosition::StrictErrors = false;
- separated the code generation from the DECORATE parser and cleaned up the interface to the code generator. Most importantly, the VMScriptFunctions are now preallocated when being added to the list of functions to compile and will be filled in later by the code generator. This allowed the removal of some ugly maintenance code.
2016-10-12 22:53:59 +00:00
ParseAllDecorate();
- separated class descriptors from VM types. Combining these two groups of data has been the cause of many hard to detect errors because it allowed liberal casting between types that are used for completely different things.
2017-04-12 20:46:49 +00:00
SynthesizeFlagFields();
- separated the code generation from the DECORATE parser and cleaned up the interface to the code generator. Most importantly, the VMScriptFunctions are now preallocated when being added to the list of functions to compile and will be filled in later by the code generator. This allowed the removal of some ugly maintenance code.
2016-10-12 22:53:59 +00:00
FunctionBuildList.Build();
- resorted some of thingdef.cpp's contents into more appropriate files. - split FinishActor into several functions. While DECORATE can, ZSCRIPT cannot do all this in one go. - split the state finalization into several class-specific virtual functions.
2016-10-12 18:42:41 +00:00
Normalize line endings
2016-03-01 15:47:10 +00:00
if (FScriptPosition::ErrorCounter > 0)
{
I_Error("%d errors while parsing DECORATE scripts", FScriptPosition::ErrorCounter);
}
- added compile time checks for bad state links and state label references. - preserve a state's source line information for the postprocessing phase so that the checker can output more useful information. - added missing check for weapon psprites to DPSprite::SetState.
2016-11-15 10:21:08 +00:00
FScriptPosition::ResetErrorCounter();
- separated the code generation from the DECORATE parser and cleaned up the interface to the code generator. Most importantly, the VMScriptFunctions are now preallocated when being added to the list of functions to compile and will be filled in later by the code generator. This allowed the removal of some ugly maintenance code.
2016-10-12 22:53:59 +00:00
- removed an assert from APowerMorph::EndEffect. With some recent changes to DestroyAllInventory it appears that the asserted condition no longer is true at this point when ending a game. - fixed: When replacing a tentative class, the pointers in the morph objects were not replaced. Instead of adding more ReplaceClassRef methods I chose to integrate this part into the PointerSubstitution mechanism and delete ReplaceClassRef entirely. The code had some oversights anyway that would have caused problems, now that non-actors can be created.
2016-11-30 23:05:23 +00:00
for (int i = PClassActor::AllActorClasses.Size() - 1; i >= 0; i--)
- separated the code generation from the DECORATE parser and cleaned up the interface to the code generator. Most importantly, the VMScriptFunctions are now preallocated when being added to the list of functions to compile and will be filled in later by the code generator. This allowed the removal of some ugly maintenance code.
2016-10-12 22:53:59 +00:00
{
- fixed: When a bogus class is deleted from AllActorClasses, the entry should also be removed from the array instead of leaving a null pointer behind.
2016-11-30 18:48:52 +00:00
auto ti = PClassActor::AllActorClasses[i];
- separated the code generation from the DECORATE parser and cleaned up the interface to the code generator. Most importantly, the VMScriptFunctions are now preallocated when being added to the list of functions to compile and will be filled in later by the code generator. This allowed the removal of some ugly maintenance code.
2016-10-12 22:53:59 +00:00
if (ti->Size == TentativeClass)
{
- separated class descriptors from VM types. Combining these two groups of data has been the cause of many hard to detect errors because it allowed liberal casting between types that are used for completely different things.
2017-04-12 20:46:49 +00:00
if (ti->bOptional)
- fixed: The morph actors stored their required classes as names, not as class pointers. This prevented any kind of error check on them. Unfortunately, due to backwards compatibility needs, on DECORATE the missing class may not be fatal so a workaround had to be added to clear those bogus pointers later if they are discovered to be broken. For ZScript, though, this will result in a compile error, which was the intention behind this change.
2016-11-23 21:34:17 +00:00
{
Printf(TEXTCOLOR_ORANGE "Class %s referenced but not defined\n", ti->TypeName.GetChars());
FScriptPosition::WarnCounter++;
- restored ZDoom 2.8.1's version of FindClassTentative which just modified the existing class instead of replacing it and having to run a costly and volatile PointerSubstitution call to replace all pointers to the old one.
2017-02-08 18:52:33 +00:00
// the class must be rendered harmless so that it won't cause problems.
ti->ParentClass = RUNTIME_CLASS(AActor);
ti->Size = sizeof(AActor);
- fixed: The morph actors stored their required classes as names, not as class pointers. This prevented any kind of error check on them. Unfortunately, due to backwards compatibility needs, on DECORATE the missing class may not be fatal so a workaround had to be added to clear those bogus pointers later if they are discovered to be broken. For ZScript, though, this will result in a compile error, which was the intention behind this change.
2016-11-23 21:34:17 +00:00
}
else
{
Printf(TEXTCOLOR_RED "Class %s referenced but not defined\n", ti->TypeName.GetChars());
FScriptPosition::ErrorCounter++;
}
- separated the code generation from the DECORATE parser and cleaned up the interface to the code generator. Most importantly, the VMScriptFunctions are now preallocated when being added to the list of functions to compile and will be filled in later by the code generator. This allowed the removal of some ugly maintenance code.
2016-10-12 22:53:59 +00:00
continue;
}
if (GetDefaultByType(ti) == nullptr)
{
Printf(TEXTCOLOR_RED "No ActorInfo defined for class '%s'\n", ti->TypeName.GetChars());
- added compile time checks for bad state links and state label references. - preserve a state's source line information for the postprocessing phase so that the checker can output more useful information. - added missing check for weapon psprites to DPSprite::SetState.
2016-11-15 10:21:08 +00:00
FScriptPosition::ErrorCounter++;
- separated the code generation from the DECORATE parser and cleaned up the interface to the code generator. Most importantly, the VMScriptFunctions are now preallocated when being added to the list of functions to compile and will be filled in later by the code generator. This allowed the removal of some ugly maintenance code.
2016-10-12 22:53:59 +00:00
continue;
}
- try to preserve a bit more information about incorrect use of user variables to print more meaningful error messages. This is not complete yet and will need integration with the previous commit.
2016-11-13 11:02:41 +00:00
- added compile time checks for bad state links and state label references. - preserve a state's source line information for the postprocessing phase so that the checker can output more useful information. - added missing check for weapon psprites to DPSprite::SetState.
2016-11-15 10:21:08 +00:00
CheckStates(ti);
- removed an assert from APowerMorph::EndEffect. With some recent changes to DestroyAllInventory it appears that the asserted condition no longer is true at this point when ending a game. - fixed: When replacing a tentative class, the pointers in the morph objects were not replaced. Instead of adding more ReplaceClassRef methods I chose to integrate this part into the PointerSubstitution mechanism and delete ReplaceClassRef entirely. The code had some oversights anyway that would have caused problems, now that non-actors can be created.
2016-11-30 23:05:23 +00:00
- removed AStateProvider from native code. The only place still referencing it was CallStateChain, so this has been made a static function now instead of a class method.
2018-11-25 09:09:06 +00:00
if (ti->bDecorateClass && ti->IsDescendantOf(NAME_StateProvider))
- try to preserve a bit more information about incorrect use of user variables to print more meaningful error messages. This is not complete yet and will need integration with the previous commit.
2016-11-13 11:02:41 +00:00
{
// either a DECORATE based weapon or CustomInventory.
// These are subject to relaxed rules for user variables in states.
// Although there is a runtime check for bogus states, let's do a quick analysis if any of the known entry points
// hits an unsafe state. If we can find something here it can be handled wuth a compile error rather than a runtime error.
- added compile time checks for bad state links and state label references. - preserve a state's source line information for the postprocessing phase so that the checker can output more useful information. - added missing check for weapon psprites to DPSprite::SetState.
2016-11-15 10:21:08 +00:00
CheckForUnsafeStates(ti);
- try to preserve a bit more information about incorrect use of user variables to print more meaningful error messages. This is not complete yet and will need integration with the previous commit.
2016-11-13 11:02:41 +00:00
}
- removed an assert from APowerMorph::EndEffect. With some recent changes to DestroyAllInventory it appears that the asserted condition no longer is true at this point when ending a game. - fixed: When replacing a tentative class, the pointers in the morph objects were not replaced. Instead of adding more ReplaceClassRef methods I chose to integrate this part into the PointerSubstitution mechanism and delete ReplaceClassRef entirely. The code had some oversights anyway that would have caused problems, now that non-actors can be created.
2016-11-30 23:05:23 +00:00
- fixed: All missiles which can bounce off actors need the CANPASS/PASSMOBJ flag so setting this in the 'bouncetype' property is insufficient, it needs to be done when the actor has been completely parsed.
2016-12-26 23:32:54 +00:00
// ensure that all actor bouncers have PASSMOBJ set.
auto defaults = GetDefaultByType(ti);
if (defaults->BounceFlags & (BOUNCE_Actors | BOUNCE_AllActors))
{
// PASSMOBJ is irrelevant for normal missiles, but not for bouncers.
defaults->flags2 |= MF2_PASSMOBJ;
}
- added validation for presence of drop item classes https://forum.zdoom.org/viewtopic.php?t=65307
2019-07-11 08:07:09 +00:00
CheckDropItems(ti);
- separated the code generation from the DECORATE parser and cleaned up the interface to the code generator. Most importantly, the VMScriptFunctions are now preallocated when being added to the list of functions to compile and will be filled in later by the code generator. This allowed the removal of some ugly maintenance code.
2016-10-12 22:53:59 +00:00
}
- added compile time checks for bad state links and state label references. - preserve a state's source line information for the postprocessing phase so that the checker can output more useful information. - added missing check for weapon psprites to DPSprite::SetState.
2016-11-15 10:21:08 +00:00
if (FScriptPosition::ErrorCounter > 0)
- separated the code generation from the DECORATE parser and cleaned up the interface to the code generator. Most importantly, the VMScriptFunctions are now preallocated when being added to the list of functions to compile and will be filled in later by the code generator. This allowed the removal of some ugly maintenance code.
2016-10-12 22:53:59 +00:00
{
- added compile time checks for bad state links and state label references. - preserve a state's source line information for the postprocessing phase so that the checker can output more useful information. - added missing check for weapon psprites to DPSprite::SetState.
2016-11-15 10:21:08 +00:00
I_Error("%d errors during actor postprocessing", FScriptPosition::ErrorCounter);
- separated the code generation from the DECORATE parser and cleaned up the interface to the code generator. Most importantly, the VMScriptFunctions are now preallocated when being added to the list of functions to compile and will be filled in later by the code generator. This allowed the removal of some ugly maintenance code.
2016-10-12 22:53:59 +00:00
}
Normalize line endings
2016-03-01 15:47:10 +00:00
timer.Unclock();
- added compile time checks for bad state links and state label references. - preserve a state's source line information for the postprocessing phase so that the checker can output more useful information. - added missing check for weapon psprites to DPSprite::SetState.
2016-11-15 10:21:08 +00:00
if (!batchrun) Printf("script parsing took %.2f ms\n", timer.TimeMS());
- resorted some of thingdef.cpp's contents into more appropriate files. - split FinishActor into several functions. While DECORATE can, ZSCRIPT cannot do all this in one go. - split the state finalization into several class-specific virtual functions.
2016-10-12 18:42:41 +00:00
- scriptified the sector actions.
2017-01-13 12:51:47 +00:00
// Now we may call the scripted OnDestroy method.
PClass::bVMOperational = true;
- added compile time checks for bad state links and state label references. - preserve a state's source line information for the postprocessing phase so that the checker can output more useful information. - added missing check for weapon psprites to DPSprite::SetState.
2016-11-15 10:21:08 +00:00
StateSourceLines.Clear();
Normalize line endings
2016-03-01 15:47:10 +00:00
}
Reference in a new issue Copy permalink