zdoom/gzdoom-gles
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom-gles.git synced 2024-11-17 01:51:17 +00:00
Code Issues Projects Releases Packages Wiki Activity
gzdoom-gles/src/dobjtype.h

809 lines
25 KiB
C
Raw Normal View History

Normalize line endings
2016-03-01 15:47:10 +00:00
#ifndef DOBJTYPE_H
#define DOBJTYPE_H
#ifndef __DOBJECT_H__
#error You must #include "dobject.h" to get dobjtype.h
#endif
Added code to initialize and destroy string variables in classes - Will require being able to add strings to non-native classes to actually test this.
2016-04-03 22:45:04 +00:00
typedef std::pair<const class PType *, unsigned> FTypeAndOffset;
- major work on dynamic array support. Mostly working, some issues still exist with Move and Copy methods and with assignments in stack variables.
2017-02-06 20:39:21 +00:00
class PStruct;
Added code to initialize and destroy string variables in classes - Will require being able to add strings to non-native classes to actually test this.
2016-04-03 22:45:04 +00:00
- did a bit of header cleanup to reduce the dependency on dobject.h.
2017-03-09 22:30:42 +00:00
// This is intentionally not in vm.h so that this file remains free of DObject pollution.
class VMException : public DObject
{
DECLARE_CLASS(VMException, DObject);
};
- reverted most of the last commit after realizing that trying to manage constructing/destructing per variable is not going to work because it'd require some extensive exception management in the compiled VM code. - instead add a list of SpecialInits to VMScriptFunction so this can be done transparently when setting up and popping the stack frame. The only drawback is that this requires permanent allocation of stack objects for the entire lifetime of a function but this is a relatively small tradeoff for significantly reduced maintenance work throughout. - removed most #include "vm.h", because nearly all files already pull this in through dobject.h.
2016-11-17 12:10:19 +00:00
#include "vm.h"
Normalize line endings
2016-03-01 15:47:10 +00:00
// Variable/parameter/field flags -------------------------------------------
// Making all these different storage types use a common set of flags seems
// like the simplest thing to do.
- parse the list of class/struct fields and add the PField entries to their type. - fixed a few issues with trying to access a class's Type before it got initialized.
2016-10-09 13:47:31 +00:00
enum
{
VARF_Optional = (1<<0), // func param is optional
VARF_Method = (1<<1), // func has an implied self parameter
VARF_Action = (1<<2), // func has implied owner and state parameters
- allow defining native fields through scripts. Internally this only requires exporting the address, but not the entire field. - added new VARF_Transient flag so that the decision whether to serialize a field does not depend solely on its native status. It may actually make a lot of sense to use the auto-serializer for native fields, too, as this would eliminate a lot of maintenance code. - defined (u)int8/16 as aliases to the byte and short types (Can't we not just get rid of this naming convention already...?) - exporting the fields of Actor revealed a few name clashes between them and some global types, so Actor.Sector was renamed to CurSector and Actor.Inventory was renamed to Actor.Inv.
2016-11-22 18:20:31 +00:00
VARF_Native = (1<<3), // func is native code, field is natively defined
- parse the list of class/struct fields and add the PField entries to their type. - fixed a few issues with trying to access a class's Type before it got initialized.
2016-10-09 13:47:31 +00:00
VARF_ReadOnly = (1<<4), // field is read only, do not write to it
VARF_Private = (1<<5), // field is private to containing class
VARF_Protected = (1<<6), // field is only accessible by containing class and children.
VARF_Deprecated = (1<<7), // Deprecated fields should output warnings when used.
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
VARF_Virtual = (1<<8), // function is virtual
VARF_Final = (1<<9), // Function may not be overridden in subclasses
VARF_In = (1<<10),
VARF_Out = (1<<11),
- 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
VARF_Implicit = (1<<12), // implicitly created parameters (i.e. do not compare types when checking function signatures)
- added property definitions to the ZScript parser. This will allow defining custom properties for the default block in custom base classes. See 'Health' for an example. - support transient object member variables for information that does not need to be put in a savegame. - fixed: special initialization of objects needs to pass the proper defaults along, otherwise the parent classes will use their own, inappropriate one.
2017-01-15 15:55:30 +00:00
VARF_Static = (1<<13),
- added a new variable flag that allows defining variables which can only be modified by internal script code but not by external mods. Currently this is used by the NoBlockmap and NoSector flags which need special handling for changing.
2016-11-08 10:12:56 +00:00
VARF_InternalAccess = (1<<14), // overrides VARF_ReadOnly for internal script code.
- implemented handling for virtual function. Syntax-wise I chose to make it as strict as possible to reduce the chance of errors: Virtual base functions must be declared with the 'virtual' keyword, and overrides in child classes with the 'override' keyword. This way any mismatch in parameters that otherwise would cause silent failure will outright produce a compile error.
2016-11-11 19:05:07 +00:00
VARF_Override = (1<<15), // overrides a virtual function from the parent class.
- 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
VARF_Ref = (1<<16), // argument is passed by reference.
- added property definitions to the ZScript parser. This will allow defining custom properties for the default block in custom base classes. See 'Health' for an example. - support transient object member variables for information that does not need to be put in a savegame. - fixed: special initialization of objects needs to pass the proper defaults along, otherwise the parent classes will use their own, inappropriate one.
2017-01-15 15:55:30 +00:00
VARF_Transient = (1<<17), // don't auto serialize field.
VARF_Meta = (1<<18), // static class data (by necessity read only.)
Implemented static methods in String struct. Implemented String.Format and String.AppendFormat. Implemented native vararg methods for the future.
2017-01-21 00:07:44 +00:00
VARF_VarArg = (1<<19), // [ZZ] vararg: don't typecheck values after ... in function signature
Added parsing of ui, play, allowui and const qualifiers
2017-02-17 15:58:16 +00:00
VARF_UI = (1<<20), // [ZZ] ui: object is ui-scope only (can't modify playsim)
VARF_Play = (1<<21), // [ZZ] play: object is playsim-scope only (can't access ui)
Static virtualscope checking. This is possible, because virtualscope can't produce false positives (data readable for everyone), only false negatives (which are handled at runtime later)
2017-02-18 02:07:12 +00:00
VARF_VirtualScope = (1<<22), // [ZZ] virtualscope: object should use the scope of the particular class it's being used with (methods only)
Fixed: clearscope should also clear the inherited scope (through struct member access chain); Fixed: struct member access chain should ONLY work for structs (forgot that FxClassMember inherits FxStructMember)
2017-03-03 22:04:19 +00:00
VARF_ClearScope = (1<<23), // [ZZ] clearscope: this method ignores the member access chain that leads to it and is always plain data.
- parse the list of class/struct fields and add the PField entries to their type. - fixed a few issues with trying to access a class's Type before it got initialized.
2016-10-09 13:47:31 +00:00
};
Normalize line endings
2016-03-01 15:47:10 +00:00
// An action function -------------------------------------------------------
struct FState;
struct StateCallData;
class VMFrameStack;
struct VMValue;
struct VMReturn;
class VMFunction;
- delete all compile-time symbols for scripting after finishing compiling data. Even the bare-bones gzdoom.pk3 gets rid of over 2000 symbols this way that otherwise would need to be tracked by the garbage collector.
2017-01-24 10:57:42 +00:00
struct FNamespaceManager;
Normalize line endings
2016-03-01 15:47:10 +00:00
// Basic information shared by all types ------------------------------------
// Only one copy of a type is ever instantiated at one time.
// - Enums, classes, and structs are defined by their names and outer classes.
// - Pointers are uniquely defined by the type they point at.
// - ClassPointers are also defined by their class restriction.
// - Arrays are defined by their element type and count.
// - DynArrays are defined by their element type.
// - Maps are defined by their key and value types.
// - Prototypes are defined by the argument and return types.
// - Functions are defined by their names and outer objects.
// In table form:
// Outer Name Type Type2 Count
// Enum * *
// Class * *
// Struct * *
// Function * *
// Pointer *
// ClassPointer + *
// Array * *
// DynArray *
// Map * *
// Prototype *+ *+
struct ZCC_ExprConstant;
- do not declare PNamedType::Outer as DObject. Ultimately we may have to get a fully qualified name out of this, so Outer should be a type that can handle this feature. The new class for this is currently used as base for PType and PSymbol so that PNamedType inherits from it and maybe later a namespace symbol can, too.
2016-10-07 11:59:29 +00:00
class PType : public PTypeBase
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- do not declare PNamedType::Outer as DObject. Ultimately we may have to get a fully qualified name out of this, so Outer should be a type that can handle this feature. The new class for this is currently used as base for PType and PSymbol so that PNamedType inherits from it and maybe later a namespace symbol can, too.
2016-10-07 11:59:29 +00:00
DECLARE_ABSTRACT_CLASS(PType, PTypeBase)
Normalize line endings
2016-03-01 15:47:10 +00:00
protected:
- changed GetStore/LoadMoveOp and GetRegType to be based on a set of member variables instead of using virtual functions to return such trivial values. This not only creates significantly better code but also allows overriding these settings without having to create a new class just for changing them (as is needed for vectors.)
2016-10-28 08:44:01 +00:00
Normalize line endings
2016-03-01 15:47:10 +00:00
public:
- moved the TypeTableType pointer from PClassType to PType. Removing this variable is needed to remove PClassType and PClassClass as the next step to eliminate all of PClass's subclasses in order to clean up the type system.
2017-02-07 19:25:52 +00:00
PClass *TypeTableType; // The type to use for hashing into the type table
Normalize line endings
2016-03-01 15:47:10 +00:00
unsigned int Size; // this type's size
unsigned int Align; // this type's preferred alignment
PType *HashNext; // next type in this type table
PSymbolTable Symbols;
- restrict 8 and 16 bit integer types to struct and class members - and I am not really sure if they should even be allowed there, aside from legacy readonly properties. For 32 bit floats the same would hold, but those are already mapped to 64 bit doubles silently. ZDoom only uses these types in a very few isolated places, and even those can be removed without problems, so it's very doubtful that having support for these types is of any benefit - on the other hand, having them will most likely introduce more code than is saved in the data by using them...
2016-10-16 10:47:26 +00:00
bool MemberOnly = false; // type may only be used as a struct/class member but not as a local variable or function argument.
- changed order of script files to match the old DECORATE list for easy comparison of the disassembly. - added a descriptive name to all types for error messages. - added a generic type cast node to the code generator. - added a few more cast operations to the 'cast' VM instruction. - extended FxClassTypeCast to handle all possible input that can be cast to a class pointer, not just names.
2016-10-16 17:42:22 +00:00
FString mDescriptiveName;
- 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
VersionInfo mVersion = { 0,0,0 };
- the fourth.
2017-03-08 17:47:52 +00:00
uint8_t loadOp, storeOp, moveOp, RegType, RegCount;
Normalize line endings
2016-03-01 15:47:10 +00:00
- changed GetStore/LoadMoveOp and GetRegType to be based on a set of member variables instead of using virtual functions to return such trivial values. This not only creates significantly better code but also allows overriding these settings without having to create a new class just for changing them (as is needed for vectors.)
2016-10-28 08:44:01 +00:00
PType(unsigned int size = 1, unsigned int align = 1);
Normalize line endings
2016-03-01 15:47:10 +00:00
virtual ~PType();
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
virtual bool isNumeric() { return false; }
Normalize line endings
2016-03-01 15:47:10 +00:00
Added methods for PTypes to serialize their values - Values are tagged to allow for some measure of changing variable types without automatically breaking savegames. - Use these new methods to serialize the non-native variables in an object. This allows for achiving non-ints.
2016-04-03 04:10:43 +00:00
// Writes the value of a variable of this type at (addr) to an archive, preceded by
// a tag indicating its type. The tag is there so that variable types can be changed
// without completely breaking savegames, provided that the change isn't between
// totally unrelated types.
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
virtual void WriteValue(FSerializer &ar, const char *key,const void *addr) const;
Added methods for PTypes to serialize their values - Values are tagged to allow for some measure of changing variable types without automatically breaking savegames. - Use these new methods to serialize the non-native variables in an object. This allows for achiving non-ints.
2016-04-03 04:10:43 +00:00
// Returns true if the stored value was compatible. False otherwise.
// If the value was incompatible, then the memory at *addr is unchanged.
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
virtual bool ReadValue(FSerializer &ar, const char *key,void *addr) const;
Added methods for PTypes to serialize their values - Values are tagged to allow for some measure of changing variable types without automatically breaking savegames. - Use these new methods to serialize the non-native variables in an object. This allows for achiving non-ints.
2016-04-03 04:10:43 +00:00
Added code to initialize and destroy string variables in classes - Will require being able to add strings to non-native classes to actually test this.
2016-04-03 22:45:04 +00:00
// Sets the default value for this type at (base + offset)
// If the default value is binary 0, then this function doesn't need
// to do anything, because PClass::Extend() takes care of that.
//
// The stroffs array is so that types that need special initialization
// and destruction (e.g. strings) can add their offsets to it for special
// initialization when the object is created and destruction when the
// object is destroyed.
virtual void SetDefaultValue(void *base, unsigned offset, TArray<FTypeAndOffset> *special=NULL) const;
- fixed: Script defined pointers were not added to the FlatPointers array.
2016-11-17 21:21:08 +00:00
virtual void SetPointer(void *base, unsigned offset, TArray<size_t> *ptrofs = NULL) const;
- implemented the backend for dynamic arrays. Still needs thorough testing but it should be complete. - use a memory arena to store flat pointers so that the messed up cleanup can be avoided by deallocating this in bulk. - added a new SO opcode to the VM to execute a write barrier. This is necessary for all objects that are not linked into one global table, i.e. everything except thinkers and class types. - always use the cheaper LOS opcode for reading pointers to classes and defaults because these cannot be destroyed during normal operation. - removed the pointless validation from String.Mid. If the values are read as unsigned the internal validation of FString::Mid will automatically ensure proper results.
2017-02-07 13:48:27 +00:00
virtual void SetPointerArray(void *base, unsigned offset, TArray<size_t> *ptrofs = NULL) const;
Added code to initialize and destroy string variables in classes - Will require being able to add strings to non-native classes to actually test this.
2016-04-03 22:45:04 +00:00
// Initialize the value, if needed (e.g. strings)
virtual void InitializeValue(void *addr, const void *def) const;
// Destroy the value, if needed (e.g. strings)
virtual void DestroyValue(void *addr) const;
Normalize line endings
2016-03-01 15:47:10 +00:00
// Sets the value of a variable of this type at (addr)
virtual void SetValue(void *addr, int val);
Add double variants of SetValue() for numeric PTypes
2016-03-30 03:05:25 +00:00
virtual void SetValue(void *addr, double val);
Normalize line endings
2016-03-01 15:47:10 +00:00
// Gets the value of a variable of this type at (addr)
virtual int GetValueInt(void *addr) const;
Add GetValueFloat() for numeric PTypes
2016-03-30 03:24:59 +00:00
virtual double GetValueFloat(void *addr) const;
Normalize line endings
2016-03-01 15:47:10 +00:00
// Gets the opcode to store from a register to memory
- changed GetStore/LoadMoveOp and GetRegType to be based on a set of member variables instead of using virtual functions to return such trivial values. This not only creates significantly better code but also allows overriding these settings without having to create a new class just for changing them (as is needed for vectors.)
2016-10-28 08:44:01 +00:00
int GetStoreOp() const
{
return storeOp;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
// Gets the opcode to load from memory to a register
- changed GetStore/LoadMoveOp and GetRegType to be based on a set of member variables instead of using virtual functions to return such trivial values. This not only creates significantly better code but also allows overriding these settings without having to create a new class just for changing them (as is needed for vectors.)
2016-10-28 08:44:01 +00:00
int GetLoadOp() const
{
return loadOp;
}
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
// Gets the opcode to move from register to another register
- changed GetStore/LoadMoveOp and GetRegType to be based on a set of member variables instead of using virtual functions to return such trivial values. This not only creates significantly better code but also allows overriding these settings without having to create a new class just for changing them (as is needed for vectors.)
2016-10-28 08:44:01 +00:00
int GetMoveOp() const
{
return moveOp;
}
- 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
Normalize line endings
2016-03-01 15:47:10 +00:00
// Gets the register type for this type
- changed GetStore/LoadMoveOp and GetRegType to be based on a set of member variables instead of using virtual functions to return such trivial values. This not only creates significantly better code but also allows overriding these settings without having to create a new class just for changing them (as is needed for vectors.)
2016-10-28 08:44:01 +00:00
int GetRegType() const
{
return RegType;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
- fixed setup for PString which was missing the load/store/move instructions which caused me to overlook its register type. - properly set up the vector types. - fixed: a struct must start with a size of 0, not 1. This caused the layout of the vectors to be broken.
2016-10-28 12:43:29 +00:00
int GetRegCount() const
{
return RegCount;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
// Returns true if this type matches the two identifiers. Referring to the
// above table, any type is identified by at most two characteristics. Each
// type that implements this function will cast these to the appropriate type.
// It is up to the caller to make sure they are the correct types. There is
// only one prototype for this function in order to simplify type table
// management.
virtual bool IsMatch(intptr_t id1, intptr_t id2) const;
// Get the type IDs used by IsMatch
virtual void GetTypeIDs(intptr_t &id1, intptr_t &id2) const;
- changed order of script files to match the old DECORATE list for easy comparison of the disassembly. - added a descriptive name to all types for error messages. - added a generic type cast node to the code generator. - added a few more cast operations to the 'cast' VM instruction. - extended FxClassTypeCast to handle all possible input that can be cast to a class pointer, not just names.
2016-10-16 17:42:22 +00:00
const char *DescriptiveName() const;
Normalize line endings
2016-03-01 15:47:10 +00:00
static void StaticInit();
};
// Not-really-a-type types --------------------------------------------------
class PErrorType : public PType
{
DECLARE_CLASS(PErrorType, PType);
public:
- added automatic type deduction capabilities for local variables. If you type 'let variable = value;' the type of 'variable' will be deduced from the given value. This is mostly of interest for type casting pointers, because 'let p = Classtype(objectvar);' does not require writing the class type name twice.
2016-12-05 12:24:42 +00:00
PErrorType(int which = 1) : PType(0, which) {}
Normalize line endings
2016-03-01 15:47:10 +00:00
};
class PVoidType : public PType
{
DECLARE_CLASS(PVoidType, PType);
public:
PVoidType() : PType(0, 1) {}
};
// Some categorization typing -----------------------------------------------
class PBasicType : public PType
{
DECLARE_ABSTRACT_CLASS(PBasicType, PType);
public:
PBasicType();
PBasicType(unsigned int size, unsigned int align);
};
class PCompoundType : public PType
{
DECLARE_ABSTRACT_CLASS(PCompoundType, PType);
};
class PNamedType : public PCompoundType
{
DECLARE_ABSTRACT_CLASS(PNamedType, PCompoundType);
public:
- do not declare PNamedType::Outer as DObject. Ultimately we may have to get a fully qualified name out of this, so Outer should be a type that can handle this feature. The new class for this is currently used as base for PType and PSymbol so that PNamedType inherits from it and maybe later a namespace symbol can, too.
2016-10-07 11:59:29 +00:00
PTypeBase *Outer; // object this type is contained within
Normalize line endings
2016-03-01 15:47:10 +00:00
FName TypeName; // this type's name
- changed order of script files to match the old DECORATE list for easy comparison of the disassembly. - added a descriptive name to all types for error messages. - added a generic type cast node to the code generator. - added a few more cast operations to the 'cast' VM instruction. - extended FxClassTypeCast to handle all possible input that can be cast to a class pointer, not just names.
2016-10-16 17:42:22 +00:00
PNamedType() : Outer(NULL) {
mDescriptiveName = "NamedType";
}
PNamedType(FName name, PTypeBase *outer) : Outer(outer), TypeName(name) {
mDescriptiveName = name.GetChars();
}
Normalize line endings
2016-03-01 15:47:10 +00:00
virtual bool IsMatch(intptr_t id1, intptr_t id2) const;
virtual void GetTypeIDs(intptr_t &id1, intptr_t &id2) const;
};
// Basic types --------------------------------------------------------------
class PInt : public PBasicType
{
DECLARE_CLASS(PInt, PBasicType);
public:
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
PInt(unsigned int size, bool unsign, bool compatible = true);
Normalize line endings
2016-03-01 15:47:10 +00:00
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
void WriteValue(FSerializer &ar, const char *key,const void *addr) const override;
bool ReadValue(FSerializer &ar, const char *key,void *addr) const override;
Added methods for PTypes to serialize their values - Values are tagged to allow for some measure of changing variable types without automatically breaking savegames. - Use these new methods to serialize the non-native variables in an object. This allows for achiving non-ints.
2016-04-03 04:10:43 +00:00
Normalize line endings
2016-03-01 15:47:10 +00:00
virtual void SetValue(void *addr, int val);
Add double variants of SetValue() for numeric PTypes
2016-03-30 03:05:25 +00:00
virtual void SetValue(void *addr, double val);
Normalize line endings
2016-03-01 15:47:10 +00:00
virtual int GetValueInt(void *addr) const;
Add GetValueFloat() for numeric PTypes
2016-03-30 03:24:59 +00:00
virtual double GetValueFloat(void *addr) const;
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
virtual bool isNumeric() override { return IntCompatible; }
Normalize line endings
2016-03-01 15:47:10 +00:00
bool Unsigned;
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
bool IntCompatible;
Normalize line endings
2016-03-01 15:47:10 +00:00
protected:
PInt();
- changed GetStore/LoadMoveOp and GetRegType to be based on a set of member variables instead of using virtual functions to return such trivial values. This not only creates significantly better code but also allows overriding these settings without having to create a new class just for changing them (as is needed for vectors.)
2016-10-28 08:44:01 +00:00
void SetOps();
Normalize line endings
2016-03-01 15:47:10 +00:00
};
class PBool : public PInt
{
DECLARE_CLASS(PBool, PInt);
public:
PBool();
- added Get/SetValue functions to PBool.
2017-03-22 14:44:54 +00:00
virtual void SetValue(void *addr, int val);
virtual void SetValue(void *addr, double val);
virtual int GetValueInt(void *addr) const;
virtual double GetValueFloat(void *addr) const;
Normalize line endings
2016-03-01 15:47:10 +00:00
};
class PFloat : public PBasicType
{
DECLARE_CLASS(PFloat, PBasicType);
public:
PFloat(unsigned int size);
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
void WriteValue(FSerializer &ar, const char *key,const void *addr) const override;
bool ReadValue(FSerializer &ar, const char *key,void *addr) const override;
Added methods for PTypes to serialize their values - Values are tagged to allow for some measure of changing variable types without automatically breaking savegames. - Use these new methods to serialize the non-native variables in an object. This allows for achiving non-ints.
2016-04-03 04:10:43 +00:00
Normalize line endings
2016-03-01 15:47:10 +00:00
virtual void SetValue(void *addr, int val);
Add double variants of SetValue() for numeric PTypes
2016-03-30 03:05:25 +00:00
virtual void SetValue(void *addr, double val);
Normalize line endings
2016-03-01 15:47:10 +00:00
virtual int GetValueInt(void *addr) const;
Add GetValueFloat() for numeric PTypes
2016-03-30 03:24:59 +00:00
virtual double GetValueFloat(void *addr) const;
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
virtual bool isNumeric() override { return true; }
Normalize line endings
2016-03-01 15:47:10 +00:00
protected:
PFloat();
- changed GetStore/LoadMoveOp and GetRegType to be based on a set of member variables instead of using virtual functions to return such trivial values. This not only creates significantly better code but also allows overriding these settings without having to create a new class just for changing them (as is needed for vectors.)
2016-10-28 08:44:01 +00:00
void SetOps();
Normalize line endings
2016-03-01 15:47:10 +00:00
private:
struct SymbolInitF
{
ENamedName Name;
double Value;
};
struct SymbolInitI
{
ENamedName Name;
int Value;
};
void SetSingleSymbols();
void SetDoubleSymbols();
void SetSymbols(const SymbolInitF *syminit, size_t count);
void SetSymbols(const SymbolInitI *syminit, size_t count);
};
class PString : public PBasicType
{
DECLARE_CLASS(PString, PBasicType);
public:
PString();
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
void WriteValue(FSerializer &ar, const char *key,const void *addr) const override;
bool ReadValue(FSerializer &ar, const char *key,void *addr) const override;
Added code to initialize and destroy string variables in classes - Will require being able to add strings to non-native classes to actually test this.
2016-04-03 22:45:04 +00:00
void SetDefaultValue(void *base, unsigned offset, TArray<FTypeAndOffset> *special=NULL) const override;
void InitializeValue(void *addr, const void *def) const override;
void DestroyValue(void *addr) const override;
Normalize line endings
2016-03-01 15:47:10 +00:00
};
// Variations of integer types ----------------------------------------------
class PName : public PInt
{
DECLARE_CLASS(PName, PInt);
public:
PName();
Added methods for PTypes to serialize their values - Values are tagged to allow for some measure of changing variable types without automatically breaking savegames. - Use these new methods to serialize the non-native variables in an object. This allows for achiving non-ints.
2016-04-03 04:10:43 +00:00
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
void WriteValue(FSerializer &ar, const char *key,const void *addr) const override;
bool ReadValue(FSerializer &ar, const char *key,void *addr) const override;
Normalize line endings
2016-03-01 15:47:10 +00:00
};
class PSound : public PInt
{
DECLARE_CLASS(PSound, PInt);
public:
PSound();
Added methods for PTypes to serialize their values - Values are tagged to allow for some measure of changing variable types without automatically breaking savegames. - Use these new methods to serialize the non-native variables in an object. This allows for achiving non-ints.
2016-04-03 04:10:43 +00:00
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
void WriteValue(FSerializer &ar, const char *key,const void *addr) const override;
bool ReadValue(FSerializer &ar, const char *key,void *addr) const override;
Normalize line endings
2016-03-01 15:47:10 +00:00
};
- added two new integral types SpriteID and TextureID, both are needed to allow proper serialization as they require something different to be written out than a regular integer.
2016-11-21 12:45:33 +00:00
class PSpriteID : public PInt
{
DECLARE_CLASS(PSpriteID, PInt);
public:
PSpriteID();
void WriteValue(FSerializer &ar, const char *key, const void *addr) const override;
bool ReadValue(FSerializer &ar, const char *key, void *addr) const override;
};
class PTextureID : public PInt
{
DECLARE_CLASS(PTextureID, PInt);
public:
PTextureID();
void WriteValue(FSerializer &ar, const char *key, const void *addr) const override;
bool ReadValue(FSerializer &ar, const char *key, void *addr) const override;
};
Normalize line endings
2016-03-01 15:47:10 +00:00
class PColor : public PInt
{
DECLARE_CLASS(PColor, PInt);
public:
PColor();
};
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
class PStateLabel : public PInt
{
DECLARE_CLASS(PStateLabel, PInt);
public:
PStateLabel();
};
Normalize line endings
2016-03-01 15:47:10 +00:00
// Pointers -----------------------------------------------------------------
class PPointer : public PBasicType
{
DECLARE_CLASS(PPointer, PBasicType);
- allow hooking custom serializers into PPointer so that serializable types can be handled without having to create new type classes which would be a bit unwieldy thanks to how the type system works.
2017-03-03 19:11:13 +00:00
Normalize line endings
2016-03-01 15:47:10 +00:00
public:
- allow hooking custom serializers into PPointer so that serializable types can be handled without having to create new type classes which would be a bit unwieldy thanks to how the type system works.
2017-03-03 19:11:13 +00:00
typedef void(*WriteHandler)(FSerializer &ar, const char *key, const void *addr);
typedef bool(*ReadHandler)(FSerializer &ar, const char *key, void *addr);
- preparations for null pointer support. - add pointer support to FxAssign.
2016-10-21 17:18:39 +00:00
PPointer();
- added readonly pointers. They need to be defined with 'readonly<classtype>'. These are significantly different from declaring a field readonly in that they do not disallow modification of the variable itself but what it points to. For the actor defaults this is necessary to prevent accidental modification. A readonly pointer is actually a different type than a regular pointer. - fixed code generation for dynamic cast. It was missing the jump instruction after the compare.
2016-11-05 12:51:46 +00:00
PPointer(PType *pointsat, bool isconst = false);
Normalize line endings
2016-03-01 15:47:10 +00:00
PType *PointedType;
- added readonly pointers. They need to be defined with 'readonly<classtype>'. These are significantly different from declaring a field readonly in that they do not disallow modification of the variable itself but what it points to. For the actor defaults this is necessary to prevent accidental modification. A readonly pointer is actually a different type than a regular pointer. - fixed code generation for dynamic cast. It was missing the jump instruction after the compare.
2016-11-05 12:51:46 +00:00
bool IsConst;
Normalize line endings
2016-03-01 15:47:10 +00:00
- allow hooking custom serializers into PPointer so that serializable types can be handled without having to create new type classes which would be a bit unwieldy thanks to how the type system works.
2017-03-03 19:11:13 +00:00
WriteHandler writer = nullptr;
ReadHandler reader = nullptr;
void InstallHandlers(WriteHandler w, ReadHandler r)
{
writer = w;
reader = r;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
virtual bool IsMatch(intptr_t id1, intptr_t id2) const;
virtual void GetTypeIDs(intptr_t &id1, intptr_t &id2) const;
Added methods for PTypes to serialize their values - Values are tagged to allow for some measure of changing variable types without automatically breaking savegames. - Use these new methods to serialize the non-native variables in an object. This allows for achiving non-ints.
2016-04-03 04:10:43 +00:00
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
void WriteValue(FSerializer &ar, const char *key,const void *addr) const override;
bool ReadValue(FSerializer &ar, const char *key,void *addr) const override;
Added methods for PTypes to serialize their values - Values are tagged to allow for some measure of changing variable types without automatically breaking savegames. - Use these new methods to serialize the non-native variables in an object. This allows for achiving non-ints.
2016-04-03 04:10:43 +00:00
Normalize line endings
2016-03-01 15:47:10 +00:00
protected:
- changed GetStore/LoadMoveOp and GetRegType to be based on a set of member variables instead of using virtual functions to return such trivial values. This not only creates significantly better code but also allows overriding these settings without having to create a new class just for changing them (as is needed for vectors.)
2016-10-28 08:44:01 +00:00
void SetOps();
Normalize line endings
2016-03-01 15:47:10 +00:00
};
- made PStatePointer a real pointer pointing to a native struct named 'state', because that's what it really is and what it needs to be if we want to use a state as more than an opaque identifier in the VM
2016-11-21 18:36:14 +00:00
class PStatePointer : public PPointer
{
DECLARE_CLASS(PStatePointer, PPointer);
public:
PStatePointer();
void WriteValue(FSerializer &ar, const char *key, const void *addr) const override;
bool ReadValue(FSerializer &ar, const char *key, void *addr) const override;
};
- split PPointer into PPointer and PObjectPointer. A pointer to an object has quite different semantics so let's do this with proper virtual inheritance. This should allow to simplify a lot of pointer related checks in the compiler.
2017-04-12 08:52:54 +00:00
class PObjectPointer : public PPointer
{
DECLARE_CLASS(PObjectPointer, PPointer);
public:
PObjectPointer(PClass *pointedtype = nullptr, bool isconst = false);
void WriteValue(FSerializer &ar, const char *key, const void *addr) const override;
bool ReadValue(FSerializer &ar, const char *key, void *addr) const override;
void SetPointer(void *base, unsigned offset, TArray<size_t> *special = NULL) const override;
- put PObjectPointer to some use. - fixed: There was no check for compatible class pointers.
2017-04-12 09:40:40 +00:00
PClass *PointedClass() const;
- split PPointer into PPointer and PObjectPointer. A pointer to an object has quite different semantics so let's do this with proper virtual inheritance. This should allow to simplify a lot of pointer related checks in the compiler.
2017-04-12 08:52:54 +00:00
};
Normalize line endings
2016-03-01 15:47:10 +00:00
class PClassPointer : public PPointer
{
DECLARE_CLASS(PClassPointer, PPointer);
public:
- implemented the backend for dynamic arrays. Still needs thorough testing but it should be complete. - use a memory arena to store flat pointers so that the messed up cleanup can be avoided by deallocating this in bulk. - added a new SO opcode to the VM to execute a write barrier. This is necessary for all objects that are not linked into one global table, i.e. everything except thinkers and class types. - always use the cheaper LOS opcode for reading pointers to classes and defaults because these cannot be destroyed during normal operation. - removed the pointless validation from String.Mid. If the values are read as unsigned the internal validation of FString::Mid will automatically ensure proper results.
2017-02-07 13:48:27 +00:00
PClassPointer(class PClass *restrict = nullptr);
Normalize line endings
2016-03-01 15:47:10 +00:00
class PClass *ClassRestriction;
- eliminated the native PowerupGiver class. - scriptified the respawn invulnerability code into a virtual OnRespawn function for PlayerPawn so that custom effects can be implemented.
2017-01-17 23:11:04 +00:00
bool isCompatible(PType *type);
- removed PClass::DeriveData because it is no longer needed. - fixed: IsVisibleToPlayer and optimized it a bit more. - moved SourceLumpName to PClass, so that it can also be used for non-actors (there's a lot of non-Actor classes already.) - separated the serializer for PClassPointer from PPointer. Even though not doable, a pointer to a class type is something entirely different than a class pointer with a restriction so each should handle its own case.
2017-04-12 07:55:27 +00:00
void WriteValue(FSerializer &ar, const char *key, const void *addr) const override;
bool ReadValue(FSerializer &ar, const char *key, void *addr) const override;
- fixed: Script defined pointers were not added to the FlatPointers array.
2016-11-17 21:21:08 +00:00
- fixed: When loading a savegame the player class in the userinfo needs to be updated. - fixed: Class pointers should not be added to the list of garbage collected pointers. - fixed several warnings in the event code.
2017-02-15 10:55:08 +00:00
void SetPointer(void *base, unsigned offset, TArray<size_t> *special = NULL) const override;
Normalize line endings
2016-03-01 15:47:10 +00:00
virtual bool IsMatch(intptr_t id1, intptr_t id2) const;
virtual void GetTypeIDs(intptr_t &id1, intptr_t &id2) const;
};
// Compound types -----------------------------------------------------------
- fixed: Class and struct name lookup was not context aware. If a later module reused an existing name for a different class or struct type, this new name would completely shadow the old one, even in the base files. Changed it so that each compilation unit (i.e. each ZScript and DECORATE lump) get their own symbol table and can only see the symbol tables that got defined in lower numbered resource files so that later definitions do not pollute the available list of symbols when running the compiler backend and code generator - which happens after everything has been parsed. Another effect of this is that a mod that reuses the name of an internal global constant will only see its own constant, again reducing the risk of potential errors in case the internal definitions add some new values. Global constants are still discouraged from being used because what this does not and can not handle is the case that a mod defines a global constant with the same name as a class variable. In such a case the class variable will always take precedence for code inside that class. Note that the internal struct String had to be renamed for this because the stricter checks did not let the type String pass on the left side of a '.' anymore. - made PEnum inherit from PInt and not from PNamedType. The old inheritance broke nearly every check for integer compatibility in the compiler, so this hopefully leads to a working enum implementation.
2017-01-23 18:09:36 +00:00
class PEnum : public PInt
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- fixed: Class and struct name lookup was not context aware. If a later module reused an existing name for a different class or struct type, this new name would completely shadow the old one, even in the base files. Changed it so that each compilation unit (i.e. each ZScript and DECORATE lump) get their own symbol table and can only see the symbol tables that got defined in lower numbered resource files so that later definitions do not pollute the available list of symbols when running the compiler backend and code generator - which happens after everything has been parsed. Another effect of this is that a mod that reuses the name of an internal global constant will only see its own constant, again reducing the risk of potential errors in case the internal definitions add some new values. Global constants are still discouraged from being used because what this does not and can not handle is the case that a mod defines a global constant with the same name as a class variable. In such a case the class variable will always take precedence for code inside that class. Note that the internal struct String had to be renamed for this because the stricter checks did not let the type String pass on the left side of a '.' anymore. - made PEnum inherit from PInt and not from PNamedType. The old inheritance broke nearly every check for integer compatibility in the compiler, so this hopefully leads to a working enum implementation.
2017-01-23 18:09:36 +00:00
DECLARE_CLASS(PEnum, PInt);
Normalize line endings
2016-03-01 15:47:10 +00:00
public:
- do not declare PNamedType::Outer as DObject. Ultimately we may have to get a fully qualified name out of this, so Outer should be a type that can handle this feature. The new class for this is currently used as base for PType and PSymbol so that PNamedType inherits from it and maybe later a namespace symbol can, too.
2016-10-07 11:59:29 +00:00
PEnum(FName name, PTypeBase *outer);
Normalize line endings
2016-03-01 15:47:10 +00:00
- fixed: Class and struct name lookup was not context aware. If a later module reused an existing name for a different class or struct type, this new name would completely shadow the old one, even in the base files. Changed it so that each compilation unit (i.e. each ZScript and DECORATE lump) get their own symbol table and can only see the symbol tables that got defined in lower numbered resource files so that later definitions do not pollute the available list of symbols when running the compiler backend and code generator - which happens after everything has been parsed. Another effect of this is that a mod that reuses the name of an internal global constant will only see its own constant, again reducing the risk of potential errors in case the internal definitions add some new values. Global constants are still discouraged from being used because what this does not and can not handle is the case that a mod defines a global constant with the same name as a class variable. In such a case the class variable will always take precedence for code inside that class. Note that the internal struct String had to be renamed for this because the stricter checks did not let the type String pass on the left side of a '.' anymore. - made PEnum inherit from PInt and not from PNamedType. The old inheritance broke nearly every check for integer compatibility in the compiler, so this hopefully leads to a working enum implementation.
2017-01-23 18:09:36 +00:00
PTypeBase *Outer;
FName EnumName;
Normalize line endings
2016-03-01 15:47:10 +00:00
protected:
PEnum();
};
class PArray : public PCompoundType
{
DECLARE_CLASS(PArray, PCompoundType);
public:
PArray(PType *etype, unsigned int ecount);
PType *ElementType;
unsigned int ElementCount;
unsigned int ElementSize;
virtual bool IsMatch(intptr_t id1, intptr_t id2) const;
virtual void GetTypeIDs(intptr_t &id1, intptr_t &id2) const;
Added methods for PTypes to serialize their values - Values are tagged to allow for some measure of changing variable types without automatically breaking savegames. - Use these new methods to serialize the non-native variables in an object. This allows for achiving non-ints.
2016-04-03 04:10:43 +00:00
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
void WriteValue(FSerializer &ar, const char *key,const void *addr) const override;
bool ReadValue(FSerializer &ar, const char *key,void *addr) const override;
Added methods for PTypes to serialize their values - Values are tagged to allow for some measure of changing variable types without automatically breaking savegames. - Use these new methods to serialize the non-native variables in an object. This allows for achiving non-ints.
2016-04-03 04:10:43 +00:00
Added code to initialize and destroy string variables in classes - Will require being able to add strings to non-native classes to actually test this.
2016-04-03 22:45:04 +00:00
void SetDefaultValue(void *base, unsigned offset, TArray<FTypeAndOffset> *special) const override;
- fixed: Script defined pointers were not added to the FlatPointers array.
2016-11-17 21:21:08 +00:00
void SetPointer(void *base, unsigned offset, TArray<size_t> *special) const override;
Added code to initialize and destroy string variables in classes - Will require being able to add strings to non-native classes to actually test this.
2016-04-03 22:45:04 +00:00
Normalize line endings
2016-03-01 15:47:10 +00:00
protected:
PArray();
};
- added some syntactic help to the ZScript parser to allow defining the arrays with native structs on the script side instead of having to define them internally.
2017-03-13 11:48:25 +00:00
class PStaticArray : public PArray
- added a TStaticArray class that allows safe access to resizable static data (like the sectors, linedefs, etc.) for the VM. - used this to replace the line list in Sector because that gets already used and implemented proper bounds checks for this type of array.
2017-01-02 20:40:52 +00:00
{
- added some syntactic help to the ZScript parser to allow defining the arrays with native structs on the script side instead of having to define them internally.
2017-03-13 11:48:25 +00:00
DECLARE_CLASS(PStaticArray, PArray);
- added a TStaticArray class that allows safe access to resizable static data (like the sectors, linedefs, etc.) for the VM. - used this to replace the line list in Sector because that gets already used and implemented proper bounds checks for this type of array.
2017-01-02 20:40:52 +00:00
public:
- added some syntactic help to the ZScript parser to allow defining the arrays with native structs on the script side instead of having to define them internally.
2017-03-13 11:48:25 +00:00
PStaticArray(PType *etype);
- added a TStaticArray class that allows safe access to resizable static data (like the sectors, linedefs, etc.) for the VM. - used this to replace the line list in Sector because that gets already used and implemented proper bounds checks for this type of array.
2017-01-02 20:40:52 +00:00
virtual bool IsMatch(intptr_t id1, intptr_t id2) const;
virtual void GetTypeIDs(intptr_t &id1, intptr_t &id2) const;
protected:
- added some syntactic help to the ZScript parser to allow defining the arrays with native structs on the script side instead of having to define them internally.
2017-03-13 11:48:25 +00:00
PStaticArray();
- added a TStaticArray class that allows safe access to resizable static data (like the sectors, linedefs, etc.) for the VM. - used this to replace the line list in Sector because that gets already used and implemented proper bounds checks for this type of array.
2017-01-02 20:40:52 +00:00
};
Normalize line endings
2016-03-01 15:47:10 +00:00
class PDynArray : public PCompoundType
{
DECLARE_CLASS(PDynArray, PCompoundType);
public:
- major work on dynamic array support. Mostly working, some issues still exist with Move and Copy methods and with assignments in stack variables.
2017-02-06 20:39:21 +00:00
PDynArray(PType *etype, PStruct *backing);
Normalize line endings
2016-03-01 15:47:10 +00:00
PType *ElementType;
- major work on dynamic array support. Mostly working, some issues still exist with Move and Copy methods and with assignments in stack variables.
2017-02-06 20:39:21 +00:00
PStruct *BackingType;
Normalize line endings
2016-03-01 15:47:10 +00:00
virtual bool IsMatch(intptr_t id1, intptr_t id2) const;
virtual void GetTypeIDs(intptr_t &id1, intptr_t &id2) const;
- implemented the backend for dynamic arrays. Still needs thorough testing but it should be complete. - use a memory arena to store flat pointers so that the messed up cleanup can be avoided by deallocating this in bulk. - added a new SO opcode to the VM to execute a write barrier. This is necessary for all objects that are not linked into one global table, i.e. everything except thinkers and class types. - always use the cheaper LOS opcode for reading pointers to classes and defaults because these cannot be destroyed during normal operation. - removed the pointless validation from String.Mid. If the values are read as unsigned the internal validation of FString::Mid will automatically ensure proper results.
2017-02-07 13:48:27 +00:00
void WriteValue(FSerializer &ar, const char *key, const void *addr) const override;
bool ReadValue(FSerializer &ar, const char *key, void *addr) const override;
void SetDefaultValue(void *base, unsigned offset, TArray<FTypeAndOffset> *specials) const override;
void InitializeValue(void *addr, const void *def) const override;
void DestroyValue(void *addr) const override;
void SetPointerArray(void *base, unsigned offset, TArray<size_t> *ptrofs = NULL) const override;
Normalize line endings
2016-03-01 15:47:10 +00:00
protected:
PDynArray();
};
class PMap : public PCompoundType
{
DECLARE_CLASS(PMap, PCompoundType);
public:
PMap(PType *keytype, PType *valtype);
PType *KeyType;
PType *ValueType;
virtual bool IsMatch(intptr_t id1, intptr_t id2) const;
virtual void GetTypeIDs(intptr_t &id1, intptr_t &id2) const;
protected:
PMap();
};
class PStruct : public PNamedType
{
DECLARE_CLASS(PStruct, PNamedType);
- added the ability to attach a constructor or destructor to an internally defined struct. There are a few which require explicit native construction or destruction that need to be exported to the VM, e.g. FCheckPosition. The VM cannot handle this directly, it needs two special functions to be attached to handle such elements.
2017-01-11 22:46:03 +00:00
Normalize line endings
2016-03-01 15:47:10 +00:00
public:
- do not declare PNamedType::Outer as DObject. Ultimately we may have to get a fully qualified name out of this, so Outer should be a type that can handle this feature. The new class for this is currently used as base for PType and PSymbol so that PNamedType inherits from it and maybe later a namespace symbol can, too.
2016-10-07 11:59:29 +00:00
PStruct(FName name, PTypeBase *outer);
Normalize line endings
2016-03-01 15:47:10 +00:00
TArray<PField *> Fields;
- scriptified A_SpawnFly. - added support for global variables to the code generator - not the compiler, though. For the handful of entries this is needed for it may just as well be done manually. So far FLevelLocals level is the only one being exported. - fixed: The VM disassembler truncated 64 bit pointers to 15 digits because the output buffer was too small. - resolve entire FxSequences instead of aborting on the first failed entry. This allows to output all errors at once.
2016-11-03 12:38:40 +00:00
bool HasNativeFields;
- added the ability to attach a constructor or destructor to an internally defined struct. There are a few which require explicit native construction or destruction that need to be exported to the VM, e.g. FCheckPosition. The VM cannot handle this directly, it needs two special functions to be attached to handle such elements.
2017-01-11 22:46:03 +00:00
// Some internal structs require explicit construction and destruction of fields the VM cannot handle directly so use thes two functions for it.
VMFunction *mConstructor = nullptr;
VMFunction *mDestructor = nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
- most WORD and SWORD are gone.
2017-03-08 17:50:37 +00:00
virtual PField *AddField(FName name, PType *type, uint32_t flags=0);
virtual PField *AddNativeField(FName name, PType *type, size_t address, uint32_t flags = 0, int bitvalue = 0);
Normalize line endings
2016-03-01 15:47:10 +00:00
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
void WriteValue(FSerializer &ar, const char *key,const void *addr) const override;
bool ReadValue(FSerializer &ar, const char *key,void *addr) const override;
Added code to initialize and destroy string variables in classes - Will require being able to add strings to non-native classes to actually test this.
2016-04-03 22:45:04 +00:00
void SetDefaultValue(void *base, unsigned offset, TArray<FTypeAndOffset> *specials) const override;
- fixed: Script defined pointers were not added to the FlatPointers array.
2016-11-17 21:21:08 +00:00
void SetPointer(void *base, unsigned offset, TArray<size_t> *specials) const override;
Added methods for PTypes to serialize their values - Values are tagged to allow for some measure of changing variable types without automatically breaking savegames. - Use these new methods to serialize the non-native variables in an object. This allows for achiving non-ints.
2016-04-03 04:10:43 +00:00
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
static void WriteFields(FSerializer &ar, const void *addr, const TArray<PField *> &fields);
bool ReadFields(FSerializer &ar, void *addr) const;
Normalize line endings
2016-03-01 15:47:10 +00:00
protected:
PStruct();
};
- allow functions in structs. This is needed for several internal data types like players, sectors, lines, etc. - added a new type 'NativeStruct'. This will be used for types that cannot be instantiated, and is also needed to cleanly handle many internal types that only can exist as reference.
2016-11-19 11:12:29 +00:00
// a native struct will always be abstract and cannot be instantiated. All variables are references.
// In addition, native structs can have methods (but no virtual ones.)
class PNativeStruct : public PStruct
{
DECLARE_CLASS(PNativeStruct, PStruct);
public:
- fixed: Class and struct name lookup was not context aware. If a later module reused an existing name for a different class or struct type, this new name would completely shadow the old one, even in the base files. Changed it so that each compilation unit (i.e. each ZScript and DECORATE lump) get their own symbol table and can only see the symbol tables that got defined in lower numbered resource files so that later definitions do not pollute the available list of symbols when running the compiler backend and code generator - which happens after everything has been parsed. Another effect of this is that a mod that reuses the name of an internal global constant will only see its own constant, again reducing the risk of potential errors in case the internal definitions add some new values. Global constants are still discouraged from being used because what this does not and can not handle is the case that a mod defines a global constant with the same name as a class variable. In such a case the class variable will always take precedence for code inside that class. Note that the internal struct String had to be renamed for this because the stricter checks did not let the type String pass on the left side of a '.' anymore. - made PEnum inherit from PInt and not from PNamedType. The old inheritance broke nearly every check for integer compatibility in the compiler, so this hopefully leads to a working enum implementation.
2017-01-23 18:09:36 +00:00
PNativeStruct(FName name = NAME_None, PTypeBase *outer = nullptr);
- allow functions in structs. This is needed for several internal data types like players, sectors, lines, etc. - added a new type 'NativeStruct'. This will be used for types that cannot be instantiated, and is also needed to cleanly handle many internal types that only can exist as reference.
2016-11-19 11:12:29 +00:00
};
Normalize line endings
2016-03-01 15:47:10 +00:00
class PPrototype : public PCompoundType
{
DECLARE_CLASS(PPrototype, PCompoundType);
public:
PPrototype(const TArray<PType *> &rettypes, const TArray<PType *> &argtypes);
TArray<PType *> ArgumentTypes;
TArray<PType *> ReturnTypes;
size_t PropagateMark();
virtual bool IsMatch(intptr_t id1, intptr_t id2) const;
virtual void GetTypeIDs(intptr_t &id1, intptr_t &id2) const;
protected:
PPrototype();
};
// Meta-info for every class derived from DObject ---------------------------
enum
{
TentativeClass = UINT_MAX,
};
- allow functions in structs. This is needed for several internal data types like players, sectors, lines, etc. - added a new type 'NativeStruct'. This will be used for types that cannot be instantiated, and is also needed to cleanly handle many internal types that only can exist as reference.
2016-11-19 11:12:29 +00:00
class PClass : public PNativeStruct
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- allow functions in structs. This is needed for several internal data types like players, sectors, lines, etc. - added a new type 'NativeStruct'. This will be used for types that cannot be instantiated, and is also needed to cleanly handle many internal types that only can exist as reference.
2016-11-19 11:12:29 +00:00
DECLARE_CLASS(PClass, PNativeStruct);
Normalize line endings
2016-03-01 15:47:10 +00:00
// We unravel _WITH_META here just as we did for PType.
- implemented the basics of a working metadata system. This will store class meta properties in a separate memory block so that it won't have to muck around with PClass - which made the implementation from the scripting branch relatively useless because extending the data wasn't particularly easy and also not well implemented. This can now be handled just like the defaults.
2017-02-27 22:28:19 +00:00
protected:
TArray<FTypeAndOffset> MetaInits;
- implemented handling for virtual function. Syntax-wise I chose to make it as strict as possible to reduce the chance of errors: Virtual base functions must be declared with the 'virtual' keyword, and overrides in child classes with the 'override' keyword. This way any mismatch in parameters that otherwise would cause silent failure will outright produce a compile error.
2016-11-11 19:05:07 +00:00
void Derive(PClass *newclass, FName name);
- implemented the basics of a working metadata system. This will store class meta properties in a separate memory block so that it won't have to muck around with PClass - which made the implementation from the scripting branch relatively useless because extending the data wasn't particularly easy and also not well implemented. This can now be handled just like the defaults.
2017-02-27 22:28:19 +00:00
void InitializeSpecials(void *addr, void *defaults, TArray<FTypeAndOffset> PClass::*Inits);
- implemented complete resolving of constants - both global and class-local. This uses a different algorithm as the old implementation - instead of recursively resolving unknown symbols it will first collect all constants from all scopes and then process them in one operation, doing multiple passes over the list until no more constants can be resolved anymore.
2016-10-08 20:16:10 +00:00
void SetSuper();
- most WORD and SWORD are gone.
2017-03-08 17:50:37 +00:00
PField *AddMetaField(FName name, PType *type, uint32_t flags);
Normalize line endings
2016-03-01 15:47:10 +00:00
public:
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
void WriteValue(FSerializer &ar, const char *key,const void *addr) const override;
void WriteAllFields(FSerializer &ar, const void *addr) const;
bool ReadValue(FSerializer &ar, const char *key,void *addr) const override;
bool ReadAllFields(FSerializer &ar, void *addr) const;
fixed and completed the special field init code. Strings can now be used as class members, and so can structs which contain strings. - made 'DamageMultiply' an actor property and moved the initialization of ConversationRoot to the property handler for the compiler to get this stuff out of the type classes. - consolidate default initialization into one function which performs all the required setup. The original implementation did this when adding the fields but that cannot work because at that time no defaults have been created yet. - fixed: When deriving a class the child class's defaults also must initialize the copied parent fields with special initialization. This part was completely missing. - removed DECORATE code for parsing native classes because it's no longer needed.
2016-11-11 13:40:32 +00:00
void InitializeDefaults();
- implemented handling for virtual function. Syntax-wise I chose to make it as strict as possible to reduce the chance of errors: Virtual base functions must be declared with the 'virtual' keyword, and overrides in child classes with the 'override' keyword. This way any mismatch in parameters that otherwise would cause silent failure will outright produce a compile error.
2016-11-11 19:05:07 +00:00
int FindVirtualIndex(FName name, PPrototype *proto);
Added methods for PTypes to serialize their values - Values are tagged to allow for some measure of changing variable types without automatically breaking savegames. - Use these new methods to serialize the non-native variables in an object. This allows for achiving non-ints.
2016-04-03 04:10:43 +00:00
Normalize line endings
2016-03-01 15:47:10 +00:00
static void StaticInit();
static void StaticShutdown();
static void StaticBootstrap();
// Per-class information -------------------------------------
- implemented the basics of a working metadata system. This will store class meta properties in a separate memory block so that it won't have to muck around with PClass - which made the implementation from the scripting branch relatively useless because extending the data wasn't particularly easy and also not well implemented. This can now be handled just like the defaults.
2017-02-27 22:28:19 +00:00
TArray<FTypeAndOffset> SpecialInits;
Normalize line endings
2016-03-01 15:47:10 +00:00
PClass *ParentClass; // the class this class derives from
const size_t *Pointers; // object pointers defined by this class *only*
const size_t *FlatPointers; // object pointers defined by this class and all its superclasses; not initialized by default
- implemented the backend for dynamic arrays. Still needs thorough testing but it should be complete. - use a memory arena to store flat pointers so that the messed up cleanup can be avoided by deallocating this in bulk. - added a new SO opcode to the VM to execute a write barrier. This is necessary for all objects that are not linked into one global table, i.e. everything except thinkers and class types. - always use the cheaper LOS opcode for reading pointers to classes and defaults because these cannot be destroyed during normal operation. - removed the pointless validation from String.Mid. If the values are read as unsigned the internal validation of FString::Mid will automatically ensure proper results.
2017-02-07 13:48:27 +00:00
const size_t *ArrayPointers; // dynamic arrays containing object pointers.
- the fourth.
2017-03-08 17:47:52 +00:00
uint8_t *Defaults;
uint8_t *Meta; // Per-class static script data
- implemented the basics of a working metadata system. This will store class meta properties in a separate memory block so that it won't have to muck around with PClass - which made the implementation from the scripting branch relatively useless because extending the data wasn't particularly easy and also not well implemented. This can now be handled just like the defaults.
2017-02-27 22:28:19 +00:00
unsigned MetaSize;
Normalize line endings
2016-03-01 15:47:10 +00:00
bool bRuntimeClass; // class was defined at run-time, not compile-time
- scriptified parts of a_bossbrain.cpp. Some things cannot be done yet, the script code is there but commented out. - exported thinker iterator and drop item chain to scripting. Unlike its native counterpart the script-side iterator is wrapped into a DObject to allow proper handling for memory management. - fixed: The VMFunctionBuilder only distinguished between member and action functions but failed on static ones. - fixed: FxAssign did not add all needed type casts. Except for purely numeric types it will now wrap the expression in an FxTypeCast. Numeric handling remains unchanged for both performance reasons and not altering semantics for DECORATE. - exported all internal flags as variables to scripting. They still cannot be used in an actor definition. - make ATAG_STATE the same as ATAG_GENERIC. Since state pointers exist as actual variables they can take both values which on occasion can trigger some asserts. - gave PClass a bExported flag, so that scripts cannot see purely internal classes. Especially the types like PInt can cause problems. Todo: we need readonly references to safely expose the actor defaults. Right now some badly behaving code could overwrite them.
2016-10-31 16:02:47 +00:00
bool bExported; // This type has been declared in a script
- 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
bool bDecorateClass; // may be subject to some idiosyncracies due to DECORATE backwards compatibility
- implemented handling for virtual function. Syntax-wise I chose to make it as strict as possible to reduce the chance of errors: Virtual base functions must be declared with the 'virtual' keyword, and overrides in child classes with the 'override' keyword. This way any mismatch in parameters that otherwise would cause silent failure will outright produce a compile error.
2016-11-11 19:05:07 +00:00
TArray<VMFunction*> Virtuals; // virtual function table
- removed PClass::DeriveData because it is no longer needed. - fixed: IsVisibleToPlayer and optimized it a bit more. - moved SourceLumpName to PClass, so that it can also be used for non-actors (there's a lot of non-Actor classes already.) - separated the serializer for PClassPointer from PPointer. Even though not doable, a pointer to a class type is something entirely different than a class pointer with a restriction so each should handle its own case.
2017-04-12 07:55:27 +00:00
FName SourceLumpName;
Normalize line endings
2016-03-01 15:47:10 +00:00
void (*ConstructNative)(void *);
// The rest are all functions and static data ----------------
PClass();
~PClass();
void InsertIntoHash();
- implemented the basics of a working metadata system. This will store class meta properties in a separate memory block so that it won't have to muck around with PClass - which made the implementation from the scripting branch relatively useless because extending the data wasn't particularly easy and also not well implemented. This can now be handled just like the defaults.
2017-02-27 22:28:19 +00:00
DObject *CreateNew();
Normalize line endings
2016-03-01 15:47:10 +00:00
PClass *CreateDerivedClass(FName name, unsigned int size);
- most WORD and SWORD are gone.
2017-03-08 17:50:37 +00:00
PField *AddField(FName name, PType *type, uint32_t flags=0) override;
Normalize line endings
2016-03-01 15:47:10 +00:00
void InitializeActorInfo();
void BuildFlatPointers();
- implemented the backend for dynamic arrays. Still needs thorough testing but it should be complete. - use a memory arena to store flat pointers so that the messed up cleanup can be avoided by deallocating this in bulk. - added a new SO opcode to the VM to execute a write barrier. This is necessary for all objects that are not linked into one global table, i.e. everything except thinkers and class types. - always use the cheaper LOS opcode for reading pointers to classes and defaults because these cannot be destroyed during normal operation. - removed the pointless validation from String.Mid. If the values are read as unsigned the internal validation of FString::Mid will automatically ensure proper results.
2017-02-07 13:48:27 +00:00
void BuildArrayPointers();
- properly handle all meta properties for inventory items.
2017-02-27 23:45:16 +00:00
void InitMeta();
- implemented the basics of a working metadata system. This will store class meta properties in a separate memory block so that it won't have to muck around with PClass - which made the implementation from the scripting branch relatively useless because extending the data wasn't particularly easy and also not well implemented. This can now be handled just like the defaults.
2017-02-27 22:28:19 +00:00
void DestroySpecials(void *addr);
- 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
void DestroyMeta(void *addr);
Normalize line endings
2016-03-01 15:47:10 +00:00
const PClass *NativeClass() const;
// Returns true if this type is an ancestor of (or same as) the passed type.
bool IsAncestorOf(const PClass *ti) const
{
while (ti)
{
if (this == ti)
return true;
ti = ti->ParentClass;
}
return false;
}
- 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
Normalize line endings
2016-03-01 15:47:10 +00:00
inline bool IsDescendantOf(const PClass *ti) const
{
return ti->IsAncestorOf(this);
}
- 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
inline bool IsDescendantOf(FName ti) const
{
auto me = this;
while (me)
{
if (me->TypeName == ti)
return true;
me = me->ParentClass;
}
return false;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
// Find a type, given its name.
Added methods for PTypes to serialize their values - Values are tagged to allow for some measure of changing variable types without automatically breaking savegames. - Use these new methods to serialize the non-native variables in an object. This allows for achiving non-ints.
2016-04-03 04:10:43 +00:00
const PClass *FindParentClass(FName name) const;
PClass *FindParentClass(FName name) { return const_cast<PClass *>(const_cast<const PClass *>(this)->FindParentClass(name)); }
Normalize line endings
2016-03-01 15:47:10 +00:00
static PClass *FindClass(const char *name) { return FindClass(FName(name, true)); }
static PClass *FindClass(const FString &name) { return FindClass(FName(name, true)); }
static PClass *FindClass(ENamedName name) { return FindClass(FName(name)); }
static PClass *FindClass(FName name);
static PClassActor *FindActor(const char *name) { return FindActor(FName(name, true)); }
static PClassActor *FindActor(const FString &name) { return FindActor(FName(name, true)); }
static PClassActor *FindActor(ENamedName name) { return FindActor(FName(name)); }
static PClassActor *FindActor(FName name);
- scriptified the Sigil. This isn't fully tested yet.
2016-11-28 13:39:25 +00:00
static VMFunction *FindFunction(FName cls, FName func);
- fixed: the restart CCMD must clear out all statically stored pointers to VM functions because they do not survive the shutdown that is needed before loading new data.
2017-01-31 12:41:23 +00:00
static void FindFunction(VMFunction **pptr, FName cls, FName func);
- fixed: ZScript did not properly fill in tentatively created classes from defaults processing. The proper setup for such classes was only done in CreateDerivedClass, but not in FindClassTentative itself. This extends CreateDerivedClass to allow it to create a class without fully initializing it.
2016-11-12 12:09:19 +00:00
PClass *FindClassTentative(FName name);
Normalize line endings
2016-03-01 15:47:10 +00:00
static TArray<PClass *> AllClasses;
- fixed: the restart CCMD must clear out all statically stored pointers to VM functions because they do not survive the shutdown that is needed before loading new data.
2017-01-31 12:41:23 +00:00
static TArray<VMFunction**> FunctionPtrList;
Normalize line endings
2016-03-01 15:47:10 +00:00
static bool bShutdown;
- scriptified the sector actions.
2017-01-13 12:51:47 +00:00
static bool bVMOperational;
Normalize line endings
2016-03-01 15:47:10 +00:00
};
// Type tables --------------------------------------------------------------
struct FTypeTable
{
enum { HASH_SIZE = 1021 };
PType *TypeHash[HASH_SIZE];
PType *FindType(PClass *metatype, intptr_t parm1, intptr_t parm2, size_t *bucketnum);
void AddType(PType *type, PClass *metatype, intptr_t parm1, intptr_t parm2, size_t bucket);
void AddType(PType *type);
void Clear();
static size_t Hash(const PClass *p1, intptr_t p2, intptr_t p3);
};
extern FTypeTable TypeTable;
// Returns a type from the TypeTable. Will create one if it isn't present.
PMap *NewMap(PType *keytype, PType *valuetype);
PArray *NewArray(PType *type, unsigned int count);
- added some syntactic help to the ZScript parser to allow defining the arrays with native structs on the script side instead of having to define them internally.
2017-03-13 11:48:25 +00:00
PStaticArray *NewStaticArray(PType *type);
Normalize line endings
2016-03-01 15:47:10 +00:00
PDynArray *NewDynArray(PType *type);
- added readonly pointers. They need to be defined with 'readonly<classtype>'. These are significantly different from declaring a field readonly in that they do not disallow modification of the variable itself but what it points to. For the actor defaults this is necessary to prevent accidental modification. A readonly pointer is actually a different type than a regular pointer. - fixed code generation for dynamic cast. It was missing the jump instruction after the compare.
2016-11-05 12:51:46 +00:00
PPointer *NewPointer(PType *type, bool isconst = false);
Normalize line endings
2016-03-01 15:47:10 +00:00
PClassPointer *NewClassPointer(PClass *restrict);
- do not declare PNamedType::Outer as DObject. Ultimately we may have to get a fully qualified name out of this, so Outer should be a type that can handle this feature. The new class for this is currently used as base for PType and PSymbol so that PNamedType inherits from it and maybe later a namespace symbol can, too.
2016-10-07 11:59:29 +00:00
PEnum *NewEnum(FName name, PTypeBase *outer);
PStruct *NewStruct(FName name, PTypeBase *outer);
- made all internal struct types NativeStructs so that all variables of their types are made references.
2016-11-21 18:20:27 +00:00
PNativeStruct *NewNativeStruct(FName name, PTypeBase *outer);
Normalize line endings
2016-03-01 15:47:10 +00:00
PPrototype *NewPrototype(const TArray<PType *> &rettypes, const TArray<PType *> &argtypes);
// Built-in types -----------------------------------------------------------
extern PErrorType *TypeError;
- added automatic type deduction capabilities for local variables. If you type 'let variable = value;' the type of 'variable' will be deduced from the given value. This is mostly of interest for type casting pointers, because 'let p = Classtype(objectvar);' does not require writing the class type name twice.
2016-12-05 12:24:42 +00:00
extern PErrorType *TypeAuto;
Normalize line endings
2016-03-01 15:47:10 +00:00
extern PVoidType *TypeVoid;
extern PInt *TypeSInt8, *TypeUInt8;
extern PInt *TypeSInt16, *TypeUInt16;
extern PInt *TypeSInt32, *TypeUInt32;
extern PBool *TypeBool;
extern PFloat *TypeFloat32, *TypeFloat64;
extern PString *TypeString;
extern PName *TypeName;
extern PSound *TypeSound;
extern PColor *TypeColor;
- added two new integral types SpriteID and TextureID, both are needed to allow proper serialization as they require something different to be written out than a regular integer.
2016-11-21 12:45:33 +00:00
extern PTextureID *TypeTextureID;
extern PSpriteID *TypeSpriteID;
- parse the list of class/struct fields and add the PField entries to their type. - fixed a few issues with trying to access a class's Type before it got initialized.
2016-10-09 13:47:31 +00:00
extern PStruct *TypeVector2;
extern PStruct *TypeVector3;
- added per-channel access for color variables. However, since they are locally stored in registers, it required a minor bit of fudging for this case. - make sure that a PFunction's implementation is always initialized before starting the code generator.
2016-11-21 11:38:39 +00:00
extern PStruct *TypeColorStruct;
- scriptified Strife's coins. - added a String class to allow attaching methods to the builtin string type. This works by checking if the left side of the member accessor is a string and just replacing the tyoe in this one place, all the rest is automatic.
2016-11-28 17:15:18 +00:00
extern PStruct *TypeStringStruct;
Normalize line endings
2016-03-01 15:47:10 +00:00
extern PStatePointer *TypeState;
- streamlined font handling for scripts a bit. - moved the two 'you raised the alarm' messages for Strife to the string table
2017-02-05 12:14:22 +00:00
extern PPointer *TypeFont;
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
extern PStateLabel *TypeStateLabel;
- preparations for null pointer support. - add pointer support to FxAssign.
2016-10-21 17:18:39 +00:00
extern PPointer *TypeNullPtr;
some groundwork for the implementation of dynamic arrays - created script exports for all relevant functions with all integral types. - created script side definitions for the underlying data types. - added a void pointer type so that the prototype for the pointer array can use a generic type every pointer can be assigned to.
2017-01-10 23:57:31 +00:00
extern PPointer *TypeVoidPtr;
Normalize line endings
2016-03-01 15:47:10 +00:00
- fixed: Class and struct name lookup was not context aware. If a later module reused an existing name for a different class or struct type, this new name would completely shadow the old one, even in the base files. Changed it so that each compilation unit (i.e. each ZScript and DECORATE lump) get their own symbol table and can only see the symbol tables that got defined in lower numbered resource files so that later definitions do not pollute the available list of symbols when running the compiler backend and code generator - which happens after everything has been parsed. Another effect of this is that a mod that reuses the name of an internal global constant will only see its own constant, again reducing the risk of potential errors in case the internal definitions add some new values. Global constants are still discouraged from being used because what this does not and can not handle is the case that a mod defines a global constant with the same name as a class variable. In such a case the class variable will always take precedence for code inside that class. Note that the internal struct String had to be renamed for this because the stricter checks did not let the type String pass on the left side of a '.' anymore. - made PEnum inherit from PInt and not from PNamedType. The old inheritance broke nearly every check for integer compatibility in the compiler, so this hopefully leads to a working enum implementation.
2017-01-23 18:09:36 +00:00
// Enumerations for serializing types in an archive -------------------------
more inventory scriptification * completely scriptified DehackedPickup and FakeInventory. * scriptified all remaining virtual functions of Inventory, so that its inheritance is now 100% script-side. * scriptified CallTryPickup and most of the code called by that. - fixed: Passing local variables by reference did not work in the VM.
2017-01-19 22:42:12 +00:00
inline bool &DObject::BoolVar(FName field)
{
return *(bool*)ScriptVar(field, TypeBool);
}
- added property definitions to the ZScript parser. This will allow defining custom properties for the default block in custom base classes. See 'Health' for an example. - support transient object member variables for information that does not need to be put in a savegame. - fixed: special initialization of objects needs to pass the proper defaults along, otherwise the parent classes will use their own, inappropriate one.
2017-01-15 15:55:30 +00:00
inline int &DObject::IntVar(FName field)
{
return *(int*)ScriptVar(field, TypeSInt32);
}
- made GetDeathHeight a virtual scripted function. - made GetGibHealth a virtual scripted function. - removed a few more native meta properties.
2017-02-28 12:40:46 +00:00
inline FSoundID &DObject::SoundVar(FName field)
{
return *(FSoundID*)ScriptVar(field, TypeSound);
}
- scriptified the remains of APowerup. - ensure that actor defaults contain a valid virtual table and class pointer so that they can actually use virtual and class-dependent method functions. This is needed for retrieving script variables from them.
2017-01-18 09:33:03 +00:00
inline PalEntry &DObject::ColorVar(FName field)
{
return *(PalEntry*)ScriptVar(field, TypeColor);
}
inline FName &DObject::NameVar(FName field)
{
return *(FName*)ScriptVar(field, TypeName);
}
- added property definitions to the ZScript parser. This will allow defining custom properties for the default block in custom base classes. See 'Health' for an example. - support transient object member variables for information that does not need to be put in a savegame. - fixed: special initialization of objects needs to pass the proper defaults along, otherwise the parent classes will use their own, inappropriate one.
2017-01-15 15:55:30 +00:00
inline double &DObject::FloatVar(FName field)
{
return *(double*)ScriptVar(field, TypeFloat64);
}
- properly handle all meta properties for inventory items.
2017-02-27 23:45:16 +00:00
inline FString &DObject::StringVar(FName field)
{
return *(FString*)ScriptVar(field, TypeString);
}
- scriptified the rest of the weapon pieces.
2017-01-18 17:46:24 +00:00
template<class T>
inline T *&DObject::PointerVar(FName field)
{
return *(T**)ScriptVar(field, nullptr); // pointer check is more tricky and for the handful of uses in the DECORATE parser not worth the hassle.
}
- delete all compile-time symbols for scripting after finishing compiling data. Even the bare-bones gzdoom.pk3 gets rid of over 2000 symbols this way that otherwise would need to be tracked by the garbage collector.
2017-01-24 10:57:42 +00:00
void RemoveUnusedSymbols();
Normalize line endings
2016-03-01 15:47:10 +00:00
#endif
Reference in a new issue Copy permalink