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.cpp

3544 lines
93 KiB
C++
Raw Normal View History

Normalize line endings
2016-03-01 15:47:10 +00:00
/*
** dobjtype.cpp
** Implements the type information class
**
**---------------------------------------------------------------------------
** Copyright 1998-2010 Randy Heit
** All rights reserved.
**
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions
** are met:
**
** 1. Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** 2. Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in the
** documentation and/or other materials provided with the distribution.
** 3. The name of the author may not be used to endorse or promote products
** derived from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**---------------------------------------------------------------------------
**
*/
// HEADER FILES ------------------------------------------------------------
#include <float.h>
#include <limits>
#include "dobject.h"
#include "i_system.h"
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
#include "serializer.h"
Normalize line endings
2016-03-01 15:47:10 +00:00
#include "actor.h"
#include "templates.h"
#include "autosegs.h"
#include "v_text.h"
#include "a_pickups.h"
#include "a_weaponpiece.h"
#include "d_player.h"
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
#include "doomerrors.h"
Normalize line endings
2016-03-01 15:47:10 +00:00
#include "fragglescript/t_fs.h"
// MACROS ------------------------------------------------------------------
// TYPES -------------------------------------------------------------------
// EXTERNAL FUNCTION PROTOTYPES --------------------------------------------
// PUBLIC FUNCTION PROTOTYPES ----------------------------------------------
// PRIVATE FUNCTION PROTOTYPES ---------------------------------------------
// EXTERNAL DATA DECLARATIONS ----------------------------------------------
- added 'strictdecorate' CVAR. If this is set to 'true', any DECORATE error that had to be demoted to a warning for backwards compatibility will be treated as an actual error.
2016-06-08 08:56:11 +00:00
EXTERN_CVAR(Bool, strictdecorate);
Normalize line endings
2016-03-01 15:47:10 +00:00
// PUBLIC DATA DEFINITIONS -------------------------------------------------
FTypeTable TypeTable;
PSymbolTable GlobalSymbols;
TArray<PClass *> PClass::AllClasses;
bool PClass::bShutdown;
PErrorType *TypeError;
PVoidType *TypeVoid;
PInt *TypeSInt8, *TypeUInt8;
PInt *TypeSInt16, *TypeUInt16;
PInt *TypeSInt32, *TypeUInt32;
PBool *TypeBool;
PFloat *TypeFloat32, *TypeFloat64;
PString *TypeString;
PName *TypeName;
PSound *TypeSound;
PColor *TypeColor;
PStatePointer *TypeState;
- 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
PStruct *TypeVector2;
PStruct *TypeVector3;
- preparations for null pointer support. - add pointer support to FxAssign.
2016-10-21 17:18:39 +00:00
PPointer *TypeNullPtr;
Normalize line endings
2016-03-01 15:47:10 +00:00
// PRIVATE DATA DEFINITIONS ------------------------------------------------
// A harmless non-NULL FlatPointer for classes without pointers.
static const size_t TheEnd = ~(size_t)0;
// CODE --------------------------------------------------------------------
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PErrorType, false, false, false)
IMPLEMENT_CLASS(PVoidType, false, false, false)
Normalize line endings
2016-03-01 15:47:10 +00:00
void DumpTypeTable()
{
int used = 0;
int min = INT_MAX;
int max = 0;
int all = 0;
int lens[10] = {0};
for (size_t i = 0; i < countof(TypeTable.TypeHash); ++i)
{
int len = 0;
Printf("%4zu:", i);
for (PType *ty = TypeTable.TypeHash[i]; ty != NULL; ty = ty->HashNext)
{
Printf(" -> %s", ty->IsKindOf(RUNTIME_CLASS(PNamedType)) ? static_cast<PNamedType*>(ty)->TypeName.GetChars(): ty->GetClass()->TypeName.GetChars());
len++;
all++;
}
if (len != 0)
{
used++;
if (len < min)
min = len;
if (len > max)
max = len;
}
if (len < (int)countof(lens))
{
lens[len]++;
}
Printf("\n");
}
Printf("Used buckets: %d/%lu (%.2f%%) for %d entries\n", used, countof(TypeTable.TypeHash), double(used)/countof(TypeTable.TypeHash)*100, all);
Printf("Min bucket size: %d\n", min);
Printf("Max bucket size: %d\n", max);
Printf("Avg bucket size: %.2f\n", double(all) / used);
int j,k;
for (k = countof(lens)-1; k > 0; --k)
if (lens[k])
break;
for (j = 0; j <= k; ++j)
Printf("Buckets of len %d: %d (%.2f%%)\n", j, lens[j], j!=0?double(lens[j])/used*100:-1.0);
}
/* PClassType *************************************************************/
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PClassType, false, false, false)
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PClassType Constructor
//
//==========================================================================
PClassType::PClassType()
: TypeTableType(NULL)
{
}
//==========================================================================
//
// PClassType :: Derive
//
//==========================================================================
void PClassType::Derive(PClass *newclass)
{
assert(newclass->IsKindOf(RUNTIME_CLASS(PClassType)));
Super::Derive(newclass);
static_cast<PClassType *>(newclass)->TypeTableType = TypeTableType;
}
/* PClassClass ************************************************************/
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PClassClass, false, false, false)
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PClassClass Constructor
//
// The only thing we want to do here is automatically set TypeTableType
// to PClass.
//
//==========================================================================
PClassClass::PClassClass()
{
TypeTableType = RUNTIME_CLASS(PClass);
}
/* PType ******************************************************************/
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PType, true, true, false)
Separate the pointer list from the implement macro
2016-11-05 16:08:54 +00:00
IMPLEMENT_POINTERS_START(PType)
IMPLEMENT_POINTER(HashNext)
IMPLEMENT_POINTERS_END
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PType Parameterized Constructor
//
//==========================================================================
PType::PType(unsigned int size, unsigned int align)
: Size(size), Align(align), HashNext(NULL)
{
- 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
mDescriptiveName = "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
loadOp = OP_NOP;
storeOp = OP_NOP;
moveOp = OP_NOP;
RegType = REGT_NIL;
- 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
RegCount = 1;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
// PType Destructor
//
//==========================================================================
PType::~PType()
{
}
//==========================================================================
//
// PType :: PropagateMark
//
//==========================================================================
size_t PType::PropagateMark()
{
size_t marked = Symbols.MarkSymbols();
return marked + Super::PropagateMark();
}
//==========================================================================
//
// PType :: AddConversion
//
//==========================================================================
bool PType::AddConversion(PType *target, void (*convertconst)(ZCC_ExprConstant *, class FSharedStringArena &))
{
// Make sure a conversion hasn't already been registered
for (unsigned i = 0; i < Conversions.Size(); ++i)
{
if (Conversions[i].TargetType == target)
return false;
}
Conversions.Push(Conversion(target, convertconst));
return true;
}
//==========================================================================
//
// PType :: FindConversion
//
// Returns <0 if there is no path to target. Otherwise, returns the distance
// to target and fills slots (if non-NULL) with the necessary conversions
// to get there. A result of 0 means this is the target.
//
//==========================================================================
int PType::FindConversion(PType *target, const PType::Conversion **slots, int numslots)
{
if (this == target)
{
return 0;
}
// The queue is implemented as a ring buffer
VisitQueue queue;
VisitedNodeSet visited;
// Use a breadth-first search to find the shortest path to the target.
MarkPred(NULL, -1, -1);
queue.Push(this);
visited.Insert(this);
while (!queue.IsEmpty())
{
PType *t = queue.Pop();
if (t == target)
{ // found it
if (slots != NULL)
{
if (t->Distance >= numslots)
{ // Distance is too far for the output
return -2;
}
t->FillConversionPath(slots);
}
return t->Distance + 1;
}
for (unsigned i = 0; i < t->Conversions.Size(); ++i)
{
PType *succ = t->Conversions[i].TargetType;
if (!visited.Check(succ))
{
succ->MarkPred(t, i, t->Distance + 1);
visited.Insert(succ);
queue.Push(succ);
}
}
}
return -1;
}
//==========================================================================
//
// PType :: FillConversionPath
//
// Traces backwards from the target type to the original type and fills in
// the conversions necessary to get between them. slots must point to an
// array large enough to contain the entire path.
//
//==========================================================================
void PType::FillConversionPath(const PType::Conversion **slots)
{
for (PType *node = this; node->Distance >= 0; node = node->PredType)
{
assert(node->PredType != NULL);
slots[node->Distance] = &node->PredType->Conversions[node->PredConv];
}
}
//==========================================================================
//
// PType :: VisitQueue :: Push
//
//==========================================================================
void PType::VisitQueue::Push(PType *type)
{
Queue[In] = type;
Advance(In);
assert(!IsEmpty() && "Queue overflowed");
}
//==========================================================================
//
// PType :: VisitQueue :: Pop
//
//==========================================================================
PType *PType::VisitQueue::Pop()
{
if (IsEmpty())
{
return NULL;
}
PType *node = Queue[Out];
Advance(Out);
return node;
}
//==========================================================================
//
// PType :: VisitedNodeSet :: Insert
//
//==========================================================================
void PType::VisitedNodeSet::Insert(PType *node)
{
assert(!Check(node) && "Node was already inserted");
size_t buck = Hash(node) & (countof(Buckets) - 1);
node->VisitNext = Buckets[buck];
Buckets[buck] = node;
}
//==========================================================================
//
// PType :: VisitedNodeSet :: Check
//
//==========================================================================
bool PType::VisitedNodeSet::Check(const PType *node)
{
size_t buck = Hash(node) & (countof(Buckets) - 1);
for (const PType *probe = Buckets[buck]; probe != NULL; probe = probe->VisitNext)
{
if (probe == node)
{
return true;
}
}
return false;
}
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
//==========================================================================
//
// PType :: WriteValue
//
//==========================================================================
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
void PType::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
{
assert(0 && "Cannot write value for this type");
}
//==========================================================================
//
// PType :: ReadValue
//
//==========================================================================
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
bool PType::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
{
assert(0 && "Cannot read value for this type");
return false;
}
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
//==========================================================================
//
// PType :: SetDefaultValue
//
//==========================================================================
void PType::SetDefaultValue(void *base, unsigned offset, TArray<FTypeAndOffset> *stroffs) const
{
}
//==========================================================================
//
// PType :: InitializeValue
//
//==========================================================================
void PType::InitializeValue(void *addr, const void *def) const
{
}
//==========================================================================
//
// PType :: DestroyValue
//
//==========================================================================
void PType::DestroyValue(void *addr) const
{
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PType :: SetValue
//
//==========================================================================
void PType::SetValue(void *addr, int val)
{
Add double variants of SetValue() for numeric PTypes
2016-03-30 03:05:25 +00:00
assert(0 && "Cannot set int value for this type");
}
void PType::SetValue(void *addr, double val)
{
assert(0 && "Cannot set float value for this type");
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
// PType :: GetValue
//
//==========================================================================
int PType::GetValueInt(void *addr) const
{
assert(0 && "Cannot get value for this type");
return 0;
}
Add GetValueFloat() for numeric PTypes
2016-03-30 03:24:59 +00:00
double PType::GetValueFloat(void *addr) const
{
assert(0 && "Cannot get value for this type");
return 0;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PType :: IsMatch
//
//==========================================================================
bool PType::IsMatch(intptr_t id1, intptr_t id2) const
{
return false;
}
//==========================================================================
//
// PType :: GetTypeIDs
//
//==========================================================================
void PType::GetTypeIDs(intptr_t &id1, intptr_t &id2) const
{
id1 = 0;
id2 = 0;
}
- 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
//==========================================================================
//
// PType :: GetTypeIDs
//
//==========================================================================
const char *PType::DescriptiveName() const
{
return mDescriptiveName.GetChars();
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PType :: StaticInit STATIC
//
// Set up TypeTableType values for every PType child and create basic types.
//
//==========================================================================
void ReleaseGlobalSymbols()
{
TypeTable.Clear();
GlobalSymbols.ReleaseSymbols();
}
void PType::StaticInit()
{
// Add types to the global symbol table.
atterm(ReleaseGlobalSymbols);
// Set up TypeTable hash keys.
RUNTIME_CLASS(PErrorType)->TypeTableType = RUNTIME_CLASS(PErrorType);
RUNTIME_CLASS(PVoidType)->TypeTableType = RUNTIME_CLASS(PVoidType);
RUNTIME_CLASS(PInt)->TypeTableType = RUNTIME_CLASS(PInt);
RUNTIME_CLASS(PBool)->TypeTableType = RUNTIME_CLASS(PBool);
RUNTIME_CLASS(PFloat)->TypeTableType = RUNTIME_CLASS(PFloat);
RUNTIME_CLASS(PString)->TypeTableType = RUNTIME_CLASS(PString);
RUNTIME_CLASS(PName)->TypeTableType = RUNTIME_CLASS(PName);
RUNTIME_CLASS(PSound)->TypeTableType = RUNTIME_CLASS(PSound);
RUNTIME_CLASS(PColor)->TypeTableType = RUNTIME_CLASS(PColor);
RUNTIME_CLASS(PPointer)->TypeTableType = RUNTIME_CLASS(PPointer);
PClassPointer should use its own type as the metatype in the type table - I don't remember why I thought using PPointer as the metatype for PClassPointer would be preferable, but it means that PPointer's MatchID can potentially be called for PClassPointer entries.
2016-03-03 21:09:19 +00:00
RUNTIME_CLASS(PClassPointer)->TypeTableType = RUNTIME_CLASS(PClassPointer);
Normalize line endings
2016-03-01 15:47:10 +00:00
RUNTIME_CLASS(PEnum)->TypeTableType = RUNTIME_CLASS(PEnum);
RUNTIME_CLASS(PArray)->TypeTableType = RUNTIME_CLASS(PArray);
RUNTIME_CLASS(PDynArray)->TypeTableType = RUNTIME_CLASS(PDynArray);
RUNTIME_CLASS(PVector)->TypeTableType = RUNTIME_CLASS(PVector);
RUNTIME_CLASS(PMap)->TypeTableType = RUNTIME_CLASS(PMap);
RUNTIME_CLASS(PStruct)->TypeTableType = RUNTIME_CLASS(PStruct);
RUNTIME_CLASS(PPrototype)->TypeTableType = RUNTIME_CLASS(PPrototype);
RUNTIME_CLASS(PClass)->TypeTableType = RUNTIME_CLASS(PClass);
RUNTIME_CLASS(PStatePointer)->TypeTableType = RUNTIME_CLASS(PStatePointer);
- The fixed_t type for the VM also is not needed any longer and was removed.
2016-03-25 14:50:39 +00:00
Normalize line endings
2016-03-01 15:47:10 +00:00
// Create types and add them type the type table.
TypeTable.AddType(TypeError = new PErrorType);
TypeTable.AddType(TypeVoid = new PVoidType);
TypeTable.AddType(TypeSInt8 = new PInt(1, false));
TypeTable.AddType(TypeUInt8 = new PInt(1, true));
TypeTable.AddType(TypeSInt16 = new PInt(2, false));
TypeTable.AddType(TypeUInt16 = new PInt(2, true));
TypeTable.AddType(TypeSInt32 = new PInt(4, false));
TypeTable.AddType(TypeUInt32 = new PInt(4, true));
TypeTable.AddType(TypeBool = new PBool);
TypeTable.AddType(TypeFloat32 = new PFloat(4));
TypeTable.AddType(TypeFloat64 = new PFloat(8));
TypeTable.AddType(TypeString = new PString);
TypeTable.AddType(TypeName = new PName);
TypeTable.AddType(TypeSound = new PSound);
TypeTable.AddType(TypeColor = new PColor);
TypeTable.AddType(TypeState = new PStatePointer);
- preparations for null pointer support. - add pointer support to FxAssign.
2016-10-21 17:18:39 +00:00
TypeTable.AddType(TypeNullPtr = new PPointer);
Normalize line endings
2016-03-01 15:47:10 +00:00
- 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
TypeVector2 = new PStruct(NAME_Vector2, nullptr);
TypeVector2->AddField(NAME_X, TypeFloat64);
TypeVector2->AddField(NAME_Y, TypeFloat64);
TypeTable.AddType(TypeVector2);
- fixed GetOps() call and added info for vectors.
2016-10-28 11:30:19 +00:00
TypeVector2->loadOp = OP_LV2;
TypeVector2->storeOp = OP_SV2;
TypeVector2->moveOp = OP_MOVEV2;
- 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
TypeVector2->RegType = REGT_FLOAT;
TypeVector2->RegCount = 2;
- 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
TypeVector3 = new PStruct(NAME_Vector3, nullptr);
TypeVector3->AddField(NAME_X, TypeFloat64);
TypeVector3->AddField(NAME_Y, TypeFloat64);
TypeVector3->AddField(NAME_Z, TypeFloat64);
- replaced 'vector<2>' and 'vector<3>' with 'vector2' and 'vector3'. - added initializer syntax for vectors. A vector can be set with vectorvar = (x,y,z); for a 3-dimensional vector and vectorvar = (x, y); for a 2-dimensional one.
2016-10-27 23:14:21 +00:00
// allow accessing xy as a vector2. This is marked native because it's not supposed to be serialized.
TypeVector3->Symbols.AddSymbol(new PField(NAME_XY, TypeVector2, VARF_Native, 0));
- 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
TypeTable.AddType(TypeVector3);
- 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
TypeVector3->loadOp = OP_LV3;
TypeVector3->storeOp = OP_SV3;
TypeVector3->moveOp = OP_MOVEV3;
TypeVector3->RegType = REGT_FLOAT;
TypeVector3->RegCount = 3;
- 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
GlobalSymbols.AddSymbol(new PSymbolType(NAME_sByte, TypeSInt8));
GlobalSymbols.AddSymbol(new PSymbolType(NAME_Byte, TypeUInt8));
GlobalSymbols.AddSymbol(new PSymbolType(NAME_Short, TypeSInt16));
GlobalSymbols.AddSymbol(new PSymbolType(NAME_uShort, TypeUInt16));
GlobalSymbols.AddSymbol(new PSymbolType(NAME_Int, TypeSInt32));
GlobalSymbols.AddSymbol(new PSymbolType(NAME_uInt, TypeUInt32));
GlobalSymbols.AddSymbol(new PSymbolType(NAME_Bool, TypeBool));
GlobalSymbols.AddSymbol(new PSymbolType(NAME_Float, TypeFloat64));
GlobalSymbols.AddSymbol(new PSymbolType(NAME_Double, TypeFloat64));
GlobalSymbols.AddSymbol(new PSymbolType(NAME_Float32, TypeFloat32));
GlobalSymbols.AddSymbol(new PSymbolType(NAME_Float64, TypeFloat64));
GlobalSymbols.AddSymbol(new PSymbolType(NAME_String, TypeString));
GlobalSymbols.AddSymbol(new PSymbolType(NAME_Name, TypeName));
GlobalSymbols.AddSymbol(new PSymbolType(NAME_Sound, TypeSound));
GlobalSymbols.AddSymbol(new PSymbolType(NAME_Color, TypeColor));
GlobalSymbols.AddSymbol(new PSymbolType(NAME_State, TypeState));
- 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
GlobalSymbols.AddSymbol(new PSymbolType(NAME_Vector2, TypeVector2));
GlobalSymbols.AddSymbol(new PSymbolType(NAME_Vector3, TypeVector3));
Normalize line endings
2016-03-01 15:47:10 +00:00
}
/* PBasicType *************************************************************/
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PBasicType, true, false, false)
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PBasicType Default Constructor
//
//==========================================================================
PBasicType::PBasicType()
{
}
//==========================================================================
//
// PBasicType Parameterized Constructor
//
//==========================================================================
PBasicType::PBasicType(unsigned int size, unsigned int align)
: PType(size, align)
{
- 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
mDescriptiveName = "BasicType";
Normalize line endings
2016-03-01 15:47:10 +00:00
}
/* PCompoundType **********************************************************/
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PCompoundType, true, false, false)
Normalize line endings
2016-03-01 15:47:10 +00:00
/* PNamedType *************************************************************/
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PNamedType, true, true, false)
Separate the pointer list from the implement macro
2016-11-05 16:08:54 +00:00
IMPLEMENT_POINTERS_START(PNamedType)
IMPLEMENT_POINTER(Outer)
IMPLEMENT_POINTERS_END
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PNamedType :: IsMatch
//
//==========================================================================
bool PNamedType::IsMatch(intptr_t id1, intptr_t id2) const
{
const DObject *outer = (const DObject *)id1;
FName name = (ENamedName)(intptr_t)id2;
return Outer == outer && TypeName == name;
}
//==========================================================================
//
// PNamedType :: GetTypeIDs
//
//==========================================================================
void PNamedType::GetTypeIDs(intptr_t &id1, intptr_t &id2) const
{
id1 = (intptr_t)Outer;
id2 = TypeName;
}
- 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
//==========================================================================
//
// PNamedType :: QualifiedName
//
//==========================================================================
FString PNamedType::QualifiedName() const
{
FString out;
if (Outer != nullptr) out = Outer->QualifiedName();
out << "::" << TypeName;
return out;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
/* PInt *******************************************************************/
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PInt, false, false, false)
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PInt Default Constructor
//
//==========================================================================
PInt::PInt()
: PBasicType(4, 4), Unsigned(false)
{
- 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
mDescriptiveName = "SInt32";
Normalize line endings
2016-03-01 15:47:10 +00:00
Symbols.AddSymbol(new PSymbolConstNumeric(NAME_Min, this, -0x7FFFFFFF - 1));
Symbols.AddSymbol(new PSymbolConstNumeric(NAME_Max, this, 0x7FFFFFFF));
- fixed GetOps() call and added info for vectors.
2016-10-28 11:30:19 +00:00
SetOps();
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
// PInt Parameterized Constructor
//
//==========================================================================
PInt::PInt(unsigned int size, bool unsign)
: PBasicType(size, size), Unsigned(unsign)
{
- 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
mDescriptiveName.Format("%cInt%d", unsign? 'U':'S', size);
- 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
MemberOnly = (size < 4);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (!unsign)
{
int maxval = (1 << ((8 * size) - 1)) - 1;
int minval = -maxval - 1;
Symbols.AddSymbol(new PSymbolConstNumeric(NAME_Min, this, minval));
Symbols.AddSymbol(new PSymbolConstNumeric(NAME_Max, this, maxval));
}
else
{
Symbols.AddSymbol(new PSymbolConstNumeric(NAME_Min, this, 0u));
Symbols.AddSymbol(new PSymbolConstNumeric(NAME_Max, this, (1u << (8 * size)) - 1));
}
- 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
SetOps();
}
void PInt::SetOps()
{
moveOp = OP_MOVE;
RegType = REGT_INT;
if (Size == 4)
{
storeOp = OP_SW;
loadOp = OP_LW;
}
else if (Size == 1)
{
storeOp = OP_SB;
loadOp = Unsigned ? OP_LBU : OP_LB;
}
else if (Size == 2)
{
storeOp = OP_SH;
loadOp = Unsigned ? OP_LHU : OP_LH;
}
else
{
assert(0 && "Unhandled integer size");
storeOp = OP_NOP;
}
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
//==========================================================================
//
// PInt :: WriteValue
//
//==========================================================================
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
void PInt::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
{
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
if (Size == 8 && Unsigned)
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
// this is a special case that cannot be represented by an int64_t.
uint64_t val = *(uint64_t*)addr;
ar(key, val);
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
else
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
int64_t val;
switch (Size)
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
case 1:
val = Unsigned ? *(uint8_t*)addr : *(int8_t*)addr;
break;
case 2:
val = Unsigned ? *(uint16_t*)addr : *(int16_t*)addr;
break;
case 4:
val = Unsigned ? *(uint32_t*)addr : *(int32_t*)addr;
break;
case 8:
val = *(int64_t*)addr;
break;
default:
return; // something invalid
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
ar(key, val);
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
}
}
//==========================================================================
//
// PInt :: ReadValue
//
//==========================================================================
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
bool PInt::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
{
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
NumericValue val;
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
ar(key, val);
if (val.type == NumericValue::NM_invalid) return false; // not found or usable
if (val.type == NumericValue::NM_float) val.signedval = (int64_t)val.floatval;
// No need to check the unsigned state here. Downcasting to smaller types will yield the same result for both.
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
switch (Size)
{
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
case 1:
*(uint8_t*)addr = (uint8_t)val.signedval;
break;
case 2:
*(uint16_t*)addr = (uint16_t)val.signedval;
break;
case 4:
*(uint32_t*)addr = (uint32_t)val.signedval;
break;
case 8:
*(uint64_t*)addr = (uint64_t)val.signedval;
break;
default:
return false; // something invalid
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
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
return true;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PInt :: SetValue
//
//==========================================================================
void PInt::SetValue(void *addr, int val)
{
assert(((intptr_t)addr & (Align - 1)) == 0 && "unaligned address");
if (Size == 4)
{
*(int *)addr = val;
}
else if (Size == 1)
{
*(BYTE *)addr = val;
}
else if (Size == 2)
{
*(WORD *)addr = val;
}
else if (Size == 8)
{
*(QWORD *)addr = val;
}
else
{
assert(0 && "Unhandled integer size");
}
}
Add double variants of SetValue() for numeric PTypes
2016-03-30 03:05:25 +00:00
void PInt::SetValue(void *addr, double val)
{
SetValue(addr, (int)val);
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PInt :: GetValueInt
//
//==========================================================================
int PInt::GetValueInt(void *addr) const
{
assert(((intptr_t)addr & (Align - 1)) == 0 && "unaligned address");
if (Size == 4)
{
return *(int *)addr;
}
else if (Size == 1)
{
return Unsigned ? *(BYTE *)addr : *(SBYTE *)addr;
}
else if (Size == 2)
{
return Unsigned ? *(WORD *)addr : *(SWORD *)addr;
}
else if (Size == 8)
{ // truncated output
return (int)*(QWORD *)addr;
}
else
{
assert(0 && "Unhandled integer size");
return 0;
}
}
Add GetValueFloat() for numeric PTypes
2016-03-30 03:24:59 +00:00
//==========================================================================
//
// PInt :: GetValueFloat
//
//==========================================================================
double PInt::GetValueFloat(void *addr) const
{
return GetValueInt(addr);
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PInt :: GetStoreOp
//
//==========================================================================
/* PBool ******************************************************************/
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PBool, false, false, false)
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PBool Default Constructor
//
//==========================================================================
PBool::PBool()
: PInt(sizeof(bool), true)
{
- 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
mDescriptiveName = "Bool";
MemberOnly = false;
Normalize line endings
2016-03-01 15:47:10 +00:00
// Override the default max set by PInt's constructor
PSymbolConstNumeric *maxsym = static_cast<PSymbolConstNumeric *>(Symbols.FindSymbol(NAME_Max, false));
assert(maxsym != NULL && maxsym->IsKindOf(RUNTIME_CLASS(PSymbolConstNumeric)));
maxsym->Value = 1;
}
/* PFloat *****************************************************************/
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PFloat, false, false, false)
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PFloat Default Constructor
//
//==========================================================================
PFloat::PFloat()
: PBasicType(8, 8)
{
- 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
mDescriptiveName = "Float";
Normalize line endings
2016-03-01 15:47:10 +00:00
SetDoubleSymbols();
- 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
SetOps();
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
// PFloat Parameterized Constructor
//
//==========================================================================
PFloat::PFloat(unsigned int size)
: PBasicType(size, size)
{
- 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
mDescriptiveName.Format("Float%d", size);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (size == 8)
{
SetDoubleSymbols();
}
else
{
assert(size == 4);
- 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
MemberOnly = true;
Normalize line endings
2016-03-01 15:47:10 +00:00
SetSingleSymbols();
}
- 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
SetOps();
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
// PFloat :: SetDoubleSymbols
//
// Setup constant values for 64-bit floats.
//
//==========================================================================
void PFloat::SetDoubleSymbols()
{
static const SymbolInitF symf[] =
{
{ NAME_Min_Normal, DBL_MIN },
{ NAME_Max, DBL_MAX },
{ NAME_Epsilon, DBL_EPSILON },
{ NAME_NaN, std::numeric_limits<double>::quiet_NaN() },
{ NAME_Infinity, std::numeric_limits<double>::infinity() },
{ NAME_Min_Denormal, std::numeric_limits<double>::denorm_min() }
};
static const SymbolInitI symi[] =
{
{ NAME_Dig, DBL_DIG },
{ NAME_Min_Exp, DBL_MIN_EXP },
{ NAME_Max_Exp, DBL_MAX_EXP },
{ NAME_Mant_Dig, DBL_MANT_DIG },
{ NAME_Min_10_Exp, DBL_MIN_10_EXP },
{ NAME_Max_10_Exp, DBL_MAX_10_EXP }
};
SetSymbols(symf, countof(symf));
SetSymbols(symi, countof(symi));
}
//==========================================================================
//
// PFloat :: SetSingleSymbols
//
// Setup constant values for 32-bit floats.
//
//==========================================================================
void PFloat::SetSingleSymbols()
{
static const SymbolInitF symf[] =
{
{ NAME_Min_Normal, FLT_MIN },
{ NAME_Max, FLT_MAX },
{ NAME_Epsilon, FLT_EPSILON },
{ NAME_NaN, std::numeric_limits<float>::quiet_NaN() },
{ NAME_Infinity, std::numeric_limits<float>::infinity() },
{ NAME_Min_Denormal, std::numeric_limits<float>::denorm_min() }
};
static const SymbolInitI symi[] =
{
{ NAME_Dig, FLT_DIG },
{ NAME_Min_Exp, FLT_MIN_EXP },
{ NAME_Max_Exp, FLT_MAX_EXP },
{ NAME_Mant_Dig, FLT_MANT_DIG },
{ NAME_Min_10_Exp, FLT_MIN_10_EXP },
{ NAME_Max_10_Exp, FLT_MAX_10_EXP }
};
SetSymbols(symf, countof(symf));
SetSymbols(symi, countof(symi));
}
//==========================================================================
//
// PFloat :: SetSymbols
//
//==========================================================================
void PFloat::SetSymbols(const PFloat::SymbolInitF *sym, size_t count)
{
for (size_t i = 0; i < count; ++i)
{
Symbols.AddSymbol(new PSymbolConstNumeric(sym[i].Name, this, sym[i].Value));
}
}
void PFloat::SetSymbols(const PFloat::SymbolInitI *sym, size_t count)
{
for (size_t i = 0; i < count; ++i)
{
Symbols.AddSymbol(new PSymbolConstNumeric(sym[i].Name, this, sym[i].Value));
}
}
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
//==========================================================================
//
// PFloat :: WriteValue
//
//==========================================================================
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
void PFloat::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
{
if (Size == 8)
{
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
ar(key, *(double*)addr);
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
}
else
{
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
ar(key, *(float*)addr);
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
}
}
//==========================================================================
//
// PFloat :: ReadValue
//
//==========================================================================
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
bool PFloat::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
{
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
NumericValue val;
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
ar(key, val);
if (val.type == NumericValue::NM_invalid) return false; // not found or usable
else if (val.type == NumericValue::NM_signed) val.floatval = (double)val.signedval;
else if (val.type == NumericValue::NM_unsigned) val.floatval = (double)val.unsignedval;
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
if (Size == 8)
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
*(double*)addr = val.floatval;
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
else
{
*(float*)addr = (float)val.floatval;
}
return true;
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
//==========================================================================
//
// PFloat :: SetValue
//
//==========================================================================
void PFloat::SetValue(void *addr, int val)
Add double variants of SetValue() for numeric PTypes
2016-03-30 03:05:25 +00:00
{
return SetValue(addr, (double)val);
}
void PFloat::SetValue(void *addr, double val)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
assert(((intptr_t)addr & (Align - 1)) == 0 && "unaligned address");
if (Size == 4)
{
*(float *)addr = (float)val;
}
else
{
assert(Size == 8);
*(double *)addr = val;
}
}
//==========================================================================
//
// PFloat :: GetValueInt
//
//==========================================================================
int PFloat::GetValueInt(void *addr) const
Add GetValueFloat() for numeric PTypes
2016-03-30 03:24:59 +00:00
{
return xs_ToInt(GetValueFloat(addr));
}
//==========================================================================
//
// PFloat :: GetValueFloat
//
//==========================================================================
double PFloat::GetValueFloat(void *addr) const
Normalize line endings
2016-03-01 15:47:10 +00:00
{
assert(((intptr_t)addr & (Align - 1)) == 0 && "unaligned address");
if (Size == 4)
{
Add GetValueFloat() for numeric PTypes
2016-03-30 03:24:59 +00:00
return *(float *)addr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
assert(Size == 8);
Add GetValueFloat() for numeric PTypes
2016-03-30 03:24:59 +00:00
return *(double *)addr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
//==========================================================================
//
// PFloat :: GetStoreOp
//
//==========================================================================
- 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 PFloat::SetOps()
Normalize line endings
2016-03-01 15:47:10 +00:00
{
if (Size == 4)
{
- 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
storeOp = OP_SSP;
loadOp = OP_LSP;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
assert(Size == 8);
- 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
storeOp = OP_SDP;
loadOp = OP_LDP;
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
moveOp = OP_MOVEF;
RegType = REGT_FLOAT;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
/* PString ****************************************************************/
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PString, false, false, false)
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PString Default Constructor
//
//==========================================================================
PString::PString()
: PBasicType(sizeof(FString), __alignof(FString))
{
- 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
mDescriptiveName = "String";
- 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
storeOp = OP_SS;
loadOp = OP_LS;
moveOp = OP_MOVES;
RegType = REGT_STRING;
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
//==========================================================================
//
// PString :: WriteValue
//
//==========================================================================
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
void PString::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
{
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
ar(key, *(FString*)addr);
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
}
//==========================================================================
//
// PString :: ReadValue
//
//==========================================================================
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
bool PString::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
{
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
const char *cptr;
ar.StringPtr(key, cptr);
if (cptr == nullptr)
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
return false;
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
}
else
{
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
*(FString*)addr = cptr;
return true;
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
//==========================================================================
//
// PString :: SetDefaultValue
//
//==========================================================================
void PString::SetDefaultValue(void *base, unsigned offset, TArray<FTypeAndOffset> *special) const
{
- changed PClass:AddField so that it doesn't create defaults if none are present. The ZScript compiler will not create any defaults until after all fields have been added and this function created bad data if it was run on a class without defaults. - added checks for duplicate field names. - moved the tree node symbol tables out of PSymbolTreeNode to the worker data. That symbol is a bad location because it restricts the usefulness of the symbol class which is also needed for variables which use different AST structs. - fixed some memory management issues with the work classes for the compiler that became apparent after moving the symbol tables in there. In several places these were copied around, possibly losing data.
2016-10-09 23:18:47 +00:00
if (base != nullptr) new((BYTE *)base + offset) FString;
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
if (special != NULL)
{
special->Push(std::make_pair(this, offset));
}
}
//==========================================================================
//
// PString :: InitializeValue
//
//==========================================================================
void PString::InitializeValue(void *addr, const void *def) const
{
- changed PClass:AddField so that it doesn't create defaults if none are present. The ZScript compiler will not create any defaults until after all fields have been added and this function created bad data if it was run on a class without defaults. - added checks for duplicate field names. - moved the tree node symbol tables out of PSymbolTreeNode to the worker data. That symbol is a bad location because it restricts the usefulness of the symbol class which is also needed for variables which use different AST structs. - fixed some memory management issues with the work classes for the compiler that became apparent after moving the symbol tables in there. In several places these were copied around, possibly losing data.
2016-10-09 23:18:47 +00:00
if (def != nullptr)
{
new(addr) FString(*(FString *)def);
}
else
{
new(addr) FString;
}
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
}
//==========================================================================
//
// PString :: DestroyValue
//
//==========================================================================
void PString::DestroyValue(void *addr) const
{
((FString *)addr)->~FString();
}
Normalize line endings
2016-03-01 15:47:10 +00:00
/* PName ******************************************************************/
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PName, false, false, false)
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PName Default Constructor
//
//==========================================================================
PName::PName()
: PInt(sizeof(FName), true)
{
- 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
mDescriptiveName = "Name";
Normalize line endings
2016-03-01 15:47:10 +00:00
assert(sizeof(FName) == __alignof(FName));
}
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
//==========================================================================
//
// PName :: WriteValue
//
//==========================================================================
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
void PName::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
{
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
const char *cptr = ((const FName*)addr)->GetChars();
ar.StringPtr(key, cptr);
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
}
//==========================================================================
//
// PName :: ReadValue
//
//==========================================================================
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
bool PName::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
{
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
const char *cptr;
ar.StringPtr(key, cptr);
if (cptr == nullptr)
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
return false;
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
}
else
{
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
*(FName*)addr = FName(cptr);
return true;
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
/* PSound *****************************************************************/
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PSound, false, false, false)
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PSound Default Constructor
//
//==========================================================================
PSound::PSound()
: PInt(sizeof(FSoundID), true)
{
- 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
mDescriptiveName = "Sound";
Normalize line endings
2016-03-01 15:47:10 +00:00
assert(sizeof(FSoundID) == __alignof(FSoundID));
}
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
//==========================================================================
//
// PSound :: WriteValue
//
//==========================================================================
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
void PSound::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
{
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
const char *cptr = *(const FSoundID *)addr;
ar.StringPtr(key, cptr);
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
}
//==========================================================================
//
// PSound :: ReadValue
//
//==========================================================================
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
bool PSound::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
{
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
const char *cptr;
ar.StringPtr(key, cptr);
if (cptr == nullptr)
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
return false;
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
}
else
{
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
*(FSoundID *)addr = FSoundID(cptr);
return true;
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
/* PColor *****************************************************************/
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PColor, false, false, false)
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PColor Default Constructor
//
//==========================================================================
PColor::PColor()
: PInt(sizeof(PalEntry), true)
{
- 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
mDescriptiveName = "Color";
Normalize line endings
2016-03-01 15:47:10 +00:00
assert(sizeof(PalEntry) == __alignof(PalEntry));
}
/* PStatePointer **********************************************************/
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PStatePointer, false, false, false)
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PStatePointer Default Constructor
//
//==========================================================================
PStatePointer::PStatePointer()
: PBasicType(sizeof(FState *), __alignof(FState *))
{
- 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
mDescriptiveName = "State";
- 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
storeOp = OP_SP;
loadOp = OP_LP;
moveOp = OP_MOVEA;
RegType = REGT_POINTER;
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
//==========================================================================
//
// PStatePointer :: WriteValue
//
//==========================================================================
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
void PStatePointer::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
{
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
ar(key, *(FState **)addr);
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
}
//==========================================================================
//
// PStatePointer :: ReadValue
//
//==========================================================================
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
bool PStatePointer::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
{
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
bool res = false;
::Serialize(ar, key, *(FState **)addr, nullptr, &res);
return res;
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
/* PPointer ***************************************************************/
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PPointer, false, true, false)
Separate the pointer list from the implement macro
2016-11-05 16:08:54 +00:00
IMPLEMENT_POINTERS_START(PPointer)
IMPLEMENT_POINTER(PointedType)
IMPLEMENT_POINTERS_END
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PPointer - Default Constructor
//
//==========================================================================
PPointer::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
: PBasicType(sizeof(void *), __alignof(void *)), PointedType(NULL), IsConst(false)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- preparations for null pointer support. - add pointer support to FxAssign.
2016-10-21 17:18:39 +00:00
mDescriptiveName = "NullPointer";
- 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
SetOps();
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
// PPointer - Parameterized Constructor
//
//==========================================================================
- 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::PPointer(PType *pointsat, bool isconst)
: PBasicType(sizeof(void *), __alignof(void *)), PointedType(pointsat), IsConst(isconst)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- 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
mDescriptiveName.Format("Pointer<%s%s>", pointsat->DescriptiveName(), isconst? "readonly " : "");
- 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
SetOps();
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
// PPointer :: GetStoreOp
//
//==========================================================================
- 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 PPointer::SetOps()
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
storeOp = OP_SP;
loadOp = (PointedType && PointedType->IsKindOf(RUNTIME_CLASS(PClass))) ? OP_LO : OP_LP;
moveOp = OP_MOVEA;
RegType = REGT_POINTER;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
// PPointer :: IsMatch
//
//==========================================================================
bool PPointer::IsMatch(intptr_t id1, intptr_t id2) const
{
- added an accessor to the actor defaults. This might have been possible with less work using a function but that would have necessitated some type casts when using it on subclasses. - scriptified A_BarrelDestroy to test the above.
2016-11-05 16:14:16 +00:00
assert(id2 == 0 || id2 == 1);
Normalize line endings
2016-03-01 15:47:10 +00:00
PType *pointat = (PType *)id1;
- added an accessor to the actor defaults. This might have been possible with less work using a function but that would have necessitated some type casts when using it on subclasses. - scriptified A_BarrelDestroy to test the above.
2016-11-05 16:14:16 +00:00
return pointat == PointedType && (!!id2) == IsConst;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
// PPointer :: GetTypeIDs
//
//==========================================================================
void PPointer::GetTypeIDs(intptr_t &id1, intptr_t &id2) const
{
id1 = (intptr_t)PointedType;
id2 = 0;
}
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
//==========================================================================
//
// PPointer :: WriteValue
//
//==========================================================================
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
void PPointer::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
{
if (PointedType->IsKindOf(RUNTIME_CLASS(PClass)))
{
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
ar(key, *(DObject **)addr);
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
}
else
{
assert(0 && "Pointer points to a type we don't handle");
I_Error("Attempt to save pointer to unhandled type");
}
}
//==========================================================================
//
// PPointer :: ReadValue
//
//==========================================================================
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
bool PPointer::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
{
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
if (PointedType->IsKindOf(RUNTIME_CLASS(PClass)))
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
bool res = false;
::Serialize(ar, key, *(DObject **)addr, nullptr, &res);
return res;
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
}
return false;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// NewPointer
//
// Returns a PPointer to an object of the specified 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)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
size_t bucket;
- 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
PType *ptype = TypeTable.FindType(RUNTIME_CLASS(PPointer), (intptr_t)type, isconst ? 1 : 0, &bucket);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (ptype == NULL)
{
ptype = new PPointer(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
TypeTable.AddType(ptype, RUNTIME_CLASS(PPointer), (intptr_t)type, isconst ? 1 : 0, bucket);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
return static_cast<PPointer *>(ptype);
}
/* PClassPointer **********************************************************/
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PClassPointer, false, true, false)
Separate the pointer list from the implement macro
2016-11-05 16:08:54 +00:00
IMPLEMENT_POINTERS_START(PClassPointer)
IMPLEMENT_POINTER(ClassRestriction)
IMPLEMENT_POINTERS_END
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PClassPointer - Default Constructor
//
//==========================================================================
PClassPointer::PClassPointer()
: PPointer(RUNTIME_CLASS(PClass)), ClassRestriction(NULL)
{
- 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
mDescriptiveName = "ClassPointer";
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
// PClassPointer - Parameterized Constructor
//
//==========================================================================
PClassPointer::PClassPointer(PClass *restrict)
: PPointer(RUNTIME_CLASS(PClass)), ClassRestriction(restrict)
{
- converted some Heretic stuff to ZScript for testing. - added type casts to the arguments of function calls. - added string constant to state conversion to FxTypeCast.
2016-10-16 20:32:52 +00:00
if (restrict) mDescriptiveName.Format("ClassPointer<%s>", restrict->TypeName.GetChars());
else mDescriptiveName = "ClassPointer";
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
// PClassPointer :: IsMatch
//
//==========================================================================
bool PClassPointer::IsMatch(intptr_t id1, intptr_t id2) const
{
const PType *pointat = (const PType *)id1;
const PClass *classat = (const PClass *)id2;
assert(pointat->IsKindOf(RUNTIME_CLASS(PClass)));
return classat == ClassRestriction;
}
//==========================================================================
//
// PClassPointer :: GetTypeIDs
//
//==========================================================================
void PClassPointer::GetTypeIDs(intptr_t &id1, intptr_t &id2) const
{
assert(PointedType == RUNTIME_CLASS(PClass));
id1 = (intptr_t)PointedType;
id2 = (intptr_t)ClassRestriction;
}
//==========================================================================
//
// NewClassPointer
//
// Returns a PClassPointer for the restricted type.
//
//==========================================================================
PClassPointer *NewClassPointer(PClass *restrict)
{
size_t bucket;
PClassPointer should use its own type as the metatype in the type table - I don't remember why I thought using PPointer as the metatype for PClassPointer would be preferable, but it means that PPointer's MatchID can potentially be called for PClassPointer entries.
2016-03-03 21:09:19 +00:00
PType *ptype = TypeTable.FindType(RUNTIME_CLASS(PClassPointer), (intptr_t)RUNTIME_CLASS(PClass), (intptr_t)restrict, &bucket);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (ptype == NULL)
{
ptype = new PClassPointer(restrict);
PClassPointer should use its own type as the metatype in the type table - I don't remember why I thought using PPointer as the metatype for PClassPointer would be preferable, but it means that PPointer's MatchID can potentially be called for PClassPointer entries.
2016-03-03 21:09:19 +00:00
TypeTable.AddType(ptype, RUNTIME_CLASS(PClassPointer), (intptr_t)RUNTIME_CLASS(PClass), (intptr_t)restrict, bucket);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
return static_cast<PClassPointer *>(ptype);
}
/* PEnum ******************************************************************/
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PEnum, false, true, false)
Separate the pointer list from the implement macro
2016-11-05 16:08:54 +00:00
IMPLEMENT_POINTERS_START(PEnum)
IMPLEMENT_POINTER(ValueType)
IMPLEMENT_POINTERS_END
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PEnum - Default Constructor
//
//==========================================================================
PEnum::PEnum()
: ValueType(NULL)
{
- 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
mDescriptiveName = "Enum";
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
// PEnum - Parameterized Constructor
//
//==========================================================================
- 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::PEnum(FName name, PTypeBase *outer)
Normalize line endings
2016-03-01 15:47:10 +00:00
: PNamedType(name, outer), ValueType(NULL)
{
- 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
mDescriptiveName.Format("Enum<%s>", name.GetChars());
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
// NewEnum
//
// Returns a PEnum for the given name and container, making sure not to
// create duplicates.
//
//==========================================================================
- 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)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
size_t bucket;
PType *etype = TypeTable.FindType(RUNTIME_CLASS(PEnum), (intptr_t)outer, (intptr_t)name, &bucket);
if (etype == NULL)
{
etype = new PEnum(name, outer);
TypeTable.AddType(etype, RUNTIME_CLASS(PEnum), (intptr_t)outer, (intptr_t)name, bucket);
}
return static_cast<PEnum *>(etype);
}
/* PArray *****************************************************************/
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PArray, false, true, false)
Separate the pointer list from the implement macro
2016-11-05 16:08:54 +00:00
IMPLEMENT_POINTERS_START(PArray)
IMPLEMENT_POINTER(ElementType)
IMPLEMENT_POINTERS_END
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PArray - Default Constructor
//
//==========================================================================
PArray::PArray()
: ElementType(NULL), ElementCount(0)
{
- 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
mDescriptiveName = "Array";
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
// PArray - Parameterized Constructor
//
//==========================================================================
PArray::PArray(PType *etype, unsigned int ecount)
: ElementType(etype), ElementCount(ecount)
{
- 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
mDescriptiveName.Format("Array<%s>[%d]", etype->DescriptiveName(), ecount);
Normalize line endings
2016-03-01 15:47:10 +00:00
Align = etype->Align;
// Since we are concatenating elements together, the element size should
// also be padded to the nearest alignment.
ElementSize = (etype->Size + (etype->Align - 1)) & ~(etype->Align - 1);
Size = ElementSize * ecount;
}
//==========================================================================
//
// PArray :: IsMatch
//
//==========================================================================
bool PArray::IsMatch(intptr_t id1, intptr_t id2) const
{
const PType *elemtype = (const PType *)id1;
unsigned int count = (unsigned int)(intptr_t)id2;
return elemtype == ElementType && count == ElementCount;
}
//==========================================================================
//
// PArray :: GetTypeIDs
//
//==========================================================================
void PArray::GetTypeIDs(intptr_t &id1, intptr_t &id2) const
{
id1 = (intptr_t)ElementType;
id2 = ElementCount;
}
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
//==========================================================================
//
// PArray :: WriteValue
//
//==========================================================================
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
void PArray::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
{
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
if (ar.BeginArray(key))
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
const BYTE *addrb = (const BYTE *)addr;
for (unsigned i = 0; i < ElementCount; ++i)
{
ElementType->WriteValue(ar, nullptr, addrb);
addrb += ElementSize;
}
ar.EndArray();
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
}
}
//==========================================================================
//
// PArray :: ReadValue
//
//==========================================================================
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
bool PArray::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
{
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
if (ar.BeginArray(key))
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
bool readsomething = false;
unsigned count = ar.ArraySize();
unsigned loop = MIN(count, ElementCount);
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
BYTE *addrb = (BYTE *)addr;
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
for(unsigned i=0;i<loop;i++)
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
{
- re-added serialization of treanslations. - removed more dead code.
2016-09-20 17:45:32 +00:00
readsomething |= ElementType->ReadValue(ar, nullptr, addrb);
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
addrb += ElementSize;
}
- re-added serialization of treanslations. - removed more dead code.
2016-09-20 17:45:32 +00:00
if (loop < count)
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 multiple message levels for 'developer' CVAR so that the important stuff won't get drowned in pointless notification spam that's of no use to anyone. - made 'developer' CVAR persist across launches and added some menu entries for it. - added checks for 'developer' to ACS's CheckInventory function.
2016-08-28 07:55:04 +00:00
DPrintf(DMSG_WARNING, "Array on disk (%u) is bigger than in memory (%u)\n",
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
count, ElementCount);
}
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
ar.EndArray();
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
return readsomething;
}
return false;
}
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
//==========================================================================
//
// PArray :: SetDefaultValue
//
//==========================================================================
void PArray::SetDefaultValue(void *base, unsigned offset, TArray<FTypeAndOffset> *special) const
{
for (unsigned i = 0; i < ElementCount; ++i)
{
ElementType->SetDefaultValue(base, offset + i*ElementSize, special);
}
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// NewArray
//
// Returns a PArray for the given type and size, making sure not to create
// duplicates.
//
//==========================================================================
PArray *NewArray(PType *type, unsigned int count)
{
size_t bucket;
PType *atype = TypeTable.FindType(RUNTIME_CLASS(PArray), (intptr_t)type, count, &bucket);
if (atype == NULL)
{
atype = new PArray(type, count);
TypeTable.AddType(atype, RUNTIME_CLASS(PArray), (intptr_t)type, count, bucket);
}
return (PArray *)atype;
}
/* PVector ****************************************************************/
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PVector, false, false, false)
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PVector - Default Constructor
//
//==========================================================================
PVector::PVector()
: PArray(TypeFloat32, 3)
{
- 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
mDescriptiveName = "Vector";
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
// PVector - Parameterized Constructor
//
//==========================================================================
PVector::PVector(unsigned int size)
: PArray(TypeFloat32, size)
{
- 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
mDescriptiveName.Format("Vector<%d>", size);
Normalize line endings
2016-03-01 15:47:10 +00:00
assert(size >= 2 && size <= 4);
}
//==========================================================================
//
// NewVector
//
// Returns a PVector with the given dimension, making sure not to create
// duplicates.
//
//==========================================================================
PVector *NewVector(unsigned int size)
{
size_t bucket;
PType *type = TypeTable.FindType(RUNTIME_CLASS(PVector), (intptr_t)TypeFloat32, size, &bucket);
if (type == NULL)
{
type = new PVector(size);
TypeTable.AddType(type, RUNTIME_CLASS(PVector), (intptr_t)TypeFloat32, size, bucket);
}
return (PVector *)type;
}
/* PDynArray **************************************************************/
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PDynArray, false, true, false)
Separate the pointer list from the implement macro
2016-11-05 16:08:54 +00:00
IMPLEMENT_POINTERS_START(PDynArray)
IMPLEMENT_POINTER(ElementType)
IMPLEMENT_POINTERS_END
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PDynArray - Default Constructor
//
//==========================================================================
PDynArray::PDynArray()
: ElementType(NULL)
{
- 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
mDescriptiveName = "DynArray";
Normalize line endings
2016-03-01 15:47:10 +00:00
Size = sizeof(FArray);
Align = __alignof(FArray);
}
//==========================================================================
//
// PDynArray - Parameterized Constructor
//
//==========================================================================
PDynArray::PDynArray(PType *etype)
: ElementType(etype)
{
- 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
mDescriptiveName.Format("DynArray<%s>", etype->DescriptiveName());
Normalize line endings
2016-03-01 15:47:10 +00:00
Size = sizeof(FArray);
Align = __alignof(FArray);
}
//==========================================================================
//
// PDynArray :: IsMatch
//
//==========================================================================
bool PDynArray::IsMatch(intptr_t id1, intptr_t id2) const
{
assert(id2 == 0);
const PType *elemtype = (const PType *)id1;
return elemtype == ElementType;
}
//==========================================================================
//
// PDynArray :: GetTypeIDs
//
//==========================================================================
void PDynArray::GetTypeIDs(intptr_t &id1, intptr_t &id2) const
{
id1 = (intptr_t)ElementType;
id2 = 0;
}
//==========================================================================
//
// NewDynArray
//
// Creates a new DynArray of the given type, making sure not to create a
// duplicate.
//
//==========================================================================
PDynArray *NewDynArray(PType *type)
{
size_t bucket;
PType *atype = TypeTable.FindType(RUNTIME_CLASS(PDynArray), (intptr_t)type, 0, &bucket);
if (atype == NULL)
{
atype = new PDynArray(type);
TypeTable.AddType(atype, RUNTIME_CLASS(PDynArray), (intptr_t)type, 0, bucket);
}
return (PDynArray *)atype;
}
/* PMap *******************************************************************/
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PMap, false, true, false)
Separate the pointer list from the implement macro
2016-11-05 16:08:54 +00:00
IMPLEMENT_POINTERS_START(PMap)
IMPLEMENT_POINTER(KeyType)
IMPLEMENT_POINTER(ValueType)
IMPLEMENT_POINTERS_END
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PMap - Default Constructor
//
//==========================================================================
PMap::PMap()
: KeyType(NULL), ValueType(NULL)
{
- 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
mDescriptiveName = "Map";
Normalize line endings
2016-03-01 15:47:10 +00:00
Size = sizeof(FMap);
Align = __alignof(FMap);
}
//==========================================================================
//
// PMap - Parameterized Constructor
//
//==========================================================================
PMap::PMap(PType *keytype, PType *valtype)
: KeyType(keytype), ValueType(valtype)
{
- 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
mDescriptiveName.Format("Map<%s, %s>", keytype->DescriptiveName(), valtype->DescriptiveName());
Normalize line endings
2016-03-01 15:47:10 +00:00
Size = sizeof(FMap);
Align = __alignof(FMap);
}
//==========================================================================
//
// PMap :: IsMatch
//
//==========================================================================
bool PMap::IsMatch(intptr_t id1, intptr_t id2) const
{
const PType *keyty = (const PType *)id1;
const PType *valty = (const PType *)id2;
return keyty == KeyType && valty == ValueType;
}
//==========================================================================
//
// PMap :: GetTypeIDs
//
//==========================================================================
void PMap::GetTypeIDs(intptr_t &id1, intptr_t &id2) const
{
id1 = (intptr_t)KeyType;
id2 = (intptr_t)ValueType;
}
//==========================================================================
//
// NewMap
//
// Returns a PMap for the given key and value types, ensuring not to create
// duplicates.
//
//==========================================================================
PMap *NewMap(PType *keytype, PType *valuetype)
{
size_t bucket;
PType *maptype = TypeTable.FindType(RUNTIME_CLASS(PMap), (intptr_t)keytype, (intptr_t)valuetype, &bucket);
if (maptype == NULL)
{
maptype = new PMap(keytype, valuetype);
TypeTable.AddType(maptype, RUNTIME_CLASS(PMap), (intptr_t)keytype, (intptr_t)valuetype, bucket);
}
return (PMap *)maptype;
}
/* PStruct ****************************************************************/
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PStruct, false, false, false)
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PStruct - Default Constructor
//
//==========================================================================
PStruct::PStruct()
{
- 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
mDescriptiveName = "Struct";
- 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
Size = 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
// PStruct - Parameterized Constructor
//
//==========================================================================
- 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::PStruct(FName name, PTypeBase *outer)
Normalize line endings
2016-03-01 15:47:10 +00:00
: PNamedType(name, outer)
{
- 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
mDescriptiveName.Format("Struct<%s>", name.GetChars());
- 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
Size = 0;
- 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
HasNativeFields = false;
Normalize line endings
2016-03-01 15:47:10 +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
//==========================================================================
//
// PStruct :: SetDefaultValue
//
//==========================================================================
void PStruct::SetDefaultValue(void *base, unsigned offset, TArray<FTypeAndOffset> *special) const
{
for (const PField *field : Fields)
{
if (!(field->Flags & VARF_Native))
{
- 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
field->Type->SetDefaultValue(base, unsigned(offset + field->Offset), special);
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
}
}
}
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
//==========================================================================
//
// PStruct :: WriteValue
//
//==========================================================================
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
void PStruct::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
{
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
if (ar.BeginObject(key))
{
WriteFields(ar, addr, Fields);
ar.EndObject();
}
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
}
//==========================================================================
//
// PStruct :: ReadValue
//
//==========================================================================
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
bool PStruct::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
{
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
if (ar.BeginObject(key))
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
bool ret = ReadFields(ar, addr);
ar.EndObject();
return ret;
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
return false;
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
}
//==========================================================================
//
// PStruct :: WriteFields STATIC
//
//==========================================================================
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
void PStruct::WriteFields(FSerializer &ar, const void *addr, const TArray<PField *> &fields)
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
{
for (unsigned i = 0; i < fields.Size(); ++i)
{
const PField *field = fields[i];
// Skip fields with native serialization
if (!(field->Flags & VARF_Native))
{
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
field->Type->WriteValue(ar, field->SymbolName.GetChars(), (const BYTE *)addr + field->Offset);
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
}
}
}
//==========================================================================
//
// PStruct :: ReadFields
//
//==========================================================================
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
bool PStruct::ReadFields(FSerializer &ar, 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
{
bool readsomething = false;
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
bool foundsomething = false;
const char *label;
while ((label = ar.GetKey()))
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
foundsomething = true;
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 PSymbol *sym = Symbols.FindSymbol(FName(label, true), true);
if (sym == NULL)
{
- added multiple message levels for 'developer' CVAR so that the important stuff won't get drowned in pointless notification spam that's of no use to anyone. - made 'developer' CVAR persist across launches and added some menu entries for it. - added checks for 'developer' to ACS's CheckInventory function.
2016-08-28 07:55:04 +00:00
DPrintf(DMSG_ERROR, "Cannot find field %s in %s\n",
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
label, TypeName.GetChars());
}
else if (!sym->IsKindOf(RUNTIME_CLASS(PField)))
{
- added multiple message levels for 'developer' CVAR so that the important stuff won't get drowned in pointless notification spam that's of no use to anyone. - made 'developer' CVAR persist across launches and added some menu entries for it. - added checks for 'developer' to ACS's CheckInventory function.
2016-08-28 07:55:04 +00:00
DPrintf(DMSG_ERROR, "Symbol %s in %s is not a field\n",
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
label, TypeName.GetChars());
}
else
{
- removed the sequential processing of JSON objects because the benefit is too small. After testing with a savegame on ZDCMP2 which is probably the largest map in existence, timing both methods resulted in a speed difference of less than 40 ms (70 vs 110 ms for reading all sectory, linedefs, sidedefs and objects). This compares to an overall restoration time, including reloading the level, precaching all textures and setting everything up, of approx. 1.2 s, meaning an increase of 3% of the entire reloading time. That's simply not worth all the negative side effects that may happen with a method that highly depends on proper code construction. On the other hand, using random access means that a savegame version change is only needed now when the semantics of a field change, but not if some get added or deleted. - do not I_Error out in the serializer unless caused by a programming error. It is better to let the serializer finish, collect all the errors and I_Error out when the game is known to be in a stable enough state to allow unwinding.
2016-09-23 12:04:05 +00:00
readsomething |= static_cast<const PField *>(sym)->Type->ReadValue(ar, nullptr,
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
(BYTE *)addr + static_cast<const PField *>(sym)->Offset);
}
}
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
return readsomething || !foundsomething;
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
//==========================================================================
//
// PStruct :: AddField
//
// Appends a new field to the end of a struct. Returns either the new field
// or NULL if a symbol by that name already exists.
//
//==========================================================================
PField *PStruct::AddField(FName name, PType *type, DWORD flags)
{
- 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
PField *field = new PField(name, type, flags);
Normalize line endings
2016-03-01 15:47:10 +00:00
// The new field is added to the end of this struct, alignment permitting.
field->Offset = (Size + (type->Align - 1)) & ~(type->Align - 1);
// Enlarge this struct to enclose the new field.
- 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
Size = unsigned(field->Offset + type->Size);
Normalize line endings
2016-03-01 15:47:10 +00:00
// This struct's alignment is the same as the largest alignment of any of
// its fields.
Align = MAX(Align, type->Align);
if (Symbols.AddSymbol(field) == NULL)
{ // name is already in use
delete field;
return NULL;
}
Fields.Push(field);
return field;
}
- 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
//==========================================================================
//
// PStruct :: AddField
//
// Appends a new native field to the struct. Returns either the new field
// or NULL if a symbol by that name already exists.
//
//==========================================================================
PField *PStruct::AddNativeField(FName name, PType *type, size_t address, DWORD flags, int bitvalue)
{
PField *field = new PField(name, type, flags|VARF_Native, address, bitvalue);
if (Symbols.AddSymbol(field) == nullptr)
{ // name is already in use
- do not delete duplicate PFields - they are better be destroyed and left to the GC. - removed two duplicate entries to the flag table.
2016-11-04 14:21:45 +00:00
field->Destroy();
- 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
return nullptr;
}
Fields.Push(field);
HasNativeFields = true;
return field;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PStruct :: PropagateMark
//
//==========================================================================
size_t PStruct::PropagateMark()
{
GC::MarkArray(Fields);
return Fields.Size() * sizeof(void*) + Super::PropagateMark();
}
//==========================================================================
//
// NewStruct
// Returns a PStruct for the given name and container, making sure not to
// create duplicates.
//
//==========================================================================
- 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 *NewStruct(FName name, PTypeBase *outer)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
size_t bucket;
PType *stype = TypeTable.FindType(RUNTIME_CLASS(PStruct), (intptr_t)outer, (intptr_t)name, &bucket);
if (stype == NULL)
{
stype = new PStruct(name, outer);
TypeTable.AddType(stype, RUNTIME_CLASS(PStruct), (intptr_t)outer, (intptr_t)name, bucket);
}
return static_cast<PStruct *>(stype);
}
/* PField *****************************************************************/
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PField, false, false, false)
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PField - Default Constructor
//
//==========================================================================
PField::PField()
: PSymbol(NAME_None), Offset(0), Type(NULL), Flags(0)
{
}
- moved declaration of native fields into the respective class definitions. This bypasses a declaration in the script in favor of a simpler implementation. In order to work it is always necessary to have an offset table to map the variables to, but doing it fully on the native side only requires adding the type to the declaration.
2016-11-03 23:19:36 +00:00
- implement flag variables with the VM's sbit and lbit instructions. - synthesize PField entries from the flag list for AActor. This intentionally excludes the bounce flags for now. - allow deprecated flags that do not call the deprecated flag handler. - disallow constructs like (a = b) = c by not allowing an address request on an assignment operation. - restrict modify/assign on boolean variables to the bit operators. Everything else needs to promote the result to an integer to make sense so it should be disallowed.
2016-10-24 15:18:20 +00:00
PField::PField(FName name, PType *type, DWORD flags, size_t offset, int bitvalue)
- 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
: PSymbol(name), Offset(offset), Type(type), Flags(flags)
- implement flag variables with the VM's sbit and lbit instructions. - synthesize PField entries from the flag list for AActor. This intentionally excludes the bounce flags for now. - allow deprecated flags that do not call the deprecated flag handler. - disallow constructs like (a = b) = c by not allowing an address request on an assignment operation. - restrict modify/assign on boolean variables to the bit operators. Everything else needs to promote the result to an integer to make sense so it should be disallowed.
2016-10-24 15:18:20 +00:00
{
BitValue = bitvalue;
- moved declaration of native fields into the respective class definitions. This bypasses a declaration in the script in favor of a simpler implementation. In order to work it is always necessary to have an offset table to map the variables to, but doing it fully on the native side only requires adding the type to the declaration.
2016-11-03 23:19:36 +00:00
if (bitvalue != -1)
- implement flag variables with the VM's sbit and lbit instructions. - synthesize PField entries from the flag list for AActor. This intentionally excludes the bounce flags for now. - allow deprecated flags that do not call the deprecated flag handler. - disallow constructs like (a = b) = c by not allowing an address request on an assignment operation. - restrict modify/assign on boolean variables to the bit operators. Everything else needs to promote the result to an integer to make sense so it should be disallowed.
2016-10-24 15:18:20 +00:00
{
- moved declaration of native fields into the respective class definitions. This bypasses a declaration in the script in favor of a simpler implementation. In order to work it is always necessary to have an offset table to map the variables to, but doing it fully on the native side only requires adding the type to the declaration.
2016-11-03 23:19:36 +00:00
BitValue = 0;
unsigned val = bitvalue;
while ((val >>= 1)) BitValue++;
if (type->IsA(RUNTIME_CLASS(PInt)) && unsigned(BitValue) < 8u * type->Size)
- implement flag variables with the VM's sbit and lbit instructions. - synthesize PField entries from the flag list for AActor. This intentionally excludes the bounce flags for now. - allow deprecated flags that do not call the deprecated flag handler. - disallow constructs like (a = b) = c by not allowing an address request on an assignment operation. - restrict modify/assign on boolean variables to the bit operators. Everything else needs to promote the result to an integer to make sense so it should be disallowed.
2016-10-24 15:18:20 +00:00
{
// map to the single bytes in the actual variable. The internal bit instructions operate on 8 bit values.
#ifndef __BIG_ENDIAN__
Offset += BitValue / 8;
#else
Offset += type->Size - 1 - BitValue / 8;
#endif
BitValue &= 7;
Type = TypeBool;
}
else
{
// Just abort. Bit fields should only be defined internally.
I_FatalError("Trying to create an invalid bit field element: %s", name.GetChars());
}
}
}
Normalize line endings
2016-03-01 15:47:10 +00:00
/* PPrototype *************************************************************/
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PPrototype, false, false, false)
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PPrototype - Default Constructor
//
//==========================================================================
PPrototype::PPrototype()
{
}
//==========================================================================
//
// PPrototype - Parameterized Constructor
//
//==========================================================================
PPrototype::PPrototype(const TArray<PType *> &rettypes, const TArray<PType *> &argtypes)
: ArgumentTypes(argtypes), ReturnTypes(rettypes)
{
}
//==========================================================================
//
// PPrototype :: IsMatch
//
//==========================================================================
bool PPrototype::IsMatch(intptr_t id1, intptr_t id2) const
{
const TArray<PType *> *args = (const TArray<PType *> *)id1;
const TArray<PType *> *rets = (const TArray<PType *> *)id2;
return *args == ArgumentTypes && *rets == ReturnTypes;
}
//==========================================================================
//
// PPrototype :: GetTypeIDs
//
//==========================================================================
void PPrototype::GetTypeIDs(intptr_t &id1, intptr_t &id2) const
{
id1 = (intptr_t)&ArgumentTypes;
id2 = (intptr_t)&ReturnTypes;
}
//==========================================================================
//
// PPrototype :: PropagateMark
//
//==========================================================================
size_t PPrototype::PropagateMark()
{
GC::MarkArray(ArgumentTypes);
GC::MarkArray(ReturnTypes);
return (ArgumentTypes.Size() + ReturnTypes.Size()) * sizeof(void*) +
Super::PropagateMark();
}
//==========================================================================
//
// NewPrototype
//
// Returns a PPrototype for the given return and argument types, making sure
// not to create duplicates.
//
//==========================================================================
PPrototype *NewPrototype(const TArray<PType *> &rettypes, const TArray<PType *> &argtypes)
{
size_t bucket;
PType *proto = TypeTable.FindType(RUNTIME_CLASS(PPrototype), (intptr_t)&argtypes, (intptr_t)&rettypes, &bucket);
if (proto == NULL)
{
proto = new PPrototype(rettypes, argtypes);
TypeTable.AddType(proto, RUNTIME_CLASS(PPrototype), (intptr_t)&argtypes, (intptr_t)&rettypes, bucket);
}
return static_cast<PPrototype *>(proto);
}
/* PFunction **************************************************************/
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PFunction, false, false, false)
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PFunction :: PropagataMark
//
//==========================================================================
size_t PFunction::PropagateMark()
{
for (unsigned i = 0; i < Variants.Size(); ++i)
{
- give PFunction a bit more information: * explicitly require passing the owning class when creating it. * extract self pointer class when adding a variant. * put the flags on the single variants, we can not fully rule out that they will be 100% identical, if variants ever get allowed.
2016-10-15 13:50:45 +00:00
GC::Mark(Variants[i].Proto);
Normalize line endings
2016-03-01 15:47:10 +00:00
GC::Mark(Variants[i].Implementation);
}
return Variants.Size() * sizeof(Variants[0]) + Super::PropagateMark();
}
//==========================================================================
//
// PFunction :: AddVariant
//
// Adds a new variant for this function. Does not check if a matching
// variant already exists.
//
//==========================================================================
- give PFunction a bit more information: * explicitly require passing the owning class when creating it. * extract self pointer class when adding a variant. * put the flags on the single variants, we can not fully rule out that they will be 100% identical, if variants ever get allowed.
2016-10-15 13:50:45 +00:00
unsigned PFunction::AddVariant(PPrototype *proto, TArray<DWORD> &argflags, TArray<FName> &argnames, VMFunction *impl, int flags)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
Variant variant;
- give PFunction a bit more information: * explicitly require passing the owning class when creating it. * extract self pointer class when adding a variant. * put the flags on the single variants, we can not fully rule out that they will be 100% identical, if variants ever get allowed.
2016-10-15 13:50:45 +00:00
// I do not think we really want to deal with overloading here...
assert(Variants.Size() == 0);
variant.Flags = flags;
- more preparations to compile functions: * Allow PFunction to work without a VMFunction being attached. * The Variant for a function must store the prototype itself instead of relying on the VMFunction it points to. Otherwise it would not be possible to reference a prototype during compilation of the function because it does not exist yet. * Give the variant a list of the function's argument's names, because these are also needed to compile the function. * create an anonymous function symbol when the function gets registered to the builder. At this point we have all the needed information to set it up correctly, but later this is no longer the case. This is the most convenient info to have here because it contains everything that's needed to compile the function in the proper context, so it has to be present when starting compilation. * added some preparations to implement special handling for weapons and custom inventory items, which can run action functions in another actor's context. This part is not active yet but the basics are present in SetImplicitArgs.
2016-10-15 12:36:08 +00:00
variant.Proto = proto;
- tested and fixed FxLocalVariableDeclaration. - create proper variable data from the function prototype instead of assuming that there's just 3 pointers. - added a printable name to VMScriptFunction for error output during gameplay in case something goes wrong.
2016-10-20 14:55:12 +00:00
variant.ArgFlags = std::move(argflags);
variant.ArgNames = std::move(argnames);
Normalize line endings
2016-03-01 15:47:10 +00:00
variant.Implementation = impl;
- more preparations to compile functions: * Allow PFunction to work without a VMFunction being attached. * The Variant for a function must store the prototype itself instead of relying on the VMFunction it points to. Otherwise it would not be possible to reference a prototype during compilation of the function because it does not exist yet. * Give the variant a list of the function's argument's names, because these are also needed to compile the function. * create an anonymous function symbol when the function gets registered to the builder. At this point we have all the needed information to set it up correctly, but later this is no longer the case. This is the most convenient info to have here because it contains everything that's needed to compile the function in the proper context, so it has to be present when starting compilation. * added some preparations to implement special handling for weapons and custom inventory items, which can run action functions in another actor's context. This part is not active yet but the basics are present in SetImplicitArgs.
2016-10-15 12:36:08 +00:00
if (impl != nullptr) impl->Proto = proto;
- give PFunction a bit more information: * explicitly require passing the owning class when creating it. * extract self pointer class when adding a variant. * put the flags on the single variants, we can not fully rule out that they will be 100% identical, if variants ever get allowed.
2016-10-15 13:50:45 +00:00
// SelfClass can differ from OwningClass, but this is variant-dependent.
// Unlike the owner there can be cases where different variants can have different SelfClasses.
// (Of course only if this ever gets enabled...)
if (flags & VARF_Method)
{
assert(proto->ArgumentTypes.Size() > 0);
- pass the current function to the compile context instead of just the containing class.
2016-10-15 15:40:27 +00:00
auto selftypeptr = dyn_cast<PPointer>(proto->ArgumentTypes[0]);
assert(selftypeptr != nullptr);
variant.SelfClass = dyn_cast<PClass>(selftypeptr->PointedType);
- give PFunction a bit more information: * explicitly require passing the owning class when creating it. * extract self pointer class when adding a variant. * put the flags on the single variants, we can not fully rule out that they will be 100% identical, if variants ever get allowed.
2016-10-15 13:50:45 +00:00
assert(variant.SelfClass != nullptr);
}
Normalize line endings
2016-03-01 15:47:10 +00:00
return Variants.Push(variant);
}
/* PClass *****************************************************************/
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PClass, false, true, false)
Separate the pointer list from the implement macro
2016-11-05 16:08:54 +00:00
IMPLEMENT_POINTERS_START(PClass)
IMPLEMENT_POINTER(ParentClass)
IMPLEMENT_POINTERS_END
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
//==========================================================================
//
// PClass :: WriteValue
//
// Similar to PStruct's version, except it also needs to traverse parent
// classes.
//
//==========================================================================
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
static void RecurseWriteFields(const PClass *type, FSerializer &ar, const void *addr)
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
{
if (type != NULL)
{
RecurseWriteFields(type->ParentClass, ar, addr);
// Don't write this part if it has no non-native variables
for (unsigned i = 0; i < type->Fields.Size(); ++i)
{
if (!(type->Fields[i]->Flags & VARF_Native))
{
// Tag this section with the class it came from in case
// a more-derived class has variables that shadow a less-
// derived class. Whether or not that is a language feature
// that will actually be allowed remains to be seen.
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
FString key;
key.Format("class:%s", type->TypeName.GetChars());
if (ar.BeginObject(key.GetChars()))
{
PStruct::WriteFields(ar, addr, type->Fields);
ar.EndObject();
}
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
break;
}
}
}
}
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
void PClass::WriteValue(FSerializer &ar, const char *key,const void *addr) const
{
if (ar.BeginObject(key))
{
RecurseWriteFields(this, ar, addr);
ar.EndObject();
}
}
// Same as WriteValue, but does not create a new object in the serializer
// This is so that user variables do not contain unnecessary subblocks.
void PClass::WriteAllFields(FSerializer &ar, 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
{
RecurseWriteFields(this, ar, addr);
}
//==========================================================================
//
// PClass :: ReadValue
//
//==========================================================================
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
bool PClass::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
{
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
if (ar.BeginObject(key))
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
bool ret = ReadAllFields(ar, addr);
ar.EndObject();
return ret;
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
return true;
}
bool PClass::ReadAllFields(FSerializer &ar, void *addr) const
{
bool readsomething = false;
bool foundsomething = false;
const char *key;
- removed the sequential processing of JSON objects because the benefit is too small. After testing with a savegame on ZDCMP2 which is probably the largest map in existence, timing both methods resulted in a speed difference of less than 40 ms (70 vs 110 ms for reading all sectory, linedefs, sidedefs and objects). This compares to an overall restoration time, including reloading the level, precaching all textures and setting everything up, of approx. 1.2 s, meaning an increase of 3% of the entire reloading time. That's simply not worth all the negative side effects that may happen with a method that highly depends on proper code construction. On the other hand, using random access means that a savegame version change is only needed now when the semantics of a field change, but not if some get added or deleted. - do not I_Error out in the serializer unless caused by a programming error. It is better to let the serializer finish, collect all the errors and I_Error out when the game is known to be in a stable enough state to allow unwinding.
2016-09-23 12:04:05 +00:00
key = ar.GetKey();
if (strcmp(key, "classtype"))
{
// this does not represent a DObject
Printf(TEXTCOLOR_RED "trying to read user variables but got a non-object (first key is '%s')", key);
ar.mErrors++;
return false;
}
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
while ((key = ar.GetKey()))
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
if (strncmp(key, "class:", 6))
{
- removed the sequential processing of JSON objects because the benefit is too small. After testing with a savegame on ZDCMP2 which is probably the largest map in existence, timing both methods resulted in a speed difference of less than 40 ms (70 vs 110 ms for reading all sectory, linedefs, sidedefs and objects). This compares to an overall restoration time, including reloading the level, precaching all textures and setting everything up, of approx. 1.2 s, meaning an increase of 3% of the entire reloading time. That's simply not worth all the negative side effects that may happen with a method that highly depends on proper code construction. On the other hand, using random access means that a savegame version change is only needed now when the semantics of a field change, but not if some get added or deleted. - do not I_Error out in the serializer unless caused by a programming error. It is better to let the serializer finish, collect all the errors and I_Error out when the game is known to be in a stable enough state to allow unwinding.
2016-09-23 12:04:05 +00:00
// We have read all user variable blocks.
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
break;
}
foundsomething = true;
PClass *type = PClass::FindClass(key + 6);
if (type != nullptr)
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
{
// Only read it if the type is related to this one.
const PClass *parent;
for (parent = this; parent != NULL; parent = parent->ParentClass)
{
if (parent == type)
{
break;
}
}
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
if (parent != nullptr)
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
{
- removed the sequential processing of JSON objects because the benefit is too small. After testing with a savegame on ZDCMP2 which is probably the largest map in existence, timing both methods resulted in a speed difference of less than 40 ms (70 vs 110 ms for reading all sectory, linedefs, sidedefs and objects). This compares to an overall restoration time, including reloading the level, precaching all textures and setting everything up, of approx. 1.2 s, meaning an increase of 3% of the entire reloading time. That's simply not worth all the negative side effects that may happen with a method that highly depends on proper code construction. On the other hand, using random access means that a savegame version change is only needed now when the semantics of a field change, but not if some get added or deleted. - do not I_Error out in the serializer unless caused by a programming error. It is better to let the serializer finish, collect all the errors and I_Error out when the game is known to be in a stable enough state to allow unwinding.
2016-09-23 12:04:05 +00:00
if (ar.BeginObject(nullptr))
{
readsomething |= type->ReadFields(ar, addr);
ar.EndObject();
}
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
}
else
{
- added multiple message levels for 'developer' CVAR so that the important stuff won't get drowned in pointless notification spam that's of no use to anyone. - made 'developer' CVAR persist across launches and added some menu entries for it. - added checks for 'developer' to ACS's CheckInventory function.
2016-08-28 07:55:04 +00:00
DPrintf(DMSG_ERROR, "Unknown superclass %s of class %s\n",
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
type->TypeName.GetChars(), TypeName.GetChars());
}
}
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
else
{
DPrintf(DMSG_ERROR, "Unknown superclass %s of class %s\n",
key+6, TypeName.GetChars());
}
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
return readsomething || !foundsomething;
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
//==========================================================================
//
// cregcmp
//
// Sorter to keep built-in types in a deterministic order. (Needed?)
//
//==========================================================================
- removed STACK_ARGS. The only reason this even existed was that ZDoom's original VC projects used __fastcall. The CMake generated project do not, they stick to __cdecl. Since no performance gain can be seen by using __fastcall the best course of action is to just remove all traces of it from the source and forget that it ever existed.
2016-04-11 08:46:30 +00:00
static int cregcmp (const void *a, const void *b) NO_SANITIZE
Normalize line endings
2016-03-01 15:47:10 +00:00
{
const PClass *class1 = *(const PClass **)a;
const PClass *class2 = *(const PClass **)b;
return strcmp(class1->TypeName, class2->TypeName);
}
//==========================================================================
//
// PClass :: StaticInit STATIC
//
// Creates class metadata for all built-in types.
//
//==========================================================================
void PClass::StaticInit ()
{
atterm (StaticShutdown);
StaticBootstrap();
FAutoSegIterator probe(CRegHead, CRegTail);
while (*++probe != NULL)
{
((ClassReg *)*probe)->RegisterClass ();
}
// Keep built-in classes in consistant order. I did this before, though
// I'm not sure if this is really necessary to maintain any sort of sync.
qsort(&AllClasses[0], AllClasses.Size(), sizeof(AllClasses[0]), cregcmp);
- 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
// Set all symbol table relations here so that they are valid right from the start.
for (auto c : AllClasses)
{
if (c->ParentClass != nullptr)
{
c->Symbols.SetParentTable(&c->ParentClass->Symbols);
}
}
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
// PClass :: StaticShutdown STATIC
//
// Frees FlatPointers belonging to all classes. Only really needed to avoid
// memory leak warnings at exit.
//
//==========================================================================
void PClass::StaticShutdown ()
{
TArray<size_t *> uniqueFPs(64);
unsigned int i, j;
FS_Close(); // this must be done before the classes get deleted.
for (i = 0; i < PClass::AllClasses.Size(); ++i)
{
PClass *type = PClass::AllClasses[i];
PClass::AllClasses[i] = NULL;
if (type->FlatPointers != &TheEnd && type->FlatPointers != type->Pointers)
{
// FlatPointers are shared by many classes, so we must check for
// duplicates and only delete those that are unique.
for (j = 0; j < uniqueFPs.Size(); ++j)
{
if (type->FlatPointers == uniqueFPs[j])
{
break;
}
}
if (j == uniqueFPs.Size())
{
uniqueFPs.Push(const_cast<size_t *>(type->FlatPointers));
}
}
}
for (i = 0; i < uniqueFPs.Size(); ++i)
{
delete[] uniqueFPs[i];
}
TypeTable.Clear();
bShutdown = true;
AllClasses.Clear();
PClassActor::AllActorClasses.Clear();
FAutoSegIterator probe(CRegHead, CRegTail);
while (*++probe != NULL)
{
((ClassReg *)*probe)->MyClass = NULL;
}
}
//==========================================================================
//
// PClass :: StaticBootstrap STATIC
//
// PClass and PClassClass have intermingling dependencies on their
// definitions. To sort this out, we explicitly define them before
// proceeding with the RegisterClass loop in StaticInit().
//
//==========================================================================
void PClass::StaticBootstrap()
{
PClassClass *clscls = new PClassClass;
PClassClass::RegistrationInfo.SetupClass(clscls);
PClassClass *cls = new PClassClass;
PClass::RegistrationInfo.SetupClass(cls);
// The PClassClass constructor initialized these to NULL, because the
// PClass metadata had not been created yet. Now it has, so we know what
// they should be and can insert them into the type table successfully.
clscls->TypeTableType = cls;
cls->TypeTableType = cls;
clscls->InsertIntoHash();
cls->InsertIntoHash();
// Create parent objects before we go so that these definitions are complete.
clscls->ParentClass = PClassType::RegistrationInfo.ParentType->RegisterClass();
cls->ParentClass = PClass::RegistrationInfo.ParentType->RegisterClass();
}
//==========================================================================
//
// PClass Constructor
//
//==========================================================================
PClass::PClass()
{
Size = sizeof(DObject);
ParentClass = NULL;
Pointers = NULL;
FlatPointers = NULL;
HashNext = NULL;
Defaults = NULL;
bRuntimeClass = false;
- 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
bExported = false;
Normalize line endings
2016-03-01 15:47:10 +00:00
ConstructNative = NULL;
- 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
mDescriptiveName = "Class";
Normalize line endings
2016-03-01 15:47:10 +00:00
PClass::AllClasses.Push(this);
}
//==========================================================================
//
// PClass Destructor
//
//==========================================================================
PClass::~PClass()
{
if (Defaults != NULL)
{
M_Free(Defaults);
Defaults = NULL;
}
}
//==========================================================================
//
// ClassReg :: RegisterClass
//
// Create metadata describing the built-in class this struct is intended
// for.
//
//==========================================================================
PClass *ClassReg::RegisterClass()
{
static ClassReg *const metaclasses[] =
{
&PClass::RegistrationInfo,
&PClassActor::RegistrationInfo,
&PClassInventory::RegistrationInfo,
&PClassAmmo::RegistrationInfo,
&PClassHealth::RegistrationInfo,
&PClassPuzzleItem::RegistrationInfo,
&PClassWeapon::RegistrationInfo,
&PClassPlayerPawn::RegistrationInfo,
&PClassType::RegistrationInfo,
&PClassClass::RegistrationInfo,
&PClassWeaponPiece::RegistrationInfo,
&PClassPowerupGiver::RegistrationInfo,
};
// Skip classes that have already been registered
if (MyClass != NULL)
{
return MyClass;
}
// Add type to list
PClass *cls;
if (MetaClassNum >= countof(metaclasses))
{
assert(0 && "Class registry has an invalid meta class identifier");
}
if (metaclasses[MetaClassNum]->MyClass == NULL)
{ // Make sure the meta class is already registered before registering this one
metaclasses[MetaClassNum]->RegisterClass();
}
cls = static_cast<PClass *>(metaclasses[MetaClassNum]->MyClass->CreateNew());
SetupClass(cls);
cls->InsertIntoHash();
if (ParentType != NULL)
{
cls->ParentClass = ParentType->RegisterClass();
}
return cls;
}
//==========================================================================
//
// ClassReg :: SetupClass
//
// Copies the class-defining parameters from a ClassReg to the Class object
// created for it.
//
//==========================================================================
void ClassReg::SetupClass(PClass *cls)
{
assert(MyClass == NULL);
MyClass = cls;
cls->TypeName = FName(Name+1);
cls->Size = SizeOf;
cls->Pointers = Pointers;
cls->ConstructNative = ConstructNative;
- 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
cls->mDescriptiveName.Format("Class<%s>", cls->TypeName.GetChars());
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
// PClass :: InsertIntoHash
//
// Add class to the type table.
//
//==========================================================================
void PClass::InsertIntoHash ()
{
size_t bucket;
PType *found;
found = TypeTable.FindType(RUNTIME_CLASS(PClass), (intptr_t)Outer, TypeName, &bucket);
if (found != NULL)
{ // This type has already been inserted
- changed handling of duplicate classes in DECORATE. Instead of replacing the original, the second class will get renamed now, using the originating file as an identifier. In the vast majority of cases this should do exactly what is needed: Create an unconflicting second class that can coexist with the original. Unless the class is used by name this should eliminate all problems with this, but so far I haven't seen anything that used them by name. This is choosing the lesser of two evils. While some mod out there may get broken, the old setup meant that the first class of a given name could not be written out to a savegame because it was not retrievable when loading it back.
2016-10-07 13:28:25 +00:00
I_Error("Tried to register class '%s' more than once.\n", TypeName.GetChars());
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
TypeTable.AddType(this, RUNTIME_CLASS(PClass), (intptr_t)Outer, TypeName, bucket);
}
}
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
//==========================================================================
//
// PClass :: FindParentClass
//
// Finds a parent class that matches the given name, including itself.
//
//==========================================================================
const PClass *PClass::FindParentClass(FName name) const
{
for (const PClass *type = this; type != NULL; type = type->ParentClass)
{
if (type->TypeName == name)
{
return type;
}
}
return NULL;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PClass :: FindClass
//
// Find a type, passed the name as a name.
//
//==========================================================================
PClass *PClass::FindClass (FName zaname)
{
if (zaname == NAME_None)
{
return NULL;
}
return static_cast<PClass *>(TypeTable.FindType(RUNTIME_CLASS(PClass),
/*FIXME:Outer*/0, zaname, NULL));
}
//==========================================================================
//
// PClass :: CreateNew
//
// Create a new object that this class represents
//
//==========================================================================
DObject *PClass::CreateNew() const
{
BYTE *mem = (BYTE *)M_Malloc (Size);
assert (mem != NULL);
// Set this object's defaults before constructing it.
if (Defaults != NULL)
memcpy (mem, Defaults, Size);
else
memset (mem, 0, Size);
ConstructNative (mem);
((DObject *)mem)->SetClass (const_cast<PClass *>(this));
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
if (Defaults != NULL)
{
InitializeSpecials(mem);
}
Normalize line endings
2016-03-01 15:47:10 +00:00
return (DObject *)mem;
}
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
//==========================================================================
//
// PClass :: InitializeSpecials
//
Don't waste time looking for variables to (de)init in native classes
2016-04-04 19:57:43 +00:00
// Initialize special fields (e.g. strings) of a newly-created instance.
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 PClass::InitializeSpecials(void *addr) const
{
Don't waste time looking for variables to (de)init in native classes
2016-04-04 19:57:43 +00:00
// Once we reach a native class, we can stop going up the family tree,
// since native classes handle initialization natively.
if (!bRuntimeClass)
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
{
Don't waste time looking for variables to (de)init in native classes
2016-04-04 19:57:43 +00:00
return;
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
}
Don't waste time looking for variables to (de)init in native classes
2016-04-04 19:57:43 +00:00
assert(ParentClass != NULL);
ParentClass->InitializeSpecials(addr);
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
for (auto tao : SpecialInits)
{
- changed PClass:AddField so that it doesn't create defaults if none are present. The ZScript compiler will not create any defaults until after all fields have been added and this function created bad data if it was run on a class without defaults. - added checks for duplicate field names. - moved the tree node symbol tables out of PSymbolTreeNode to the worker data. That symbol is a bad location because it restricts the usefulness of the symbol class which is also needed for variables which use different AST structs. - fixed some memory management issues with the work classes for the compiler that became apparent after moving the symbol tables in there. In several places these were copied around, possibly losing data.
2016-10-09 23:18:47 +00:00
tao.first->InitializeValue((BYTE*)addr + tao.second, Defaults == nullptr? nullptr : Defaults + tao.second);
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
}
}
//==========================================================================
//
// PClass :: DestroySpecials
//
Don't waste time looking for variables to (de)init in native classes
2016-04-04 19:57:43 +00:00
// Destroy special fields (e.g. strings) of an instance that is about to be
// deleted.
//
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 PClass::DestroySpecials(void *addr) const
{
Don't waste time looking for variables to (de)init in native classes
2016-04-04 19:57:43 +00:00
// Once we reach a native class, we can stop going up the family tree,
// since native classes handle deinitialization natively.
if (!bRuntimeClass)
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
{
Don't waste time looking for variables to (de)init in native classes
2016-04-04 19:57:43 +00:00
return;
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
}
Don't waste time looking for variables to (de)init in native classes
2016-04-04 19:57:43 +00:00
assert(ParentClass != NULL);
ParentClass->DestroySpecials(addr);
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
for (auto tao : SpecialInits)
{
tao.first->DestroyValue((BYTE *)addr + tao.second);
}
}
Don't waste time looking for variables to (de)init in native classes
2016-04-04 19:57:43 +00:00
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// PClass :: Derive
//
// Copies inheritable values into the derived class and other miscellaneous setup.
//
//==========================================================================
void PClass::Derive(PClass *newclass)
{
newclass->ParentClass = this;
newclass->ConstructNative = ConstructNative;
// Set up default instance of the new class.
newclass->Defaults = (BYTE *)M_Malloc(newclass->Size);
if (Defaults) memcpy(newclass->Defaults, Defaults, Size);
if (newclass->Size > Size)
{
memset(newclass->Defaults + Size, 0, newclass->Size - Size);
}
newclass->Symbols.SetParentTable(&this->Symbols);
}
//==========================================================================
//
// PClass :: CreateDerivedClass
//
// Create a new class based on an existing class
//
//==========================================================================
PClass *PClass::CreateDerivedClass(FName name, unsigned int size)
{
assert (size >= Size);
PClass *type;
bool notnew;
size_t bucket;
PClass *existclass = static_cast<PClass *>(TypeTable.FindType(RUNTIME_CLASS(PClass), /*FIXME:Outer*/0, name, &bucket));
// This is a placeholder so fill it in
- changed handling of duplicate classes in DECORATE. Instead of replacing the original, the second class will get renamed now, using the originating file as an identifier. In the vast majority of cases this should do exactly what is needed: Create an unconflicting second class that can coexist with the original. Unless the class is used by name this should eliminate all problems with this, but so far I haven't seen anything that used them by name. This is choosing the lesser of two evils. While some mod out there may get broken, the old setup meant that the first class of a given name could not be written out to a savegame because it was not retrievable when loading it back.
2016-10-07 13:28:25 +00:00
if (existclass != nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- changed handling of duplicate classes in DECORATE. Instead of replacing the original, the second class will get renamed now, using the originating file as an identifier. In the vast majority of cases this should do exactly what is needed: Create an unconflicting second class that can coexist with the original. Unless the class is used by name this should eliminate all problems with this, but so far I haven't seen anything that used them by name. This is choosing the lesser of two evils. While some mod out there may get broken, the old setup meant that the first class of a given name could not be written out to a savegame because it was not retrievable when loading it back.
2016-10-07 13:28:25 +00:00
if (existclass->Size == TentativeClass)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- changed handling of duplicate classes in DECORATE. Instead of replacing the original, the second class will get renamed now, using the originating file as an identifier. In the vast majority of cases this should do exactly what is needed: Create an unconflicting second class that can coexist with the original. Unless the class is used by name this should eliminate all problems with this, but so far I haven't seen anything that used them by name. This is choosing the lesser of two evils. While some mod out there may get broken, the old setup meant that the first class of a given name could not be written out to a savegame because it was not retrievable when loading it back.
2016-10-07 13:28:25 +00:00
type = const_cast<PClass*>(existclass);
if (!IsDescendantOf(type->ParentClass))
{
I_Error("%s must inherit from %s but doesn't.", name.GetChars(), type->ParentClass->TypeName.GetChars());
}
DPrintf(DMSG_SPAMMY, "Defining placeholder class %s\n", name.GetChars());
notnew = true;
}
else
{
// a different class with the same name already exists. Let the calling code deal with this.
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
else
{
notnew = false;
}
// Create a new type object of the same type as us. (We may be a derived class of PClass.)
type = static_cast<PClass *>(GetClass()->CreateNew());
type->TypeName = name;
type->Size = size;
type->bRuntimeClass = true;
- 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
type->mDescriptiveName.Format("Class<%s>", name.GetChars());
Normalize line endings
2016-03-01 15:47:10 +00:00
Derive(type);
DeriveData(type);
if (!notnew)
{
type->InsertIntoHash();
}
else
{
PClassActor::AllActorClasses.Pop(); // remove the newly added class from the list
// todo: replace all affected fields
for (unsigned i = 0; i < PClassActor::AllActorClasses.Size(); i++)
{
PClassActor::AllActorClasses[i]->ReplaceClassRef(existclass, type);
if (PClassActor::AllActorClasses[i] == existclass)
PClassActor::AllActorClasses[i] = static_cast<PClassActor*>(type);
}
TypeTable.ReplaceType(type, existclass, bucket);
}
return type;
}
//==========================================================================
Add an AddField() override to PClass that extends the default instance
2016-04-03 21:18:59 +00:00
//
// PClass :: AddField
//
//==========================================================================
PField *PClass::AddField(FName name, PType *type, DWORD flags)
{
unsigned oldsize = Size;
PField *field = Super::AddField(name, type, flags);
- changed PClass:AddField so that it doesn't create defaults if none are present. The ZScript compiler will not create any defaults until after all fields have been added and this function created bad data if it was run on a class without defaults. - added checks for duplicate field names. - moved the tree node symbol tables out of PSymbolTreeNode to the worker data. That symbol is a bad location because it restricts the usefulness of the symbol class which is also needed for variables which use different AST structs. - fixed some memory management issues with the work classes for the compiler that became apparent after moving the symbol tables in there. In several places these were copied around, possibly losing data.
2016-10-09 23:18:47 +00:00
// Only initialize the defaults if they have already been created.
// For ZScript this is not the case, it will first define all fields before
// setting up any defaults for any class.
if (field != nullptr && !(flags & VARF_Native) && Defaults != nullptr)
{
Defaults = (BYTE *)M_Realloc(Defaults, Size);
memset(Defaults + oldsize, 0, Size - oldsize);
- 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
type->SetDefaultValue(Defaults, unsigned(field->Offset), &SpecialInits);
Add an AddField() override to PClass that extends the default instance
2016-04-03 21:18:59 +00:00
}
return field;
}
//==========================================================================
Normalize line endings
2016-03-01 15:47:10 +00:00
//
// PClass :: FindClassTentative
//
// Like FindClass but creates a placeholder if no class is found.
// CreateDerivedClass will automatically fill in the placeholder when the
// actual class is defined.
//
//==========================================================================
PClass *PClass::FindClassTentative(FName name, bool fatal)
{
if (name == NAME_None)
{
return NULL;
}
size_t bucket;
PType *found = TypeTable.FindType(RUNTIME_CLASS(PClass),
/*FIXME:Outer*/0, name, &bucket);
if (found != NULL)
{
return static_cast<PClass *>(found);
}
PClass *type = static_cast<PClass *>(GetClass()->CreateNew());
- added multiple message levels for 'developer' CVAR so that the important stuff won't get drowned in pointless notification spam that's of no use to anyone. - made 'developer' CVAR persist across launches and added some menu entries for it. - added checks for 'developer' to ACS's CheckInventory function.
2016-08-28 07:55:04 +00:00
DPrintf(DMSG_SPAMMY, "Creating placeholder class %s : %s\n", name.GetChars(), TypeName.GetChars());
Normalize line endings
2016-03-01 15:47:10 +00:00
type->TypeName = name;
type->ParentClass = this;
- implemented the Defaults property initializer. This uses the same property and flag tables as DECORATE with a few changes: * it sets the parse mode to strict, so that several DECORATE warnings are now errors. * trying to change a deprecated flag will print a warning. * setting of editor numbers, spawn and conversation ID id not possible. Use MAPINFO to do this. * all subclass flags must use the qualified name now (e.g. +ALWAYSPICKUP will print an error.) * the scriptable Damage property is not yet implemented. This will require a special case with a differently named property in the processing function because in the AST it is no longer possible to distinguish between a damage value and a constant damage function.
2016-10-10 22:56:47 +00:00
type->ConstructNative = ConstructNative;
Normalize line endings
2016-03-01 15:47:10 +00:00
type->Size = TentativeClass;
type->bRuntimeClass = true;
- 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
type->mDescriptiveName.Format("Class<%s>", name.GetChars());
- 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
type->Symbols.SetParentTable(&Symbols);
Normalize line endings
2016-03-01 15:47:10 +00:00
TypeTable.AddType(type, RUNTIME_CLASS(PClass), (intptr_t)type->Outer, name, bucket);
return type;
}
//==========================================================================
//
// PClass :: BuildFlatPointers
//
// Create the FlatPointers array, if it doesn't exist already.
// It comprises all the Pointers from superclasses plus this class's own
// Pointers. If this class does not define any new Pointers, then
// FlatPointers will be set to the same array as the super class.
//
//==========================================================================
void PClass::BuildFlatPointers ()
{
if (FlatPointers != NULL)
{ // Already built: Do nothing.
return;
}
else if (ParentClass == NULL)
{ // No parent: FlatPointers is the same as Pointers.
if (Pointers == NULL)
{ // No pointers: Make FlatPointers a harmless non-NULL.
FlatPointers = &TheEnd;
}
else
{
FlatPointers = Pointers;
}
}
else
{
ParentClass->BuildFlatPointers ();
if (Pointers == NULL)
{ // No new pointers: Just use the same FlatPointers as the parent.
FlatPointers = ParentClass->FlatPointers;
}
else
{ // New pointers: Create a new FlatPointers array and add them.
int numPointers, numSuperPointers;
// Count pointers defined by this class.
for (numPointers = 0; Pointers[numPointers] != ~(size_t)0; numPointers++)
{ }
// Count pointers defined by superclasses.
for (numSuperPointers = 0; ParentClass->FlatPointers[numSuperPointers] != ~(size_t)0; numSuperPointers++)
{ }
// Concatenate them into a new array
size_t *flat = new size_t[numPointers + numSuperPointers + 1];
if (numSuperPointers > 0)
{
memcpy (flat, ParentClass->FlatPointers, sizeof(size_t)*numSuperPointers);
}
memcpy (flat + numSuperPointers, Pointers, sizeof(size_t)*(numPointers+1));
FlatPointers = flat;
}
}
}
//==========================================================================
//
// PClass :: NativeClass
//
- create struct types. - fixed class creation. There was an infinite loop and some missing checks for native classes. - do not write the compiler's symbols to the same symbol table as the output. The output must go to GlobalSymbols but the internal symbols must go to a namespace specific table that can be discarded after compilation.
2016-10-08 11:34:37 +00:00
// Finds the native type underlying this class.
Normalize line endings
2016-03-01 15:47:10 +00:00
//
//==========================================================================
const PClass *PClass::NativeClass() const
{
const PClass *cls = this;
while (cls && cls->bRuntimeClass)
cls = cls->ParentClass;
return cls;
}
/* FTypeTable **************************************************************/
//==========================================================================
//
// FTypeTable :: FindType
//
//==========================================================================
PType *FTypeTable::FindType(PClass *metatype, intptr_t parm1, intptr_t parm2, size_t *bucketnum)
{
size_t bucket = Hash(metatype, parm1, parm2) % HASH_SIZE;
if (bucketnum != NULL)
{
*bucketnum = bucket;
}
for (PType *type = TypeHash[bucket]; type != NULL; type = type->HashNext)
{
if (type->GetClass()->TypeTableType == metatype && type->IsMatch(parm1, parm2))
{
return type;
}
}
return NULL;
}
//==========================================================================
//
// FTypeTable :: ReplaceType
//
// Replaces an existing type in the table with a new version of the same
// type. For use when redefining actors in DECORATE. Does nothing if the
// old version is not in the table.
//
//==========================================================================
void FTypeTable::ReplaceType(PType *newtype, PType *oldtype, size_t bucket)
{
for (PType **type_p = &TypeHash[bucket]; *type_p != NULL; type_p = &(*type_p)->HashNext)
{
PType *type = *type_p;
if (type == oldtype)
{
newtype->HashNext = type->HashNext;
type->HashNext = NULL;
*type_p = newtype;
break;
}
}
}
//==========================================================================
//
// FTypeTable :: AddType - Fully Parameterized Version
//
//==========================================================================
void FTypeTable::AddType(PType *type, PClass *metatype, intptr_t parm1, intptr_t parm2, size_t bucket)
{
#ifdef _DEBUG
size_t bucketcheck;
assert(metatype == type->GetClass()->TypeTableType && "Metatype does not match passed object");
assert(FindType(metatype, parm1, parm2, &bucketcheck) == NULL && "Type must not be inserted more than once");
assert(bucketcheck == bucket && "Passed bucket was wrong");
#endif
type->HashNext = TypeHash[bucket];
TypeHash[bucket] = type;
GC::WriteBarrier(type);
}
//==========================================================================
//
// FTypeTable :: AddType - Simple Version
//
//==========================================================================
void FTypeTable::AddType(PType *type)
{
PClass *metatype;
intptr_t parm1, parm2;
size_t bucket;
metatype = type->GetClass()->TypeTableType;
type->GetTypeIDs(parm1, parm2);
bucket = Hash(metatype, parm1, parm2) % HASH_SIZE;
assert(FindType(metatype, parm1, parm2, NULL) == NULL && "Type must not be inserted more than once");
type->HashNext = TypeHash[bucket];
TypeHash[bucket] = type;
GC::WriteBarrier(type);
}
//==========================================================================
//
// FTypeTable :: Hash STATIC
//
//==========================================================================
size_t FTypeTable::Hash(const PClass *p1, intptr_t p2, intptr_t p3)
{
size_t i1 = (size_t)p1;
// Swap the high and low halves of i1. The compiler should be smart enough
// to transform this into a ROR or ROL.
i1 = (i1 >> (sizeof(size_t)*4)) | (i1 << (sizeof(size_t)*4));
if (p1 != RUNTIME_CLASS(PPrototype))
{
size_t i2 = (size_t)p2;
size_t i3 = (size_t)p3;
return (~i1 ^ i2) + i3 * 961748927; // i3 is multiplied by a prime
}
else
{ // Prototypes need to hash the TArrays at p2 and p3
const TArray<PType *> *a2 = (const TArray<PType *> *)p2;
const TArray<PType *> *a3 = (const TArray<PType *> *)p3;
for (unsigned i = 0; i < a2->Size(); ++i)
{
i1 = (i1 * 961748927) + (size_t)((*a2)[i]);
}
for (unsigned i = 0; i < a3->Size(); ++i)
{
i1 = (i1 * 961748927) + (size_t)((*a3)[i]);
}
return i1;
}
}
//==========================================================================
//
// FTypeTable :: Mark
//
// Mark all types in this table for the garbage collector.
//
//==========================================================================
void FTypeTable::Mark()
{
for (int i = HASH_SIZE - 1; i >= 0; --i)
{
if (TypeHash[i] != NULL)
{
GC::Mark(TypeHash[i]);
}
}
}
//==========================================================================
//
// FTypeTable :: Clear
//
// Removes everything from the table. We let the garbage collector worry
// about deleting them.
//
//==========================================================================
void FTypeTable::Clear()
{
memset(TypeHash, 0, sizeof(TypeHash));
}
#include "c_dispatch.h"
CCMD(typetable)
{
DumpTypeTable();
}
// Symbol tables ------------------------------------------------------------
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PTypeBase, true, false, false);
IMPLEMENT_CLASS(PSymbol, true, false, false);
IMPLEMENT_CLASS(PSymbolConst, false, false, false);
IMPLEMENT_CLASS(PSymbolConstNumeric, false, false, false);
IMPLEMENT_CLASS(PSymbolConstString, false, false, false);
IMPLEMENT_CLASS(PSymbolTreeNode, false, false, false)
IMPLEMENT_CLASS(PSymbolType, false, true, false)
Separate the pointer list from the implement macro
2016-11-05 16:08:54 +00:00
IMPLEMENT_POINTERS_START(PSymbolType)
IMPLEMENT_POINTER(Type)
IMPLEMENT_POINTERS_END
Replaced the many implement macros with a single one that takes arguments instead
2016-11-05 17:27:14 +00:00
IMPLEMENT_CLASS(PSymbolVMFunction, false, true, false)
Separate the pointer list from the implement macro
2016-11-05 16:08:54 +00:00
IMPLEMENT_POINTERS_START(PSymbolVMFunction)
IMPLEMENT_POINTER(Function)
IMPLEMENT_POINTERS_END
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
//
//
//==========================================================================
PSymbol::~PSymbol()
{
}
PSymbolTable::PSymbolTable()
: ParentSymbolTable(NULL)
{
}
PSymbolTable::PSymbolTable(PSymbolTable *parent)
: ParentSymbolTable(parent)
{
}
PSymbolTable::~PSymbolTable ()
{
ReleaseSymbols();
}
size_t PSymbolTable::MarkSymbols()
{
size_t count = 0;
MapType::Iterator it(Symbols);
MapType::Pair *pair;
while (it.NextPair(pair))
{
GC::Mark(pair->Value);
count++;
}
return count * sizeof(*pair);
}
void PSymbolTable::ReleaseSymbols()
{
// The GC will take care of deleting the symbols. We just need to
// clear our references to them.
Symbols.Clear();
}
void PSymbolTable::SetParentTable (PSymbolTable *parent)
{
ParentSymbolTable = parent;
}
PSymbol *PSymbolTable::FindSymbol (FName symname, bool searchparents) const
{
PSymbol * const *value = Symbols.CheckKey(symname);
if (value == NULL && searchparents && ParentSymbolTable != NULL)
{
return ParentSymbolTable->FindSymbol(symname, searchparents);
}
return value != NULL ? *value : NULL;
}
Store known but uncompiled nodes in the symbol table - Don't bother keeping track of uncompiled nodes in a special table. Use the regular symbol table instead. This should in the future make compiling nodes referenced deeper than (and before) their definitions fairly straightforward. - Also, break up the compiler's Message() function into Warn() and Error() and get rid of zcc_errors.h. I can't really see having a set of error numbers being useful.
2016-03-13 03:22:29 +00:00
PSymbol *PSymbolTable::FindSymbolInTable(FName symname, PSymbolTable *&symtable)
{
PSymbol * const *value = Symbols.CheckKey(symname);
if (value == NULL)
{
if (ParentSymbolTable != NULL)
{
return ParentSymbolTable->FindSymbolInTable(symname, symtable);
}
symtable = NULL;
return NULL;
}
symtable = this;
return *value;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
PSymbol *PSymbolTable::AddSymbol (PSymbol *sym)
{
// Symbols that already exist are not inserted.
if (Symbols.CheckKey(sym->SymbolName) != NULL)
{
return NULL;
}
Symbols.Insert(sym->SymbolName, sym);
return sym;
}
Store known but uncompiled nodes in the symbol table - Don't bother keeping track of uncompiled nodes in a special table. Use the regular symbol table instead. This should in the future make compiling nodes referenced deeper than (and before) their definitions fairly straightforward. - Also, break up the compiler's Message() function into Warn() and Error() and get rid of zcc_errors.h. I can't really see having a set of error numbers being useful.
2016-03-13 03:22:29 +00:00
PSymbol *PSymbolTable::ReplaceSymbol(PSymbol *newsym)
{
// If a symbol with a matching name exists, take its place and return it.
PSymbol **symslot = Symbols.CheckKey(newsym->SymbolName);
if (symslot != NULL)
{
PSymbol *oldsym = *symslot;
*symslot = newsym;
return oldsym;
}
// Else, just insert normally and return NULL since there was no
// symbol to replace.
Symbols.Insert(newsym->SymbolName, newsym);
return NULL;
}
Reference in a new issue Copy permalink