zdoom/qzdoom
0
0
Fork 0
mirror of https://github.com/ZDoom/qzdoom.git synced 2024-12-14 06:21:19 +00:00
Code Issues Projects Releases Packages Wiki Activity
qzdoom/src/scripting/codegeneration/codegen.cpp

10750 lines
282 KiB
C++
Raw Normal View History

Normalize line endings
2016-03-01 15:47:10 +00:00
/*
- fixed: The message for invalid class extensions did not pass the class name to the error function.
2016-12-10 09:22:13 +00:00
** codegen.cpp
Normalize line endings
2016-03-01 15:47:10 +00:00
**
- fixed: The message for invalid class extensions did not pass the class name to the error function.
2016-12-10 09:22:13 +00:00
** Compiler backend / code generation for ZScript and DECORATE
Normalize line endings
2016-03-01 15:47:10 +00:00
**
**---------------------------------------------------------------------------
- fixed: The message for invalid class extensions did not pass the class name to the error function.
2016-12-10 09:22:13 +00:00
** Copyright 2008-2016 Christoph Oelckers
Normalize line endings
2016-03-01 15:47:10 +00:00
** All rights reserved.
**
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions
** are met:
**
** 1. Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** 2. Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in the
** documentation and/or other materials provided with the distribution.
** 3. The name of the author may not be used to endorse or promote products
** derived from this software without specific prior written permission.
** 4. When not used as part of ZDoom or a ZDoom derivative, this code will be
** covered by the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 2 of the License, or (at
** your option) any later version.
**
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**---------------------------------------------------------------------------
**
*/
#include <stdlib.h>
#include "actor.h"
#include "sc_man.h"
#include "tarray.h"
#include "templates.h"
#include "cmdlib.h"
#include "i_system.h"
#include "m_random.h"
#include "a_pickups.h"
#include "thingdef.h"
#include "p_lnspec.h"
#include "doomstat.h"
- pass the current function to the compile context instead of just the containing class.
2016-10-15 15:40:27 +00:00
#include "codegen.h"
Normalize line endings
2016-03-01 15:47:10 +00:00
#include "m_fixed.h"
#include "vmbuilder.h"
#include "v_text.h"
- added a new variable flag that allows defining variables which can only be modified by internal script code but not by external mods. Currently this is used by the NoBlockmap and NoSector flags which need special handling for changing.
2016-11-08 10:12:56 +00:00
#include "w_wad.h"
- added custom math routines for reliability.
2016-03-11 14:45:47 +00:00
#include "math/cmath.h"
Normalize line endings
2016-03-01 15:47:10 +00:00
- fixed: The RNG was not initialized for script calls that did not explicitly specify an RNG by name.
2016-11-04 08:23:29 +00:00
extern FRandom pr_exrandom;
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
FMemArena FxAlloc(65536);
- fixed: The RNG was not initialized for script calls that did not explicitly specify an RNG by name.
2016-11-04 08:23:29 +00:00
Normalize line endings
2016-03-01 15:47:10 +00:00
struct FLOP
{
ENamedName Name;
int Flop;
double (*Evaluate)(double);
};
// Decorate operates on degrees, so the evaluate functions need to convert
// degrees to radians for those that work with angles.
static const FLOP FxFlops[] =
{
- added custom math routines for reliability.
2016-03-11 14:45:47 +00:00
{ NAME_Exp, FLOP_EXP, [](double v) { return g_exp(v); } },
{ NAME_Log, FLOP_LOG, [](double v) { return g_log(v); } },
{ NAME_Log10, FLOP_LOG10, [](double v) { return g_log10(v); } },
{ NAME_Sqrt, FLOP_SQRT, [](double v) { return g_sqrt(v); } },
Normalize line endings
2016-03-01 15:47:10 +00:00
{ NAME_Ceil, FLOP_CEIL, [](double v) { return ceil(v); } },
{ NAME_Floor, FLOP_FLOOR, [](double v) { return floor(v); } },
- added custom math routines for reliability.
2016-03-11 14:45:47 +00:00
{ NAME_ACos, FLOP_ACOS_DEG, [](double v) { return g_acos(v) * (180.0 / M_PI); } },
{ NAME_ASin, FLOP_ASIN_DEG, [](double v) { return g_asin(v) * (180.0 / M_PI); } },
{ NAME_ATan, FLOP_ATAN_DEG, [](double v) { return g_atan(v) * (180.0 / M_PI); } },
{ NAME_Cos, FLOP_COS_DEG, [](double v) { return g_cosdeg(v); } },
{ NAME_Sin, FLOP_SIN_DEG, [](double v) { return g_sindeg(v); } },
{ NAME_Tan, FLOP_TAN_DEG, [](double v) { return g_tan(v * (M_PI / 180.0)); } },
Normalize line endings
2016-03-01 15:47:10 +00:00
- added custom math routines for reliability.
2016-03-11 14:45:47 +00:00
{ NAME_CosH, FLOP_COSH, [](double v) { return g_cosh(v); } },
{ NAME_SinH, FLOP_SINH, [](double v) { return g_sinh(v); } },
{ NAME_TanH, FLOP_TANH, [](double v) { return g_tanh(v); } },
Normalize line endings
2016-03-01 15:47:10 +00:00
};
DECORATE can now handle jump statements break and continue were added but are not yet useable anywhere This was made general enough so that loops and switch statements that accept breaks/continues can be done without much difficulty as well as goto statements with explicit labels if those are ever wanted
2016-07-26 21:57:26 +00:00
//==========================================================================
//
// FCompileContext
//
//==========================================================================
- fixed: Class and struct name lookup was not context aware. If a later module reused an existing name for a different class or struct type, this new name would completely shadow the old one, even in the base files. Changed it so that each compilation unit (i.e. each ZScript and DECORATE lump) get their own symbol table and can only see the symbol tables that got defined in lower numbered resource files so that later definitions do not pollute the available list of symbols when running the compiler backend and code generator - which happens after everything has been parsed. Another effect of this is that a mod that reuses the name of an internal global constant will only see its own constant, again reducing the risk of potential errors in case the internal definitions add some new values. Global constants are still discouraged from being used because what this does not and can not handle is the case that a mod defines a global constant with the same name as a class variable. In such a case the class variable will always take precedence for code inside that class. Note that the internal struct String had to be renamed for this because the stricter checks did not let the type String pass on the left side of a '.' anymore. - made PEnum inherit from PInt and not from PNamedType. The old inheritance broke nearly every check for integer compatibility in the compiler, so this hopefully leads to a working enum implementation.
2017-01-23 18:09:36 +00:00
FCompileContext::FCompileContext(PNamespace *cg, PFunction *fnc, PPrototype *ret, bool fromdecorate, int stateindex, int statecount, int lump)
: ReturnProto(ret), Function(fnc), Class(nullptr), FromDecorate(fromdecorate), StateIndex(stateindex), StateCount(statecount), Lump(lump), CurGlobals(cg)
DECORATE can now handle jump statements break and continue were added but are not yet useable anywhere This was made general enough so that loops and switch statements that accept breaks/continues can be done without much difficulty as well as goto statements with explicit labels if those are ever wanted
2016-07-26 21:57:26 +00:00
{
- pass the current function to the compile context instead of just the containing class.
2016-10-15 15:40:27 +00:00
if (fnc != nullptr) Class = fnc->OwningClass;
DECORATE can now handle jump statements break and continue were added but are not yet useable anywhere This was made general enough so that loops and switch statements that accept breaks/continues can be done without much difficulty as well as goto statements with explicit labels if those are ever wanted
2016-07-26 21:57:26 +00:00
}
- fixed: Class and struct name lookup was not context aware. If a later module reused an existing name for a different class or struct type, this new name would completely shadow the old one, even in the base files. Changed it so that each compilation unit (i.e. each ZScript and DECORATE lump) get their own symbol table and can only see the symbol tables that got defined in lower numbered resource files so that later definitions do not pollute the available list of symbols when running the compiler backend and code generator - which happens after everything has been parsed. Another effect of this is that a mod that reuses the name of an internal global constant will only see its own constant, again reducing the risk of potential errors in case the internal definitions add some new values. Global constants are still discouraged from being used because what this does not and can not handle is the case that a mod defines a global constant with the same name as a class variable. In such a case the class variable will always take precedence for code inside that class. Note that the internal struct String had to be renamed for this because the stricter checks did not let the type String pass on the left side of a '.' anymore. - made PEnum inherit from PInt and not from PNamedType. The old inheritance broke nearly every check for integer compatibility in the compiler, so this hopefully leads to a working enum implementation.
2017-01-23 18:09:36 +00:00
FCompileContext::FCompileContext(PNamespace *cg, PStruct *cls, bool fromdecorate)
: ReturnProto(nullptr), Function(nullptr), Class(cls), FromDecorate(fromdecorate), StateIndex(-1), StateCount(0), Lump(-1), CurGlobals(cg)
DECORATE can now handle jump statements break and continue were added but are not yet useable anywhere This was made general enough so that loops and switch statements that accept breaks/continues can be done without much difficulty as well as goto statements with explicit labels if those are ever wanted
2016-07-26 21:57:26 +00:00
{
- pass the current function to the compile context instead of just the containing class.
2016-10-15 15:40:27 +00:00
}
PSymbol *FCompileContext::FindInClass(FName identifier, PSymbolTable *&symt)
{
return Class != nullptr? Class->Symbols.FindSymbolInTable(identifier, symt) : nullptr;
}
PSymbol *FCompileContext::FindInSelfClass(FName identifier, PSymbolTable *&symt)
{
// If we have no self we cannot retrieve any values from it.
if (Function == nullptr || Function->Variants[0].SelfClass == nullptr) return nullptr;
return Function->Variants[0].SelfClass->Symbols.FindSymbolInTable(identifier, symt);
DECORATE can now handle jump statements break and continue were added but are not yet useable anywhere This was made general enough so that loops and switch statements that accept breaks/continues can be done without much difficulty as well as goto statements with explicit labels if those are ever wanted
2016-07-26 21:57:26 +00:00
}
PSymbol *FCompileContext::FindGlobal(FName identifier)
{
- fixed: Class and struct name lookup was not context aware. If a later module reused an existing name for a different class or struct type, this new name would completely shadow the old one, even in the base files. Changed it so that each compilation unit (i.e. each ZScript and DECORATE lump) get their own symbol table and can only see the symbol tables that got defined in lower numbered resource files so that later definitions do not pollute the available list of symbols when running the compiler backend and code generator - which happens after everything has been parsed. Another effect of this is that a mod that reuses the name of an internal global constant will only see its own constant, again reducing the risk of potential errors in case the internal definitions add some new values. Global constants are still discouraged from being used because what this does not and can not handle is the case that a mod defines a global constant with the same name as a class variable. In such a case the class variable will always take precedence for code inside that class. Note that the internal struct String had to be renamed for this because the stricter checks did not let the type String pass on the left side of a '.' anymore. - made PEnum inherit from PInt and not from PNamedType. The old inheritance broke nearly every check for integer compatibility in the compiler, so this hopefully leads to a working enum implementation.
2017-01-23 18:09:36 +00:00
return CurGlobals->Symbols.FindSymbol(identifier, true);
DECORATE can now handle jump statements break and continue were added but are not yet useable anywhere This was made general enough so that loops and switch statements that accept breaks/continues can be done without much difficulty as well as goto statements with explicit labels if those are ever wanted
2016-07-26 21:57:26 +00:00
}
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
void FCompileContext::CheckReturn(PPrototype *proto, FScriptPosition &pos)
{
assert(proto != nullptr);
bool fail = false;
if (ReturnProto == nullptr)
{
ReturnProto = proto;
return;
}
// A prototype that defines fewer return types can be compatible with
// one that defines more if the shorter one matches the initial types
// for the longer one.
if (ReturnProto->ReturnTypes.Size() < proto->ReturnTypes.Size())
{ // Make proto the shorter one to avoid code duplication below.
swapvalues(proto, ReturnProto);
}
// If one prototype returns nothing, they both must.
if (proto->ReturnTypes.Size() == 0)
{
if (ReturnProto->ReturnTypes.Size() != 0)
{
fail = true;
}
}
else
{
for (unsigned i = 0; i < proto->ReturnTypes.Size(); i++)
{
if (ReturnProto->ReturnTypes[i] != proto->ReturnTypes[i])
{ // Incompatible
fail = true;
break;
}
}
}
if (fail)
{
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
pos.Message(MSG_ERROR, "Return type mismatch");
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
}
}
- added a new variable flag that allows defining variables which can only be modified by internal script code but not by external mods. Currently this is used by the NoBlockmap and NoSector flags which need special handling for changing.
2016-11-08 10:12:56 +00:00
bool FCompileContext::CheckReadOnly(int flags)
{
if (!(flags & VARF_ReadOnly)) return false;
if (!(flags & VARF_InternalAccess)) return true;
return Wads.GetLumpFile(Lump) != 0;
}
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
FxLocalVariableDeclaration *FCompileContext::FindLocalVariable(FName name)
{
if (Block == nullptr)
{
return nullptr;
}
else
{
return Block->FindLocalVariable(name, *this);
}
}
- fixed: Class and struct name lookup was not context aware. If a later module reused an existing name for a different class or struct type, this new name would completely shadow the old one, even in the base files. Changed it so that each compilation unit (i.e. each ZScript and DECORATE lump) get their own symbol table and can only see the symbol tables that got defined in lower numbered resource files so that later definitions do not pollute the available list of symbols when running the compiler backend and code generator - which happens after everything has been parsed. Another effect of this is that a mod that reuses the name of an internal global constant will only see its own constant, again reducing the risk of potential errors in case the internal definitions add some new values. Global constants are still discouraged from being used because what this does not and can not handle is the case that a mod defines a global constant with the same name as a class variable. In such a case the class variable will always take precedence for code inside that class. Note that the internal struct String had to be renamed for this because the stricter checks did not let the type String pass on the left side of a '.' anymore. - made PEnum inherit from PInt and not from PNamedType. The old inheritance broke nearly every check for integer compatibility in the compiler, so this hopefully leads to a working enum implementation.
2017-01-23 18:09:36 +00:00
static PStruct *FindStructType(FName name, FCompileContext &ctx)
- scriptified the Minotaur. Interesting tidbit: The damage calculation in P_MinotaurSlam had been incorrect for the Heretic version since the friendly Hexen Dark Servant was added, but nobody ever noticed in 14 years...
2016-11-26 00:14:47 +00:00
{
- fixed: Class and struct name lookup was not context aware. If a later module reused an existing name for a different class or struct type, this new name would completely shadow the old one, even in the base files. Changed it so that each compilation unit (i.e. each ZScript and DECORATE lump) get their own symbol table and can only see the symbol tables that got defined in lower numbered resource files so that later definitions do not pollute the available list of symbols when running the compiler backend and code generator - which happens after everything has been parsed. Another effect of this is that a mod that reuses the name of an internal global constant will only see its own constant, again reducing the risk of potential errors in case the internal definitions add some new values. Global constants are still discouraged from being used because what this does not and can not handle is the case that a mod defines a global constant with the same name as a class variable. In such a case the class variable will always take precedence for code inside that class. Note that the internal struct String had to be renamed for this because the stricter checks did not let the type String pass on the left side of a '.' anymore. - made PEnum inherit from PInt and not from PNamedType. The old inheritance broke nearly every check for integer compatibility in the compiler, so this hopefully leads to a working enum implementation.
2017-01-23 18:09:36 +00:00
auto sym = ctx.Class->Symbols.FindSymbol(name, true);
if (sym == nullptr) sym = ctx.CurGlobals->Symbols.FindSymbol(name, true);
if (sym && sym->IsKindOf(RUNTIME_CLASS(PSymbolType)))
- scriptified the Minotaur. Interesting tidbit: The damage calculation in P_MinotaurSlam had been incorrect for the Heretic version since the friendly Hexen Dark Servant was added, but nobody ever noticed in 14 years...
2016-11-26 00:14:47 +00:00
{
- fixed: Class and struct name lookup was not context aware. If a later module reused an existing name for a different class or struct type, this new name would completely shadow the old one, even in the base files. Changed it so that each compilation unit (i.e. each ZScript and DECORATE lump) get their own symbol table and can only see the symbol tables that got defined in lower numbered resource files so that later definitions do not pollute the available list of symbols when running the compiler backend and code generator - which happens after everything has been parsed. Another effect of this is that a mod that reuses the name of an internal global constant will only see its own constant, again reducing the risk of potential errors in case the internal definitions add some new values. Global constants are still discouraged from being used because what this does not and can not handle is the case that a mod defines a global constant with the same name as a class variable. In such a case the class variable will always take precedence for code inside that class. Note that the internal struct String had to be renamed for this because the stricter checks did not let the type String pass on the left side of a '.' anymore. - made PEnum inherit from PInt and not from PNamedType. The old inheritance broke nearly every check for integer compatibility in the compiler, so this hopefully leads to a working enum implementation.
2017-01-23 18:09:36 +00:00
auto type = static_cast<PSymbolType*>(sym);
return dyn_cast<PStruct>(type->Type);
- scriptified the Minotaur. Interesting tidbit: The damage calculation in P_MinotaurSlam had been incorrect for the Heretic version since the friendly Hexen Dark Servant was added, but nobody ever noticed in 14 years...
2016-11-26 00:14:47 +00:00
}
- fixed: Class and struct name lookup was not context aware. If a later module reused an existing name for a different class or struct type, this new name would completely shadow the old one, even in the base files. Changed it so that each compilation unit (i.e. each ZScript and DECORATE lump) get their own symbol table and can only see the symbol tables that got defined in lower numbered resource files so that later definitions do not pollute the available list of symbols when running the compiler backend and code generator - which happens after everything has been parsed. Another effect of this is that a mod that reuses the name of an internal global constant will only see its own constant, again reducing the risk of potential errors in case the internal definitions add some new values. Global constants are still discouraged from being used because what this does not and can not handle is the case that a mod defines a global constant with the same name as a class variable. In such a case the class variable will always take precedence for code inside that class. Note that the internal struct String had to be renamed for this because the stricter checks did not let the type String pass on the left side of a '.' anymore. - made PEnum inherit from PInt and not from PNamedType. The old inheritance broke nearly every check for integer compatibility in the compiler, so this hopefully leads to a working enum implementation.
2017-01-23 18:09:36 +00:00
return nullptr;
}
// This is for resolving class identifiers which need to be context aware, unlike class names.
static PClass *FindClassType(FName name, FCompileContext &ctx)
{
auto sym = ctx.CurGlobals->Symbols.FindSymbol(name, true);
if (sym && sym->IsKindOf(RUNTIME_CLASS(PSymbolType)))
{
auto type = static_cast<PSymbolType*>(sym);
return dyn_cast<PClass>(type->Type);
}
return nullptr;
- scriptified the Minotaur. Interesting tidbit: The damage calculation in P_MinotaurSlam had been incorrect for the Heretic version since the friendly Hexen Dark Servant was added, but nobody ever noticed in 14 years...
2016-11-26 00:14:47 +00:00
}
- fixed: Class and struct name lookup was not context aware. If a later module reused an existing name for a different class or struct type, this new name would completely shadow the old one, even in the base files. Changed it so that each compilation unit (i.e. each ZScript and DECORATE lump) get their own symbol table and can only see the symbol tables that got defined in lower numbered resource files so that later definitions do not pollute the available list of symbols when running the compiler backend and code generator - which happens after everything has been parsed. Another effect of this is that a mod that reuses the name of an internal global constant will only see its own constant, again reducing the risk of potential errors in case the internal definitions add some new values. Global constants are still discouraged from being used because what this does not and can not handle is the case that a mod defines a global constant with the same name as a class variable. In such a case the class variable will always take precedence for code inside that class. Note that the internal struct String had to be renamed for this because the stricter checks did not let the type String pass on the left side of a '.' anymore. - made PEnum inherit from PInt and not from PNamedType. The old inheritance broke nearly every check for integer compatibility in the compiler, so this hopefully leads to a working enum implementation.
2017-01-23 18:09:36 +00:00
DECORATE can now handle jump statements break and continue were added but are not yet useable anywhere This was made general enough so that loops and switch statements that accept breaks/continues can be done without much difficulty as well as goto statements with explicit labels if those are ever wanted
2016-07-26 21:57:26 +00:00
//==========================================================================
//
// ExpEmit
//
//==========================================================================
- implemented local vector variables. Currently only the definition plus initial assignment works. - removed all vector4 handling that had already been added, now that this type can no longer be defined.
2016-10-28 13:15:30 +00:00
ExpEmit::ExpEmit(VMFunctionBuilder *build, int type, int count)
: RegNum(build->Registers[type].Get(count)), RegType(type), RegCount(count), Konst(false), Fixed(false), Final(false), Target(false)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
}
void ExpEmit::Free(VMFunctionBuilder *build)
{
if (!Fixed && !Konst && RegType <= REGT_TYPE)
{
- implemented local vector variables. Currently only the definition plus initial assignment works. - removed all vector4 handling that had already been added, now that this type can no longer be defined.
2016-10-28 13:15:30 +00:00
build->Registers[RegType].Return(RegNum, RegCount);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
void ExpEmit::Reuse(VMFunctionBuilder *build)
{
if (!Fixed && !Konst)
{
- implemented local vector variables. Currently only the definition plus initial assignment works. - removed all vector4 handling that had already been added, now that this type can no longer be defined.
2016-10-28 13:15:30 +00:00
assert(RegCount == 1);
Normalize line endings
2016-03-01 15:47:10 +00:00
bool success = build->Registers[RegType].Reuse(RegNum);
assert(success && "Attempt to reuse a register that is already in use");
}
}
//==========================================================================
//
- implemented the 'is' operator (i.e. class type check.)
2016-10-29 23:05:56 +00:00
// FindBuiltinFunction
Normalize line endings
2016-03-01 15:47:10 +00:00
//
// Returns the symbol for a decorate utility function. If not found, create
- implemented the 'is' operator (i.e. class type check.)
2016-10-29 23:05:56 +00:00
// it and install it a local symbol table.
Normalize line endings
2016-03-01 15:47:10 +00:00
//
//==========================================================================
- implemented the 'is' operator (i.e. class type check.)
2016-10-29 23:05:56 +00:00
static PSymbol *FindBuiltinFunction(FName funcname, VMNativeFunction::NativeCallType func)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- fixed: Class and struct name lookup was not context aware. If a later module reused an existing name for a different class or struct type, this new name would completely shadow the old one, even in the base files. Changed it so that each compilation unit (i.e. each ZScript and DECORATE lump) get their own symbol table and can only see the symbol tables that got defined in lower numbered resource files so that later definitions do not pollute the available list of symbols when running the compiler backend and code generator - which happens after everything has been parsed. Another effect of this is that a mod that reuses the name of an internal global constant will only see its own constant, again reducing the risk of potential errors in case the internal definitions add some new values. Global constants are still discouraged from being used because what this does not and can not handle is the case that a mod defines a global constant with the same name as a class variable. In such a case the class variable will always take precedence for code inside that class. Note that the internal struct String had to be renamed for this because the stricter checks did not let the type String pass on the left side of a '.' anymore. - made PEnum inherit from PInt and not from PNamedType. The old inheritance broke nearly every check for integer compatibility in the compiler, so this hopefully leads to a working enum implementation.
2017-01-23 18:09:36 +00:00
PSymbol *sym = Namespaces.GlobalNamespace->Symbols.FindSymbol(funcname, false);
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
if (sym == nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
PSymbolVMFunction *symfunc = new PSymbolVMFunction(funcname);
VMNativeFunction *calldec = new VMNativeFunction(func, funcname);
- scriptified the scripted marines. - fixed symbol name generation for native functions. - moved PrintableName to VMFunction so that native functions also have this information.
2016-11-21 18:09:58 +00:00
calldec->PrintableName = funcname.GetChars();
Normalize line endings
2016-03-01 15:47:10 +00:00
symfunc->Function = calldec;
sym = symfunc;
- fixed: Class and struct name lookup was not context aware. If a later module reused an existing name for a different class or struct type, this new name would completely shadow the old one, even in the base files. Changed it so that each compilation unit (i.e. each ZScript and DECORATE lump) get their own symbol table and can only see the symbol tables that got defined in lower numbered resource files so that later definitions do not pollute the available list of symbols when running the compiler backend and code generator - which happens after everything has been parsed. Another effect of this is that a mod that reuses the name of an internal global constant will only see its own constant, again reducing the risk of potential errors in case the internal definitions add some new values. Global constants are still discouraged from being used because what this does not and can not handle is the case that a mod defines a global constant with the same name as a class variable. In such a case the class variable will always take precedence for code inside that class. Note that the internal struct String had to be renamed for this because the stricter checks did not let the type String pass on the left side of a '.' anymore. - made PEnum inherit from PInt and not from PNamedType. The old inheritance broke nearly every check for integer compatibility in the compiler, so this hopefully leads to a working enum implementation.
2017-01-23 18:09:36 +00:00
Namespaces.GlobalNamespace->Symbols.AddSymbol(sym);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
return sym;
}
//==========================================================================
//
//
//
//==========================================================================
- scriptified the Minotaur. Interesting tidbit: The damage calculation in P_MinotaurSlam had been incorrect for the Heretic version since the friendly Hexen Dark Servant was added, but nobody ever noticed in 14 years...
2016-11-26 00:14:47 +00:00
static bool AreCompatiblePointerTypes(PType *dest, PType *source, bool forcompare = false)
- added null pointer. - fixed: FxMemberIdentifier checked for ClassPointers instead of object pointers to resolve the left hand side of the expression. - allow comparison of pointers.
2016-10-21 22:50:04 +00:00
{
if (dest->IsKindOf(RUNTIME_CLASS(PPointer)) && source->IsKindOf(RUNTIME_CLASS(PPointer)))
{
auto fromtype = static_cast<PPointer *>(source);
auto totype = static_cast<PPointer *>(dest);
some groundwork for the implementation of dynamic arrays - created script exports for all relevant functions with all integral types. - created script side definitions for the underlying data types. - added a void pointer type so that the prototype for the pointer array can use a generic type every pointer can be assigned to.
2017-01-10 23:57:31 +00:00
// null pointers can be assigned to everything, everything can be assigned to void pointers.
if (fromtype == nullptr || totype == TypeVoidPtr) return true;
// when comparing const-ness does not matter.
- fixed: Readonly pointers never were flagged as such. - fixed: Assignment from a readonly to a read-allowed pointer must be an error. - made GetDefaultByType a builtin so that it can do proper type assignment to the result, which for a function would be problematic in this case, even if automatic type deduction was implemented. Since this returns the class defaults which are not a real object, the result cannot be subjected to a type cast. - error out if a type cast of a readonly pointer is attempted. - fixed: FxBooleanNot could clobber a local variable because it used the source register to manipulate the result.
2016-11-27 14:50:58 +00:00
if (!forcompare && totype->IsConst != fromtype->IsConst) return false;
some groundwork for the implementation of dynamic arrays - created script exports for all relevant functions with all integral types. - created script side definitions for the underlying data types. - added a void pointer type so that the prototype for the pointer array can use a generic type every pointer can be assigned to.
2017-01-10 23:57:31 +00:00
// A type is always compatible to itself.
- added null pointer. - fixed: FxMemberIdentifier checked for ClassPointers instead of object pointers to resolve the left hand side of the expression. - allow comparison of pointers.
2016-10-21 22:50:04 +00:00
if (fromtype == totype) return true;
some groundwork for the implementation of dynamic arrays - created script exports for all relevant functions with all integral types. - created script side definitions for the underlying data types. - added a void pointer type so that the prototype for the pointer array can use a generic type every pointer can be assigned to.
2017-01-10 23:57:31 +00:00
// Pointers to different types are only compatible if both point to an object and the source type is a child of the destination type.
- added null pointer. - fixed: FxMemberIdentifier checked for ClassPointers instead of object pointers to resolve the left hand side of the expression. - allow comparison of pointers.
2016-10-21 22:50:04 +00:00
if (fromtype->PointedType->IsKindOf(RUNTIME_CLASS(PClass)) && totype->PointedType->IsKindOf(RUNTIME_CLASS(PClass)))
{
auto fromcls = static_cast<PClass *>(fromtype->PointedType);
auto tocls = static_cast<PClass *>(totype->PointedType);
- scriptified the Minotaur. Interesting tidbit: The damage calculation in P_MinotaurSlam had been incorrect for the Heretic version since the friendly Hexen Dark Servant was added, but nobody ever noticed in 14 years...
2016-11-26 00:14:47 +00:00
if (forcompare && tocls->IsDescendantOf(fromcls)) return true;
- added null pointer. - fixed: FxMemberIdentifier checked for ClassPointers instead of object pointers to resolve the left hand side of the expression. - allow comparison of pointers.
2016-10-21 22:50:04 +00:00
return (fromcls->IsDescendantOf(tocls));
}
}
return false;
}
//==========================================================================
//
//
//
//==========================================================================
Normalize line endings
2016-03-01 15:47:10 +00:00
ExpEmit FxExpression::Emit (VMFunctionBuilder *build)
{
ScriptPosition.Message(MSG_ERROR, "Unemitted expression found");
return ExpEmit();
}
- record all line numbers during function generation. This is useful for error reporting and eventually debugging. - throw a useful exception when a VM abort occurs, the simple enum was incapable of reporting anything more than the barest minimum, which at least for array index out of bounds errors was insufficient. The current exception mechanism is still insufficient. It really has to report a proper crash location and print a stack trace to the maximum extent possible. Instead it just prints a message and happily goes on. This is not a good solution.
2016-12-02 16:36:29 +00:00
//==========================================================================
//
// Emits a statement and records its position in the source.
//
//==========================================================================
void FxExpression::EmitStatement(VMFunctionBuilder *build)
{
build->BeginStatement(this);
ExpEmit exp = Emit(build);
exp.Free(build);
build->EndStatement();
}
- branch optimization.
2016-12-01 23:51:29 +00:00
//==========================================================================
//
//
//
//==========================================================================
void FxExpression::EmitCompare(VMFunctionBuilder *build, bool invert, TArray<size_t> &patchspots_yes, TArray<size_t> &patchspots_no)
{
ExpEmit op = Emit(build);
ExpEmit i;
assert(op.RegType != REGT_NIL && op.RegCount == 1 && !op.Konst);
switch (op.RegType)
{
case REGT_INT:
build->Emit(OP_EQ_K, !invert, op.RegNum, build->GetConstantInt(0));
break;
case REGT_FLOAT:
build->Emit(OP_EQF_K, !invert, op.RegNum, build->GetConstantFloat(0));
break;
case REGT_POINTER:
build->Emit(OP_EQA_K, !invert, op.RegNum, build->GetConstantAddress(0, ATAG_GENERIC));
break;
case REGT_STRING:
i = ExpEmit(build, REGT_INT);
build->Emit(OP_LENS, i.RegNum, op.RegNum);
build->Emit(OP_EQ_K, !invert, i.RegNum, build->GetConstantInt(0));
i.Free(build);
break;
default:
break;
}
patchspots_no.Push(build->Emit(OP_JMP, 0));
op.Free(build);
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
//
//
//==========================================================================
bool FxExpression::isConstant() const
{
return false;
}
//==========================================================================
//
//
//
//==========================================================================
VMFunction *FxExpression::GetDirectFunction()
{
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxExpression::Resolve(FCompileContext &ctx)
{
isresolved = true;
return this;
}
//==========================================================================
//
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
// Returns true if we can write to the address.
Normalize line endings
2016-03-01 15:47:10 +00:00
//
//==========================================================================
- added a new variable flag that allows defining variables which can only be modified by internal script code but not by external mods. Currently this is used by the NoBlockmap and NoSector flags which need special handling for changing.
2016-11-08 10:12:56 +00:00
bool FxExpression::RequestAddress(FCompileContext &ctx, bool *writable)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- handle all unary operators. - handle all binary operators which are already implemented in the code generator. - implemented sizeof/alignof operators in code generator. - rewrote RequestAddress so that its return value is not the writability of an address but the mere existence. Also changed it to not output errors itself because those cannot be dealt with by the calling function.
2016-10-17 18:33:35 +00:00
if (writable != nullptr) *writable = false;
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
return false;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
//==========================================================================
//
// Called by return statements.
//
//==========================================================================
PPrototype *FxExpression::ReturnProto()
{
assert(ValueType != nullptr);
TArray<PType *> ret(0);
TArray<PType *> none(0);
if (ValueType != TypeVoid)
{
ret.Push(ValueType);
}
return NewPrototype(ret, none);
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
//
//
//==========================================================================
Make sure to use the REGT_MULTIREG flags for opcodes that need it
2016-10-30 05:17:37 +00:00
static int EncodeRegType(ExpEmit reg)
{
int regtype = reg.RegType;
more inventory scriptification * completely scriptified DehackedPickup and FakeInventory. * scriptified all remaining virtual functions of Inventory, so that its inheritance is now 100% script-side. * scriptified CallTryPickup and most of the code called by that. - fixed: Passing local variables by reference did not work in the VM.
2017-01-19 22:42:12 +00:00
if (reg.Fixed && reg.Target)
{
regtype |= REGT_ADDROF;
}
Make sure to use the REGT_MULTIREG flags for opcodes that need it
2016-10-30 05:17:37 +00:00
if (reg.Konst)
{
regtype |= REGT_KONST;
}
else if (reg.RegCount == 2)
{
regtype |= REGT_MULTIREG2;
- scriptified a_archvile.cpp. - fixed the type checks for the conditional operator.
2016-10-30 17:41:39 +00:00
Make sure to use the REGT_MULTIREG flags for opcodes that need it
2016-10-30 05:17:37 +00:00
}
else if (reg.RegCount == 3)
{
regtype |= REGT_MULTIREG3;
}
return regtype;
}
//==========================================================================
//
//
//
//==========================================================================
- implemented passing vectors as parameters. So far working for native functions. - removed the bogus optional value from the first A_Jump argument. A quick test with an older ZDoom revealed that this was never working - and implementing it would make things a lot more complicated, especially error checking in the code generator. - fixed: The check for insufficient parameters to a function call was missing.
2016-10-29 11:10:27 +00:00
static int EmitParameter(VMFunctionBuilder *build, FxExpression *operand, const FScriptPosition &pos)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
ExpEmit where = operand->Emit(build);
if (where.RegType == REGT_NIL)
{
pos.Message(MSG_ERROR, "Attempted to pass a non-value");
build->Emit(OP_PARAM, 0, where.RegType, where.RegNum);
- implemented passing vectors as parameters. So far working for native functions. - removed the bogus optional value from the first A_Jump argument. A quick test with an older ZDoom revealed that this was never working - and implementing it would make things a lot more complicated, especially error checking in the code generator. - fixed: The check for insufficient parameters to a function call was missing.
2016-10-29 11:10:27 +00:00
return 1;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
Make sure to use the REGT_MULTIREG flags for opcodes that need it
2016-10-30 05:17:37 +00:00
build->Emit(OP_PARAM, 0, EncodeRegType(where), where.RegNum);
Normalize line endings
2016-03-01 15:47:10 +00:00
where.Free(build);
- implemented passing vectors as parameters. So far working for native functions. - removed the bogus optional value from the first A_Jump argument. A quick test with an older ZDoom revealed that this was never working - and implementing it would make things a lot more complicated, especially error checking in the code generator. - fixed: The check for insufficient parameters to a function call was missing.
2016-10-29 11:10:27 +00:00
return where.RegCount;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxConstant::MakeConstant(PSymbol *sym, const FScriptPosition &pos)
{
FxExpression *x;
PSymbolConstNumeric *csym = dyn_cast<PSymbolConstNumeric>(sym);
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
if (csym != nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
if (csym->ValueType->IsA(RUNTIME_CLASS(PInt)))
{
x = new FxConstant(csym->Value, pos);
}
else if (csym->ValueType->IsA(RUNTIME_CLASS(PFloat)))
{
x = new FxConstant(csym->Float, pos);
}
else
{
pos.Message(MSG_ERROR, "Invalid constant '%s'\n", csym->SymbolName.GetChars());
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
else
{
- scriptified the RandomSpawner. - fixed: String constants were not processed by the compiler backend. - added an explicit name cast for class types.
2017-01-14 01:05:52 +00:00
PSymbolConstString *csym = dyn_cast<PSymbolConstString>(sym);
if (csym != nullptr)
{
x = new FxConstant(csym->Str, pos);
}
else
{
pos.Message(MSG_ERROR, "'%s' is not a constant\n", sym->SymbolName.GetChars());
x = nullptr;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
}
return x;
}
ExpEmit FxConstant::Emit(VMFunctionBuilder *build)
{
ExpEmit out;
out.Konst = true;
int regtype = value.Type->GetRegType();
out.RegType = regtype;
if (regtype == REGT_INT)
{
out.RegNum = build->GetConstantInt(value.Int);
}
else if (regtype == REGT_FLOAT)
{
out.RegNum = build->GetConstantFloat(value.Float);
}
else if (regtype == REGT_POINTER)
{
VM_ATAG tag = ATAG_GENERIC;
if (value.Type == TypeState)
{
tag = ATAG_STATE;
}
else if (value.Type->GetLoadOp() == OP_LO)
{
tag = ATAG_OBJECT;
}
out.RegNum = build->GetConstantAddress(value.pointer, tag);
}
else if (regtype == REGT_STRING)
{
out.RegNum = build->GetConstantString(value.GetString());
}
else
{
ScriptPosition.Message(MSG_ERROR, "Cannot emit needed constant");
out.RegNum = 0;
}
return out;
}
//==========================================================================
//
//
//
//==========================================================================
Renamed "VectorInitializer" to "VectorValue" This was really confusing for me as this is an actual vector "value" rather than an "initializer"
2016-10-30 03:35:01 +00:00
FxVectorValue::FxVectorValue(FxExpression *x, FxExpression *y, FxExpression *z, const FScriptPosition &sc)
:FxExpression(EFX_VectorValue, sc)
- implemented local vector variables. Currently only the definition plus initial assignment works. - removed all vector4 handling that had already been added, now that this type can no longer be defined.
2016-10-28 13:15:30 +00:00
{
xyz[0] = x;
xyz[1] = y;
xyz[2] = z;
isConst = false;
ValueType = TypeVoid; // we do not know yet
}
Renamed "VectorInitializer" to "VectorValue" This was really confusing for me as this is an actual vector "value" rather than an "initializer"
2016-10-30 03:35:01 +00:00
FxVectorValue::~FxVectorValue()
- implemented local vector variables. Currently only the definition plus initial assignment works. - removed all vector4 handling that had already been added, now that this type can no longer be defined.
2016-10-28 13:15:30 +00:00
{
for (auto &a : xyz)
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
{
- implemented local vector variables. Currently only the definition plus initial assignment works. - removed all vector4 handling that had already been added, now that this type can no longer be defined.
2016-10-28 13:15:30 +00:00
SAFE_DELETE(a);
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
}
- implemented local vector variables. Currently only the definition plus initial assignment works. - removed all vector4 handling that had already been added, now that this type can no longer be defined.
2016-10-28 13:15:30 +00:00
}
Renamed "VectorInitializer" to "VectorValue" This was really confusing for me as this is an actual vector "value" rather than an "initializer"
2016-10-30 03:35:01 +00:00
FxExpression *FxVectorValue::Resolve(FCompileContext&ctx)
- implemented local vector variables. Currently only the definition plus initial assignment works. - removed all vector4 handling that had already been added, now that this type can no longer be defined.
2016-10-28 13:15:30 +00:00
{
bool fails = false;
for (auto &a : xyz)
{
if (a != nullptr)
{
a = a->Resolve(ctx);
if (a == nullptr) fails = true;
else
{
if (a->ValueType != TypeVector2) // a vec3 may be initialized with (vec2, z)
{
a = new FxFloatCast(a);
a = a->Resolve(ctx);
fails |= (a == nullptr);
}
}
}
}
if (fails)
{
delete this;
return nullptr;
}
// at this point there are three legal cases:
// * two floats = vector2
// * three floats = vector3
// * vector2 + float = vector3
if (xyz[0]->ValueType == TypeVector2)
{
if (xyz[1]->ValueType != TypeFloat64 || xyz[2] != nullptr)
{
ScriptPosition.Message(MSG_ERROR, "Not a valid vector");
delete this;
return nullptr;
}
ValueType = TypeVector3;
Renamed "VectorInitializer" to "VectorValue" This was really confusing for me as this is an actual vector "value" rather than an "initializer"
2016-10-30 03:35:01 +00:00
if (xyz[0]->ExprType == EFX_VectorValue)
- implemented local vector variables. Currently only the definition plus initial assignment works. - removed all vector4 handling that had already been added, now that this type can no longer be defined.
2016-10-28 13:15:30 +00:00
{
// If two vector initializers are nested, unnest them now.
Renamed "VectorInitializer" to "VectorValue" This was really confusing for me as this is an actual vector "value" rather than an "initializer"
2016-10-30 03:35:01 +00:00
auto vi = static_cast<FxVectorValue*>(xyz[0]);
- implemented local vector variables. Currently only the definition plus initial assignment works. - removed all vector4 handling that had already been added, now that this type can no longer be defined.
2016-10-28 13:15:30 +00:00
xyz[2] = xyz[1];
xyz[1] = vi->xyz[1];
xyz[0] = vi->xyz[0];
Fixed: A vector value could point to garbage data after being 'unnested'
2016-10-30 05:55:16 +00:00
vi->xyz[0] = vi->xyz[1] = nullptr; // Don't delete our own expressions.
- implemented local vector variables. Currently only the definition plus initial assignment works. - removed all vector4 handling that had already been added, now that this type can no longer be defined.
2016-10-28 13:15:30 +00:00
delete vi;
}
}
else if (xyz[0]->ValueType == TypeFloat64 && xyz[1]->ValueType == TypeFloat64)
{
ValueType = xyz[2] == nullptr ? TypeVector2 : TypeVector3;
}
else
{
ScriptPosition.Message(MSG_ERROR, "Not a valid vector");
delete this;
return nullptr;
}
// check if all elements are constant. If so this can be emitted as a constant vector.
isConst = true;
for (auto &a : xyz)
{
if (a != nullptr && !a->isConstant()) isConst = false;
}
return this;
}
static ExpEmit EmitKonst(VMFunctionBuilder *build, ExpEmit &emit)
{
if (emit.Konst)
{
ExpEmit out(build, REGT_FLOAT);
build->Emit(OP_LKF, out.RegNum, emit.RegNum);
return out;
}
return emit;
}
Renamed "VectorInitializer" to "VectorValue" This was really confusing for me as this is an actual vector "value" rather than an "initializer"
2016-10-30 03:35:01 +00:00
ExpEmit FxVectorValue::Emit(VMFunctionBuilder *build)
- implemented local vector variables. Currently only the definition plus initial assignment works. - removed all vector4 handling that had already been added, now that this type can no longer be defined.
2016-10-28 13:15:30 +00:00
{
- fixed a typo in the bool cast. - fixed a few places for unsigned values.
2016-12-01 08:44:52 +00:00
// no const handling here. Ultimately it's too rarely used (i.e. the only fully constant vector ever allocated in ZDoom is the 0-vector in a very few places)
- implemented local vector variables. Currently only the definition plus initial assignment works. - removed all vector4 handling that had already been added, now that this type can no longer be defined.
2016-10-28 13:15:30 +00:00
// and the negatives (excessive allocation of float constants) outweigh the positives (saved a few instructions)
assert(xyz[0] != nullptr);
assert(xyz[1] != nullptr);
if (ValueType == TypeVector2)
{
- Fixed GCC/Clang errors from recent commits.
2016-10-30 12:43:20 +00:00
ExpEmit tempxval = xyz[0]->Emit(build);
ExpEmit tempyval = xyz[1]->Emit(build);
ExpEmit xval = EmitKonst(build, tempxval);
ExpEmit yval = EmitKonst(build, tempyval);
- implemented local vector variables. Currently only the definition plus initial assignment works. - removed all vector4 handling that had already been added, now that this type can no longer be defined.
2016-10-28 13:15:30 +00:00
assert(xval.RegType == REGT_FLOAT && yval.RegType == REGT_FLOAT);
if (yval.RegNum == xval.RegNum + 1)
{
// The results are already in two continuous registers so just return them as-is.
xval.RegCount++;
return xval;
}
else
{
// The values are not in continuous registers so they need to be copied together now.
ExpEmit out(build, REGT_FLOAT, 2);
build->Emit(OP_MOVEF, out.RegNum, xval.RegNum);
build->Emit(OP_MOVEF, out.RegNum + 1, yval.RegNum);
xval.Free(build);
yval.Free(build);
return out;
}
}
else if (xyz[0]->ValueType == TypeVector2) // vec2+float
{
ExpEmit xyval = xyz[0]->Emit(build);
- Fixed GCC/Clang errors from recent commits.
2016-10-30 12:43:20 +00:00
ExpEmit tempzval = xyz[1]->Emit(build);
ExpEmit zval = EmitKonst(build, tempzval);
- implemented local vector variables. Currently only the definition plus initial assignment works. - removed all vector4 handling that had already been added, now that this type can no longer be defined.
2016-10-28 13:15:30 +00:00
assert(xyval.RegType == REGT_FLOAT && xyval.RegCount == 2 && zval.RegType == REGT_FLOAT);
if (zval.RegNum == xyval.RegNum + 2)
{
// The results are already in three continuous registers so just return them as-is.
xyval.RegCount++;
return xyval;
}
else
{
// The values are not in continuous registers so they need to be copied together now.
ExpEmit out(build, REGT_FLOAT, 3);
build->Emit(OP_MOVEV2, out.RegNum, xyval.RegNum);
build->Emit(OP_MOVEF, out.RegNum + 2, zval.RegNum);
xyval.Free(build);
zval.Free(build);
return out;
}
}
else // 3*float
{
assert(xyz[2] != nullptr);
- Fixed GCC/Clang errors from recent commits.
2016-10-30 12:43:20 +00:00
ExpEmit tempxval = xyz[0]->Emit(build);
ExpEmit tempyval = xyz[1]->Emit(build);
ExpEmit tempzval = xyz[2]->Emit(build);
ExpEmit xval = EmitKonst(build, tempxval);
ExpEmit yval = EmitKonst(build, tempyval);
ExpEmit zval = EmitKonst(build, tempzval);
- implemented local vector variables. Currently only the definition plus initial assignment works. - removed all vector4 handling that had already been added, now that this type can no longer be defined.
2016-10-28 13:15:30 +00:00
assert(xval.RegType == REGT_FLOAT && yval.RegType == REGT_FLOAT && zval.RegType == REGT_FLOAT);
if (yval.RegNum == xval.RegNum + 1 && zval.RegNum == xval.RegNum + 2)
{
// The results are already in three continuous registers so just return them as-is.
xval.RegCount += 2;
return xval;
}
else
{
// The values are not in continuous registers so they need to be copied together now.
ExpEmit out(build, REGT_FLOAT, 3);
//Try to optimize a bit...
if (yval.RegNum == xval.RegNum + 1)
{
build->Emit(OP_MOVEV2, out.RegNum, xval.RegNum);
build->Emit(OP_MOVEF, out.RegNum + 2, zval.RegNum);
}
else if (zval.RegNum == yval.RegNum + 1)
{
build->Emit(OP_MOVEF, out.RegNum, xval.RegNum);
build->Emit(OP_MOVEV2, out.RegNum+1, yval.RegNum);
}
else
{
build->Emit(OP_MOVEF, out.RegNum, xval.RegNum);
build->Emit(OP_MOVEF, out.RegNum + 1, yval.RegNum);
build->Emit(OP_MOVEF, out.RegNum + 2, zval.RegNum);
}
xval.Free(build);
yval.Free(build);
zval.Free(build);
return out;
}
}
}
//==========================================================================
//
//
//
//==========================================================================
- added an optimization to FxBoolCast that it doesn't force the source value to a 0/1 integer if not explicitly needed. When doing comparisons we do not care about actual values, we only want to know if it is 0 or not. - added the above for the 'if' condition. It works for integers, floats and pointers and will save 3 instructions if the condition is a non-boolean that can be implicitly casted to bool.
2016-10-23 13:30:58 +00:00
FxBoolCast::FxBoolCast(FxExpression *x, bool needvalue)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_BoolCast, x->ScriptPosition)
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
{
basex = x;
ValueType = TypeBool;
- added an optimization to FxBoolCast that it doesn't force the source value to a 0/1 integer if not explicitly needed. When doing comparisons we do not care about actual values, we only want to know if it is 0 or not. - added the above for the 'if' condition. It works for integers, floats and pointers and will save 3 instructions if the condition is a non-boolean that can be implicitly casted to bool.
2016-10-23 13:30:58 +00:00
NeedValue = needvalue;
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
}
//==========================================================================
//
//
//
//==========================================================================
FxBoolCast::~FxBoolCast()
{
SAFE_DELETE(basex);
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxBoolCast::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE(basex, ctx);
if (basex->ValueType == TypeBool)
{
FxExpression *x = basex;
basex = nullptr;
delete this;
return x;
}
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
else if (basex->IsBoolCompat())
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
{
if (basex->isConstant())
{
assert(basex->ValueType != TypeState && "We shouldn't be able to generate a constant state ref");
ExpVal constval = static_cast<FxConstant *>(basex)->GetValue();
FxExpression *x = new FxConstant(constval.GetBool(), ScriptPosition);
delete this;
return x;
}
return this;
}
ScriptPosition.Message(MSG_ERROR, "Numeric type expected");
delete this;
return nullptr;
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxBoolCast::Emit(VMFunctionBuilder *build)
{
ExpEmit from = basex->Emit(build);
assert(!from.Konst);
assert(basex->ValueType->GetRegType() == REGT_INT || basex->ValueType->GetRegType() == REGT_FLOAT || basex->ValueType->GetRegType() == REGT_POINTER);
- added an optimization to FxBoolCast that it doesn't force the source value to a 0/1 integer if not explicitly needed. When doing comparisons we do not care about actual values, we only want to know if it is 0 or not. - added the above for the 'if' condition. It works for integers, floats and pointers and will save 3 instructions if the condition is a non-boolean that can be implicitly casted to bool.
2016-10-23 13:30:58 +00:00
if (NeedValue)
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
{
- added an optimization to FxBoolCast that it doesn't force the source value to a 0/1 integer if not explicitly needed. When doing comparisons we do not care about actual values, we only want to know if it is 0 or not. - added the above for the 'if' condition. It works for integers, floats and pointers and will save 3 instructions if the condition is a non-boolean that can be implicitly casted to bool.
2016-10-23 13:30:58 +00:00
ExpEmit to(build, REGT_INT);
from.Free(build);
- added a boolean cast VM instruction. Although this already helps a lot with the messed up code generated for comparisons it's not really a solution for this - it still needs a proper implementation to generate efficient code.
2016-12-01 00:13:53 +00:00
build->Emit(OP_CASTB, to.RegNum, from.RegNum, from.RegType == REGT_INT ? CASTB_I : from.RegType == REGT_FLOAT ? CASTB_F : CASTB_A);
- added an optimization to FxBoolCast that it doesn't force the source value to a 0/1 integer if not explicitly needed. When doing comparisons we do not care about actual values, we only want to know if it is 0 or not. - added the above for the 'if' condition. It works for integers, floats and pointers and will save 3 instructions if the condition is a non-boolean that can be implicitly casted to bool.
2016-10-23 13:30:58 +00:00
return to;
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
}
- added an optimization to FxBoolCast that it doesn't force the source value to a 0/1 integer if not explicitly needed. When doing comparisons we do not care about actual values, we only want to know if it is 0 or not. - added the above for the 'if' condition. It works for integers, floats and pointers and will save 3 instructions if the condition is a non-boolean that can be implicitly casted to bool.
2016-10-23 13:30:58 +00:00
else
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
{
- added an optimization to FxBoolCast that it doesn't force the source value to a 0/1 integer if not explicitly needed. When doing comparisons we do not care about actual values, we only want to know if it is 0 or not. - added the above for the 'if' condition. It works for integers, floats and pointers and will save 3 instructions if the condition is a non-boolean that can be implicitly casted to bool.
2016-10-23 13:30:58 +00:00
return from;
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
}
}
//==========================================================================
//
//
//
//==========================================================================
- branch optimization.
2016-12-01 23:51:29 +00:00
void FxBoolCast::EmitCompare(VMFunctionBuilder *build, bool invert, TArray<size_t> &patchspots_yes, TArray<size_t> &patchspots_no)
{
basex->EmitCompare(build, invert, patchspots_yes, patchspots_no);
}
//==========================================================================
//
//
//
//==========================================================================
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
FxIntCast::FxIntCast(FxExpression *x, bool nowarn, bool explicitly)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_IntCast, x->ScriptPosition)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
basex=x;
ValueType = TypeSInt32;
- the compile context now knows if it is invoked by ZScript or DECORATE, so that it can be more strict with ZScript if needed. - added a truncation warning to FxIntCast, which only occurs with ZScript, not with DECORATE. FxBoolCast is intentionally left out because it would defeat the reason for this cast type.
2016-10-15 19:35:31 +00:00
NoWarn = nowarn;
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
Explicit = explicitly;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
//
//
//==========================================================================
FxIntCast::~FxIntCast()
{
SAFE_DELETE(basex);
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxIntCast::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE(basex, ctx);
if (basex->ValueType->GetRegType() == REGT_INT)
{
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
if (basex->ValueType->isNumeric() || Explicit) // names can be converted to int, but only with an explicit type cast.
- reinstated abort-on-error for any problem that gets reported during DECORATE code generation. - fixed: DECORATE allowed a silent conversion from names to integers. In old versions the name was converted to 0, since the scripting branch to the name index. Reverted to the old behavior but added a warning message.
2016-06-08 08:46:35 +00:00
{
FxExpression *x = basex;
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
x->ValueType = ValueType;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
basex = nullptr;
- reinstated abort-on-error for any problem that gets reported during DECORATE code generation. - fixed: DECORATE allowed a silent conversion from names to integers. In old versions the name was converted to 0, since the scripting branch to the name index. Reverted to the old behavior but added a warning message.
2016-06-08 08:46:35 +00:00
delete this;
return x;
}
else
{
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
// Ugh. This should abort, but too many mods fell into this logic hole somewhere, so this serious error needs to be reduced to a warning. :(
- the compile context now knows if it is invoked by ZScript or DECORATE, so that it can be more strict with ZScript if needed. - added a truncation warning to FxIntCast, which only occurs with ZScript, not with DECORATE. FxBoolCast is intentionally left out because it would defeat the reason for this cast type.
2016-10-15 19:35:31 +00:00
// At least in ZScript, MSG_OPTERROR always means to report an error, not a warning so the problem only exists in DECORATE.
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
if (!basex->isConstant())
ScriptPosition.Message(MSG_OPTERROR, "Numeric type expected, got a name");
- 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
else ScriptPosition.Message(MSG_OPTERROR, "Numeric type expected, got \"%s\"", static_cast<FxConstant*>(basex)->GetValue().GetName().GetChars());
- reinstated abort-on-error for any problem that gets reported during DECORATE code generation. - fixed: DECORATE allowed a silent conversion from names to integers. In old versions the name was converted to 0, since the scripting branch to the name index. Reverted to the old behavior but added a warning message.
2016-06-08 08:46:35 +00:00
FxExpression * x = new FxConstant(0, ScriptPosition);
delete this;
return x;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
else if (basex->IsFloat())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
if (basex->isConstant())
{
ExpVal constval = static_cast<FxConstant *>(basex)->GetValue();
FxExpression *x = new FxConstant(constval.GetInt(), ScriptPosition);
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
if (constval.GetInt() != constval.GetFloat())
- the compile context now knows if it is invoked by ZScript or DECORATE, so that it can be more strict with ZScript if needed. - added a truncation warning to FxIntCast, which only occurs with ZScript, not with DECORATE. FxBoolCast is intentionally left out because it would defeat the reason for this cast type.
2016-10-15 19:35:31 +00:00
{
ScriptPosition.Message(MSG_WARNING, "Truncation of floating point constant %f", constval.GetFloat());
}
Normalize line endings
2016-03-01 15:47:10 +00:00
delete this;
return x;
}
- the compile context now knows if it is invoked by ZScript or DECORATE, so that it can be more strict with ZScript if needed. - added a truncation warning to FxIntCast, which only occurs with ZScript, not with DECORATE. FxBoolCast is intentionally left out because it would defeat the reason for this cast type.
2016-10-15 19:35:31 +00:00
else if (!NoWarn)
{
- made the floating point truncation warning a debug message because I can see this becoming more a hassle than an asset.
2016-11-15 15:00:35 +00:00
ScriptPosition.Message(MSG_DEBUGWARN, "Truncation of floating point value");
- the compile context now knows if it is invoked by ZScript or DECORATE, so that it can be more strict with ZScript if needed. - added a truncation warning to FxIntCast, which only occurs with ZScript, not with DECORATE. FxBoolCast is intentionally left out because it would defeat the reason for this cast type.
2016-10-15 19:35:31 +00:00
}
Normalize line endings
2016-03-01 15:47:10 +00:00
return this;
}
- reinstated abort-on-error for any problem that gets reported during DECORATE code generation. - fixed: DECORATE allowed a silent conversion from names to integers. In old versions the name was converted to 0, since the scripting branch to the name index. Reverted to the old behavior but added a warning message.
2016-06-08 08:46:35 +00:00
ScriptPosition.Message(MSG_ERROR, "Numeric type expected");
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxIntCast::Emit(VMFunctionBuilder *build)
{
ExpEmit from = basex->Emit(build);
assert(!from.Konst);
assert(basex->ValueType->GetRegType() == REGT_FLOAT);
from.Free(build);
ExpEmit to(build, REGT_INT);
- added missing unsigned casts to the VM. - make the pointer to string cast a bit more useful by using the actual object's type rather than 'Object' which can be a great asset when debugging. - fixed a few bad asserts.
2016-11-18 13:50:21 +00:00
build->Emit(OP_CAST, to.RegNum, from.RegNum, ValueType == TypeUInt32? CAST_F2U : CAST_F2I);
Normalize line endings
2016-03-01 15:47:10 +00:00
return to;
}
//==========================================================================
//
//
//
//==========================================================================
FxFloatCast::FxFloatCast(FxExpression *x)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_FloatCast, x->ScriptPosition)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- 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
basex = x;
Normalize line endings
2016-03-01 15:47:10 +00:00
ValueType = TypeFloat64;
}
//==========================================================================
//
//
//
//==========================================================================
FxFloatCast::~FxFloatCast()
{
SAFE_DELETE(basex);
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxFloatCast::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE(basex, ctx);
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
if (basex->IsFloat())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
FxExpression *x = basex;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
basex = nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
delete this;
return x;
}
else if (basex->ValueType->GetRegType() == REGT_INT)
{
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
if (basex->ValueType->isNumeric())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- reinstated abort-on-error for any problem that gets reported during DECORATE code generation. - fixed: DECORATE allowed a silent conversion from names to integers. In old versions the name was converted to 0, since the scripting branch to the name index. Reverted to the old behavior but added a warning message.
2016-06-08 08:46:35 +00:00
if (basex->isConstant())
{
ExpVal constval = static_cast<FxConstant *>(basex)->GetValue();
FxExpression *x = new FxConstant(constval.GetFloat(), ScriptPosition);
delete this;
return x;
}
return this;
}
else
{
// Ugh. This should abort, but too many mods fell into this logic hole somewhere, so this seroious error needs to be reduced to a warning. :(
- the compile context now knows if it is invoked by ZScript or DECORATE, so that it can be more strict with ZScript if needed. - added a truncation warning to FxIntCast, which only occurs with ZScript, not with DECORATE. FxBoolCast is intentionally left out because it would defeat the reason for this cast type.
2016-10-15 19:35:31 +00:00
// At least in ZScript, MSG_OPTERROR always means to report an error, not a warning so the problem only exists in DECORATE.
- 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
if (!basex->isConstant()) ScriptPosition.Message(MSG_OPTERROR, "Numeric type expected, got a name");
else ScriptPosition.Message(MSG_OPTERROR, "Numeric type expected, got \"%s\"", static_cast<FxConstant*>(basex)->GetValue().GetName().GetChars());
- reinstated abort-on-error for any problem that gets reported during DECORATE code generation. - fixed: DECORATE allowed a silent conversion from names to integers. In old versions the name was converted to 0, since the scripting branch to the name index. Reverted to the old behavior but added a warning message.
2016-06-08 08:46:35 +00:00
FxExpression *x = new FxConstant(0.0, ScriptPosition);
Normalize line endings
2016-03-01 15:47:10 +00:00
delete this;
return x;
}
}
else
{
ScriptPosition.Message(MSG_ERROR, "Numeric type expected");
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxFloatCast::Emit(VMFunctionBuilder *build)
{
ExpEmit from = basex->Emit(build);
assert(!from.Konst);
assert(basex->ValueType->GetRegType() == REGT_INT);
from.Free(build);
ExpEmit to(build, REGT_FLOAT);
- added missing unsigned casts to the VM. - make the pointer to string cast a bit more useful by using the actual object's type rather than 'Object' which can be a great asset when debugging. - fixed a few bad asserts.
2016-11-18 13:50:21 +00:00
build->Emit(OP_CAST, to.RegNum, from.RegNum, basex->ValueType == TypeUInt32? CAST_U2F : CAST_I2F);
Normalize line endings
2016-03-01 15:47:10 +00:00
return to;
}
//==========================================================================
//
//
//
//==========================================================================
- scriptified the RandomSpawner. - fixed: String constants were not processed by the compiler backend. - added an explicit name cast for class types.
2017-01-14 01:05:52 +00:00
FxNameCast::FxNameCast(FxExpression *x, bool explicitly)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_NameCast, x->ScriptPosition)
- 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
{
basex = x;
ValueType = TypeName;
- scriptified the RandomSpawner. - fixed: String constants were not processed by the compiler backend. - added an explicit name cast for class types.
2017-01-14 01:05:52 +00:00
mExplicit = explicitly;
- 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
}
//==========================================================================
//
//
//
//==========================================================================
FxNameCast::~FxNameCast()
{
SAFE_DELETE(basex);
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxNameCast::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE(basex, ctx);
- scriptified the RandomSpawner. - fixed: String constants were not processed by the compiler backend. - added an explicit name cast for class types.
2017-01-14 01:05:52 +00:00
if (mExplicit && basex->ValueType->IsKindOf(RUNTIME_CLASS(PClassPointer)))
{
if (basex->isConstant())
{
auto constval = static_cast<FxConstant *>(basex)->GetValue().GetPointer();
FxExpression *x = new FxConstant(static_cast<PClass*>(constval)->TypeName, ScriptPosition);
delete this;
return x;
}
return this;
}
else if (basex->ValueType == TypeName)
- 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
{
FxExpression *x = basex;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
basex = nullptr;
- 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
delete this;
return x;
}
else if (basex->ValueType == TypeString)
{
if (basex->isConstant())
{
ExpVal constval = static_cast<FxConstant *>(basex)->GetValue();
FxExpression *x = new FxConstant(constval.GetName(), ScriptPosition);
delete this;
return x;
}
return this;
}
else
{
ScriptPosition.Message(MSG_ERROR, "Cannot convert to name");
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
- 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
}
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxNameCast::Emit(VMFunctionBuilder *build)
{
- scriptified the RandomSpawner. - fixed: String constants were not processed by the compiler backend. - added an explicit name cast for class types.
2017-01-14 01:05:52 +00:00
if (basex->ValueType == TypeString)
{
ExpEmit from = basex->Emit(build);
assert(!from.Konst);
assert(basex->ValueType == TypeString);
from.Free(build);
ExpEmit to(build, REGT_INT);
build->Emit(OP_CAST, to.RegNum, from.RegNum, CAST_S2N);
return to;
}
else
{
ExpEmit ptr = basex->Emit(build);
assert(ptr.RegType == REGT_POINTER);
ptr.Free(build);
ExpEmit to(build, REGT_INT);
build->Emit(OP_LW, to.RegNum, ptr.RegNum, build->GetConstantInt(myoffsetof(PClassActor, TypeName)));
return to;
}
- 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
}
//==========================================================================
//
//
//
//==========================================================================
FxStringCast::FxStringCast(FxExpression *x)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_StringCast, x->ScriptPosition)
- 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
{
basex = x;
ValueType = TypeString;
}
//==========================================================================
//
//
//
//==========================================================================
FxStringCast::~FxStringCast()
{
SAFE_DELETE(basex);
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxStringCast::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE(basex, ctx);
if (basex->ValueType == TypeString)
{
FxExpression *x = basex;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
basex = nullptr;
- 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
delete this;
return x;
}
else if (basex->ValueType == TypeName)
{
if (basex->isConstant())
{
ExpVal constval = static_cast<FxConstant *>(basex)->GetValue();
FxExpression *x = new FxConstant(constval.GetString(), ScriptPosition);
delete this;
return x;
}
return this;
}
else if (basex->ValueType == TypeSound)
{
if (basex->isConstant())
{
ExpVal constval = static_cast<FxConstant *>(basex)->GetValue();
FxExpression *x = new FxConstant(S_sfx[constval.GetInt()].name, ScriptPosition);
delete this;
return x;
}
return this;
}
// although it could be done, let's not convert colors back to strings.
else
{
ScriptPosition.Message(MSG_ERROR, "Cannot convert to string");
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
- 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
}
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxStringCast::Emit(VMFunctionBuilder *build)
{
ExpEmit from = basex->Emit(build);
assert(!from.Konst);
from.Free(build);
ExpEmit to(build, REGT_STRING);
- fixed initialization of local variables with other local variables. - fixed several occurenced where vectors were treated as floats. NOTE: The entire codegen.cpp file needs to be carefully reviewed for bad use of the REGT_ constants, there's probably more places where using them has broken some type checks. - fixed: committed test version of zscript.txt instead of changed actor.txt by accident. Initialization and assignment for strings is working with this commit.
2016-10-29 14:49:21 +00:00
if (basex->ValueType == TypeName)
- 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
{
build->Emit(OP_CAST, to.RegNum, from.RegNum, CAST_N2S);
}
- fixed initialization of local variables with other local variables. - fixed several occurenced where vectors were treated as floats. NOTE: The entire codegen.cpp file needs to be carefully reviewed for bad use of the REGT_ constants, there's probably more places where using them has broken some type checks. - fixed: committed test version of zscript.txt instead of changed actor.txt by accident. Initialization and assignment for strings is working with this commit.
2016-10-29 14:49:21 +00:00
else if (basex->ValueType == TypeSound)
- 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
{
build->Emit(OP_CAST, to.RegNum, from.RegNum, CAST_So2S);
}
return to;
}
//==========================================================================
//
//
//
//==========================================================================
FxColorCast::FxColorCast(FxExpression *x)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_ColorCast, x->ScriptPosition)
- 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
{
basex = x;
ValueType = TypeColor;
}
//==========================================================================
//
//
//
//==========================================================================
FxColorCast::~FxColorCast()
{
SAFE_DELETE(basex);
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxColorCast::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE(basex, ctx);
if (basex->ValueType == TypeColor || basex->ValueType->GetClass() == RUNTIME_CLASS(PInt))
{
FxExpression *x = basex;
x->ValueType = TypeColor;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
basex = nullptr;
- 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
delete this;
return x;
}
else if (basex->ValueType == TypeString)
{
if (basex->isConstant())
{
ExpVal constval = static_cast<FxConstant *>(basex)->GetValue();
- added a new variable flag that allows defining variables which can only be modified by internal script code but not by external mods. Currently this is used by the NoBlockmap and NoSector flags which need special handling for changing.
2016-11-08 10:12:56 +00:00
if (constval.GetString().Len() == 0)
{
// empty string means 'no state'. This would otherwise just cause endless errors and have the same result anyway.
FxExpression *x = new FxConstant(-1, ScriptPosition);
delete this;
return x;
}
else
{
- optionally allow passing a script position object to V_GetColor and subfunctions for better error output. Implemented this for all occurences where this info was available.
2016-12-03 15:27:53 +00:00
FxExpression *x = new FxConstant(V_GetColor(nullptr, constval.GetString(), &ScriptPosition), ScriptPosition);
- added a new variable flag that allows defining variables which can only be modified by internal script code but not by external mods. Currently this is used by the NoBlockmap and NoSector flags which need special handling for changing.
2016-11-08 10:12:56 +00:00
delete this;
return x;
}
- 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
}
return this;
}
else
{
ScriptPosition.Message(MSG_ERROR, "Cannot convert to color");
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
- 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
}
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxColorCast::Emit(VMFunctionBuilder *build)
{
ExpEmit from = basex->Emit(build);
assert(!from.Konst);
assert(basex->ValueType == TypeString);
from.Free(build);
ExpEmit to(build, REGT_INT);
build->Emit(OP_CAST, to.RegNum, from.RegNum, CAST_S2Co);
return to;
}
//==========================================================================
//
//
//
//==========================================================================
FxSoundCast::FxSoundCast(FxExpression *x)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_SoundCast, x->ScriptPosition)
- 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
{
basex = x;
ValueType = TypeSound;
}
//==========================================================================
//
//
//
//==========================================================================
FxSoundCast::~FxSoundCast()
{
SAFE_DELETE(basex);
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxSoundCast::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE(basex, ctx);
if (basex->ValueType == TypeSound || basex->ValueType->GetClass() == RUNTIME_CLASS(PInt))
{
FxExpression *x = basex;
x->ValueType = TypeSound;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
basex = nullptr;
- 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
delete this;
return x;
}
else if (basex->ValueType == TypeString)
{
if (basex->isConstant())
{
ExpVal constval = static_cast<FxConstant *>(basex)->GetValue();
FxExpression *x = new FxConstant(FSoundID(constval.GetString()), ScriptPosition);
delete this;
return x;
}
return this;
}
else
{
ScriptPosition.Message(MSG_ERROR, "Cannot convert to sound");
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
- 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
}
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxSoundCast::Emit(VMFunctionBuilder *build)
{
ExpEmit from = basex->Emit(build);
assert(!from.Konst);
assert(basex->ValueType == TypeString);
from.Free(build);
ExpEmit to(build, REGT_INT);
build->Emit(OP_CAST, to.RegNum, from.RegNum, CAST_S2So);
return to;
}
//==========================================================================
//
// generic type cast operator
//
//==========================================================================
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
FxTypeCast::FxTypeCast(FxExpression *x, PType *type, bool nowarn, bool explicitly)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_TypeCast, x->ScriptPosition)
- 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
{
basex = x;
ValueType = type;
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
NoWarn = nowarn;
Explicit = explicitly;
-fixed type handling for varargs (i.e. A_Jump.)
2016-10-26 12:15:11 +00:00
assert(ValueType != nullptr);
- 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
}
//==========================================================================
//
//
//
//==========================================================================
FxTypeCast::~FxTypeCast()
{
SAFE_DELETE(basex);
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxTypeCast::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE(basex, ctx);
// first deal with the simple types
if (ValueType == TypeError || basex->ValueType == TypeError)
{
- implemented super calls and proper dispatch of scripted virtual overrides for Destroy.
2016-11-11 20:52:08 +00:00
ScriptPosition.Message(MSG_ERROR, "Trying to cast to invalid type.");
- 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
delete this;
return nullptr;
}
else if (ValueType == TypeVoid) // this should never happen
{
goto errormsg;
}
else if (basex->ValueType == TypeVoid)
{
goto errormsg;
}
else if (basex->ValueType == ValueType)
{
// don't go through the entire list if the types are the same.
goto basereturn;
}
- preparations for null pointer support. - add pointer support to FxAssign.
2016-10-21 17:18:39 +00:00
else if (basex->ValueType == TypeNullPtr && (ValueType == TypeState || ValueType->IsKindOf(RUNTIME_CLASS(PPointer))))
{
goto basereturn;
}
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
else if (IsFloat())
- 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
{
FxExpression *x = new FxFloatCast(basex);
x = x->Resolve(ctx);
basex = nullptr;
delete this;
return x;
}
else if (ValueType->IsA(RUNTIME_CLASS(PInt)))
{
// This is only for casting to actual ints. Subtypes representing an int will be handled elsewhere.
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
FxExpression *x = new FxIntCast(basex, NoWarn, Explicit);
- 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
x = x->Resolve(ctx);
basex = nullptr;
delete this;
return x;
}
else if (ValueType == TypeBool)
{
FxExpression *x = new FxBoolCast(basex);
x = x->Resolve(ctx);
basex = nullptr;
delete this;
return x;
}
else if (ValueType == TypeString)
{
FxExpression *x = new FxStringCast(basex);
x = x->Resolve(ctx);
basex = nullptr;
delete this;
return x;
}
else if (ValueType == TypeName)
{
- scriptified the RandomSpawner. - fixed: String constants were not processed by the compiler backend. - added an explicit name cast for class types.
2017-01-14 01:05:52 +00:00
FxExpression *x = new FxNameCast(basex, Explicit);
- 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
x = x->Resolve(ctx);
basex = nullptr;
delete this;
return x;
}
else if (ValueType == TypeSound)
{
FxExpression *x = new FxSoundCast(basex);
x = x->Resolve(ctx);
basex = nullptr;
delete this;
return x;
}
else if (ValueType == TypeColor)
{
FxExpression *x = new FxColorCast(basex);
x = x->Resolve(ctx);
basex = nullptr;
delete this;
return x;
}
- scriptified the scripted marines. - fixed symbol name generation for native functions. - moved PrintableName to VMFunction so that native functions also have this information.
2016-11-21 18:09:58 +00:00
else if (ValueType == TypeSpriteID && basex->IsInteger())
{
basex->ValueType = TypeSpriteID;
auto x = basex;
basex = nullptr;
delete this;
return x;
}
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
else if (ValueType == TypeStateLabel)
- 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
{
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
if (basex->ValueType == TypeNullPtr)
{
auto x = new FxConstant(0, ScriptPosition);
x->ValueType = TypeStateLabel;
delete this;
return x;
}
- 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
// Right now this only supports string constants. There should be an option to pass a string variable, too.
if (basex->isConstant() && (basex->ValueType == TypeString || basex->ValueType == TypeName))
{
- fixed bad conversion from FString to const char * in state label type cast.
2016-11-19 11:25:53 +00:00
FString s= static_cast<FxConstant *>(basex)->GetValue().GetString();
if (s.Len() == 0 && !ctx.FromDecorate) // DECORATE should never get here at all, but let's better be safe.
- block "" and 0 as valid state names in ZScript. There were common workarounds for the lack of a null pointer in DECORATE which no longer are supported as those and would produce errors now.
2016-11-06 11:00:16 +00:00
{
ScriptPosition.Message(MSG_ERROR, "State jump to empty label.");
delete this;
return nullptr;
}
FxExpression *x = new FxMultiNameState(s, basex->ScriptPosition);
- 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
x = x->Resolve(ctx);
basex = nullptr;
delete this;
return x;
}
- fixed: The states parser tried to simplify the head node for random duration but it has to simplify the two value nodes separately. - added jump by index to ZScript.
2016-11-04 23:39:00 +00:00
else if (basex->IsNumeric() && basex->ValueType != TypeSound && basex->ValueType != TypeColor)
{
- fixed and cleaned up state index jump handling * use the function build list instead of the function to pass the info. The function is permanent so not the best place for compile-time info. * pass along the current state index which is needed to calculate the target state.
2016-11-06 12:14:46 +00:00
if (ctx.StateIndex < 0)
- fixed: The states parser tried to simplify the head node for random duration but it has to simplify the two value nodes separately. - added jump by index to ZScript.
2016-11-04 23:39:00 +00:00
{
ScriptPosition.Message(MSG_ERROR, "State jumps with index can only be used in anonymous state functions.");
delete this;
return nullptr;
}
- fixed and cleaned up state index jump handling * use the function build list instead of the function to pass the info. The function is permanent so not the best place for compile-time info. * pass along the current state index which is needed to calculate the target state.
2016-11-06 12:14:46 +00:00
if (ctx.StateCount != 1)
- fixed: The states parser tried to simplify the head node for random duration but it has to simplify the two value nodes separately. - added jump by index to ZScript.
2016-11-04 23:39:00 +00:00
{
ScriptPosition.Message(MSG_ERROR, "State jumps with index cannot be used on multistate definitions");
delete this;
return nullptr;
}
- don't run constant state indices through the runtime checker.
2016-11-05 17:15:53 +00:00
if (basex->isConstant())
{
int i = static_cast<FxConstant *>(basex)->GetValue().GetInt();
- block "" and 0 as valid state names in ZScript. There were common workarounds for the lack of a null pointer in DECORATE which no longer are supported as those and would produce errors now.
2016-11-06 11:00:16 +00:00
if (i <= 0)
- don't run constant state indices through the runtime checker.
2016-11-05 17:15:53 +00:00
{
ScriptPosition.Message(MSG_ERROR, "State index must be positive");
delete this;
return nullptr;
}
- fixed and cleaned up state index jump handling * use the function build list instead of the function to pass the info. The function is permanent so not the best place for compile-time info. * pass along the current state index which is needed to calculate the target state.
2016-11-06 12:14:46 +00:00
FxExpression *x = new FxStateByIndex(ctx.StateIndex + i, ScriptPosition);
- don't run constant state indices through the runtime checker.
2016-11-05 17:15:53 +00:00
x = x->Resolve(ctx);
basex = nullptr;
delete this;
return x;
}
else
{
FxExpression *x = new FxRuntimeStateIndex(basex);
x = x->Resolve(ctx);
basex = nullptr;
delete this;
return x;
}
- fixed: The states parser tried to simplify the head node for random duration but it has to simplify the two value nodes separately. - added jump by index to ZScript.
2016-11-04 23:39:00 +00:00
}
- 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
}
- 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
else if (ValueType->IsKindOf(RUNTIME_CLASS(PClassPointer)))
{
- fixed: only explicit class type casts must obey strict namespace rules, i.e. only '(class<type>)(variable_to_cast)' The general rule is as follows: A class name as a string will always be looked up fully, even if the class name gets shadows by another variable because strings are not identifiers. It is only class names as identifiers that must obey the rule that if it is not known yet or hidden by something else that it may not be found to ensure that the older variable does not take over the name if it gets reused.
2017-01-24 09:04:46 +00:00
FxExpression *x = new FxClassTypeCast(static_cast<PClassPointer*>(ValueType), basex, Explicit);
- 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
x = x->Resolve(ctx);
basex = nullptr;
delete this;
return x;
}
/* else if (ValueType->IsKindOf(RUNTIME_CLASS(PEnum)))
{
// this is not yet ready and does not get assigned to actual values.
}
*/
else if (ValueType->IsKindOf(RUNTIME_CLASS(PClass))) // this should never happen because the VM doesn't handle plain class types - just pointers
{
if (basex->ValueType->IsKindOf(RUNTIME_CLASS(PClass)))
{
// class types are only compatible if the base type is a descendant of the result type.
auto fromtype = static_cast<PClass *>(basex->ValueType);
auto totype = static_cast<PClass *>(ValueType);
if (fromtype->IsDescendantOf(totype)) goto basereturn;
}
}
- skriptified the skybox actors. - fixed code generation for internal pointed arrays, they were missing a pointer dereference.
2017-01-14 17:04:49 +00:00
else if (basex->ValueType->IsA(RUNTIME_CLASS(PNativeStruct)) && ValueType->IsKindOf(RUNTIME_CLASS(PPointer)) && static_cast<PPointer*>(ValueType)->PointedType == basex->ValueType)
{
bool writable;
basex->RequestAddress(ctx, &writable);
basex->ValueType = ValueType;
auto x = basex;
basex = nullptr;
delete this;
return x;
}
- added null pointer. - fixed: FxMemberIdentifier checked for ClassPointers instead of object pointers to resolve the left hand side of the expression. - allow comparison of pointers.
2016-10-21 22:50:04 +00:00
else if (AreCompatiblePointerTypes(ValueType, basex->ValueType))
- 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
{
- added null pointer. - fixed: FxMemberIdentifier checked for ClassPointers instead of object pointers to resolve the left hand side of the expression. - allow comparison of pointers.
2016-10-21 22:50:04 +00:00
goto basereturn;
- 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
}
// todo: pointers to class objects.
// All other types are only compatible to themselves and have already been handled above by the equality check.
// Anything that falls through here is not compatible and must print an error.
errormsg:
ScriptPosition.Message(MSG_ERROR, "Cannot convert %s to %s", basex->ValueType->DescriptiveName(), ValueType->DescriptiveName());
delete this;
return nullptr;
basereturn:
auto x = basex;
- added null pointer. - fixed: FxMemberIdentifier checked for ClassPointers instead of object pointers to resolve the left hand side of the expression. - allow comparison of pointers.
2016-10-21 22:50:04 +00:00
x->ValueType = ValueType;
- 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
basex = nullptr;
delete this;
return x;
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxTypeCast::Emit(VMFunctionBuilder *build)
{
assert(false);
// This should never be reached
return ExpEmit();
}
//==========================================================================
//
//
//
//==========================================================================
Normalize line endings
2016-03-01 15:47:10 +00:00
FxPlusSign::FxPlusSign(FxExpression *operand)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_PlusSign, operand->ScriptPosition)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
Operand=operand;
}
//==========================================================================
//
//
//
//==========================================================================
FxPlusSign::~FxPlusSign()
{
SAFE_DELETE(Operand);
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxPlusSign::Resolve(FCompileContext& ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE(Operand, ctx);
- implemented vector operations. Vectors are now fully working as local variables. - removed mulv_kr and divv_kr instructions. The first are redundant and the second are useless. Maybe remove all other vector/const operations as well? They won't get used by the code generator. - fixed disassembly of vector multiplication and division instructions.
2016-10-28 23:39:25 +00:00
if (Operand->IsNumeric() || Operand->IsVector())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
FxExpression *e = Operand;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
Operand = nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
delete this;
return e;
}
else
{
ScriptPosition.Message(MSG_ERROR, "Numeric type expected");
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
ExpEmit FxPlusSign::Emit(VMFunctionBuilder *build)
{
return Operand->Emit(build);
}
//==========================================================================
//
//
//
//==========================================================================
FxMinusSign::FxMinusSign(FxExpression *operand)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_MinusSign, operand->ScriptPosition)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
Operand=operand;
}
//==========================================================================
//
//
//
//==========================================================================
FxMinusSign::~FxMinusSign()
{
SAFE_DELETE(Operand);
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxMinusSign::Resolve(FCompileContext& ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE(Operand, ctx);
- implemented vector operations. Vectors are now fully working as local variables. - removed mulv_kr and divv_kr instructions. The first are redundant and the second are useless. Maybe remove all other vector/const operations as well? They won't get used by the code generator. - fixed disassembly of vector multiplication and division instructions.
2016-10-28 23:39:25 +00:00
if (Operand->IsNumeric() || Operand->IsVector())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
if (Operand->isConstant())
{
ExpVal val = static_cast<FxConstant *>(Operand)->GetValue();
FxExpression *e = val.Type->GetRegType() == REGT_INT ?
new FxConstant(-val.Int, ScriptPosition) :
new FxConstant(-val.Float, ScriptPosition);
delete this;
return e;
}
ValueType = Operand->ValueType;
return this;
}
else
{
ScriptPosition.Message(MSG_ERROR, "Numeric type expected");
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxMinusSign::Emit(VMFunctionBuilder *build)
{
assert(ValueType == Operand->ValueType);
ExpEmit from = Operand->Emit(build);
- scriptified Hexen's Dragon. - fixed several places in the code generator that did not consider locked registers for local variables: array indices, abs and floating point builtin functions. - added some debug aids to the bounds opcode. Just triggering an exception here which loses all relevant info is perfectly useless in a debug situation.
2016-11-16 18:18:21 +00:00
ExpEmit to;
Normalize line endings
2016-03-01 15:47:10 +00:00
assert(from.Konst == 0);
- implemented vector operations. Vectors are now fully working as local variables. - removed mulv_kr and divv_kr instructions. The first are redundant and the second are useless. Maybe remove all other vector/const operations as well? They won't get used by the code generator. - fixed disassembly of vector multiplication and division instructions.
2016-10-28 23:39:25 +00:00
assert(ValueType->GetRegCount() == from.RegCount);
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
// Do it in-place, unless a local variable
if (from.Fixed)
{
- scriptified Hexen's Dragon. - fixed several places in the code generator that did not consider locked registers for local variables: array indices, abs and floating point builtin functions. - added some debug aids to the bounds opcode. Just triggering an exception here which loses all relevant info is perfectly useless in a debug situation.
2016-11-16 18:18:21 +00:00
to = ExpEmit(build, from.RegType, from.RegCount);
from.Free(build);
}
else
{
to = from;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
}
Normalize line endings
2016-03-01 15:47:10 +00:00
if (ValueType->GetRegType() == REGT_INT)
{
- scriptified Hexen's Dragon. - fixed several places in the code generator that did not consider locked registers for local variables: array indices, abs and floating point builtin functions. - added some debug aids to the bounds opcode. Just triggering an exception here which loses all relevant info is perfectly useless in a debug situation.
2016-11-16 18:18:21 +00:00
build->Emit(OP_NEG, to.RegNum, from.RegNum, 0);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
assert(ValueType->GetRegType() == REGT_FLOAT);
- implemented vector operations. Vectors are now fully working as local variables. - removed mulv_kr and divv_kr instructions. The first are redundant and the second are useless. Maybe remove all other vector/const operations as well? They won't get used by the code generator. - fixed disassembly of vector multiplication and division instructions.
2016-10-28 23:39:25 +00:00
switch (from.RegCount)
{
case 1:
- scriptified Hexen's Dragon. - fixed several places in the code generator that did not consider locked registers for local variables: array indices, abs and floating point builtin functions. - added some debug aids to the bounds opcode. Just triggering an exception here which loses all relevant info is perfectly useless in a debug situation.
2016-11-16 18:18:21 +00:00
build->Emit(OP_FLOP, to.RegNum, from.RegNum, FLOP_NEG);
- implemented vector operations. Vectors are now fully working as local variables. - removed mulv_kr and divv_kr instructions. The first are redundant and the second are useless. Maybe remove all other vector/const operations as well? They won't get used by the code generator. - fixed disassembly of vector multiplication and division instructions.
2016-10-28 23:39:25 +00:00
break;
case 2:
- scriptified Hexen's Dragon. - fixed several places in the code generator that did not consider locked registers for local variables: array indices, abs and floating point builtin functions. - added some debug aids to the bounds opcode. Just triggering an exception here which loses all relevant info is perfectly useless in a debug situation.
2016-11-16 18:18:21 +00:00
build->Emit(OP_NEGV2, to.RegNum, from.RegNum);
- implemented vector operations. Vectors are now fully working as local variables. - removed mulv_kr and divv_kr instructions. The first are redundant and the second are useless. Maybe remove all other vector/const operations as well? They won't get used by the code generator. - fixed disassembly of vector multiplication and division instructions.
2016-10-28 23:39:25 +00:00
break;
case 3:
- scriptified Hexen's Dragon. - fixed several places in the code generator that did not consider locked registers for local variables: array indices, abs and floating point builtin functions. - added some debug aids to the bounds opcode. Just triggering an exception here which loses all relevant info is perfectly useless in a debug situation.
2016-11-16 18:18:21 +00:00
build->Emit(OP_NEGV3, to.RegNum, from.RegNum);
- implemented vector operations. Vectors are now fully working as local variables. - removed mulv_kr and divv_kr instructions. The first are redundant and the second are useless. Maybe remove all other vector/const operations as well? They won't get used by the code generator. - fixed disassembly of vector multiplication and division instructions.
2016-10-28 23:39:25 +00:00
break;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- scriptified Hexen's Dragon. - fixed several places in the code generator that did not consider locked registers for local variables: array indices, abs and floating point builtin functions. - added some debug aids to the bounds opcode. Just triggering an exception here which loses all relevant info is perfectly useless in a debug situation.
2016-11-16 18:18:21 +00:00
return to;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
//
//
//==========================================================================
FxUnaryNotBitwise::FxUnaryNotBitwise(FxExpression *operand)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_UnaryNotBitwise, operand->ScriptPosition)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
Operand=operand;
}
//==========================================================================
//
//
//
//==========================================================================
FxUnaryNotBitwise::~FxUnaryNotBitwise()
{
SAFE_DELETE(Operand);
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxUnaryNotBitwise::Resolve(FCompileContext& ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE(Operand, ctx);
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
if (ctx.FromDecorate && Operand->IsFloat() /* lax */)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
// DECORATE allows floats here so cast them to int.
- implemented vector operations. Vectors are now fully working as local variables. - removed mulv_kr and divv_kr instructions. The first are redundant and the second are useless. Maybe remove all other vector/const operations as well? They won't get used by the code generator. - fixed disassembly of vector multiplication and division instructions.
2016-10-28 23:39:25 +00:00
Operand = new FxIntCast(Operand, true);
Normalize line endings
2016-03-01 15:47:10 +00:00
Operand = Operand->Resolve(ctx);
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
if (Operand == nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
- implemented vector operations. Vectors are now fully working as local variables. - removed mulv_kr and divv_kr instructions. The first are redundant and the second are useless. Maybe remove all other vector/const operations as well? They won't get used by the code generator. - fixed disassembly of vector multiplication and division instructions.
2016-10-28 23:39:25 +00:00
// Names were not blocked in DECORATE here after the scripting branch merge. Now they are again.
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
if (!Operand->IsInteger())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
ScriptPosition.Message(MSG_ERROR, "Integer type expected");
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
if (Operand->isConstant())
{
int result = ~static_cast<FxConstant *>(Operand)->GetValue().GetInt();
FxExpression *e = new FxConstant(result, ScriptPosition);
- fixed a typo in the bool cast. - fixed a few places for unsigned values.
2016-12-01 08:44:52 +00:00
e->ValueType = Operand->ValueType == TypeUInt32 ? TypeUInt32 : TypeSInt32;
Normalize line endings
2016-03-01 15:47:10 +00:00
delete this;
return e;
}
- fixed a typo in the bool cast. - fixed a few places for unsigned values.
2016-12-01 08:44:52 +00:00
ValueType = Operand->ValueType == TypeUInt32? TypeUInt32 : TypeSInt32;
Normalize line endings
2016-03-01 15:47:10 +00:00
return this;
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxUnaryNotBitwise::Emit(VMFunctionBuilder *build)
{
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
assert(Operand->ValueType->GetRegType() == REGT_INT);
Normalize line endings
2016-03-01 15:47:10 +00:00
ExpEmit from = Operand->Emit(build);
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
assert(!from.Konst);
Normalize line endings
2016-03-01 15:47:10 +00:00
// Do it in-place.
build->Emit(OP_NOT, from.RegNum, from.RegNum, 0);
return from;
}
//==========================================================================
//
//
//
//==========================================================================
FxUnaryNotBoolean::FxUnaryNotBoolean(FxExpression *operand)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_UnaryNotBoolean, operand->ScriptPosition)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
Operand=operand;
}
//==========================================================================
//
//
//
//==========================================================================
FxUnaryNotBoolean::~FxUnaryNotBoolean()
{
SAFE_DELETE(Operand);
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxUnaryNotBoolean::Resolve(FCompileContext& ctx)
{
CHECKRESOLVED();
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
SAFE_RESOLVE(Operand, ctx);
Normalize line endings
2016-03-01 15:47:10 +00:00
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
if (Operand->ValueType != TypeBool)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
Operand = new FxBoolCast(Operand);
SAFE_RESOLVE(Operand, ctx);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
if (Operand->isConstant())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
bool result = !static_cast<FxConstant *>(Operand)->GetValue().GetBool();
FxExpression *e = new FxConstant(result, ScriptPosition);
Normalize line endings
2016-03-01 15:47:10 +00:00
delete this;
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
return e;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
ValueType = TypeBool;
Normalize line endings
2016-03-01 15:47:10 +00:00
return this;
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxUnaryNotBoolean::Emit(VMFunctionBuilder *build)
{
- fixed: FxUnaryNotBoolean is not necessarily TypeBoolean, it can be altered by a type cast so the asserts had to be adjusted to cover that case.
2016-11-15 12:52:38 +00:00
assert(Operand->ValueType == TypeBool);
assert(ValueType == TypeBool || IsInteger()); // this may have been changed by an int cast.
Normalize line endings
2016-03-01 15:47:10 +00:00
ExpEmit from = Operand->Emit(build);
- fixed: Readonly pointers never were flagged as such. - fixed: Assignment from a readonly to a read-allowed pointer must be an error. - made GetDefaultByType a builtin so that it can do proper type assignment to the result, which for a function would be problematic in this case, even if automatic type deduction was implemented. Since this returns the class defaults which are not a real object, the result cannot be subjected to a type cast. - error out if a type cast of a readonly pointer is attempted. - fixed: FxBooleanNot could clobber a local variable because it used the source register to manipulate the result.
2016-11-27 14:50:58 +00:00
from.Free(build);
ExpEmit to(build, REGT_INT);
Normalize line endings
2016-03-01 15:47:10 +00:00
assert(!from.Konst);
- scriptified the functions in a_possessed.cpp and added the needed exports and constants. - fixed: Script functions did not receive the function name when being created. - relaxed the asserts for PARAM_STATE, because the VM knows nothing about ATAG_STATE. Any state variable's content (e.g. Actor.SeeState) will receive ATAG_GENERIC, rather than ATAG_STATE. - added a 'NeedResult' flag so that certain operations can create shorter code if the result of the expression is not needed. So far only used for postdecrement/increment statements on local variables (which is the most frequent case where this matters.) - fixed postincrement and decrement for local variables. Due to the result preservation semantics it created faulty code.
2016-10-26 09:30:30 +00:00
// boolean not is the same as XOR-ing the lowest bit
- fixed: Readonly pointers never were flagged as such. - fixed: Assignment from a readonly to a read-allowed pointer must be an error. - made GetDefaultByType a builtin so that it can do proper type assignment to the result, which for a function would be problematic in this case, even if automatic type deduction was implemented. Since this returns the class defaults which are not a real object, the result cannot be subjected to a type cast. - error out if a type cast of a readonly pointer is attempted. - fixed: FxBooleanNot could clobber a local variable because it used the source register to manipulate the result.
2016-11-27 14:50:58 +00:00
build->Emit(OP_XOR_RK, to.RegNum, from.RegNum, build->GetConstantInt(1));
return to;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- handle all unary operators. - handle all binary operators which are already implemented in the code generator. - implemented sizeof/alignof operators in code generator. - rewrote RequestAddress so that its return value is not the writability of an address but the mere existence. Also changed it to not output errors itself because those cannot be dealt with by the calling function.
2016-10-17 18:33:35 +00:00
//==========================================================================
//
//
//
//==========================================================================
- branch optimization.
2016-12-01 23:51:29 +00:00
void FxUnaryNotBoolean::EmitCompare(VMFunctionBuilder *build, bool invert, TArray<size_t> &patchspots_yes, TArray<size_t> &patchspots_no)
{
Operand->EmitCompare(build, !invert, patchspots_yes, patchspots_no);
}
//==========================================================================
//
//
//
//==========================================================================
- handle all unary operators. - handle all binary operators which are already implemented in the code generator. - implemented sizeof/alignof operators in code generator. - rewrote RequestAddress so that its return value is not the writability of an address but the mere existence. Also changed it to not output errors itself because those cannot be dealt with by the calling function.
2016-10-17 18:33:35 +00:00
FxSizeAlign::FxSizeAlign(FxExpression *operand, int which)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_SizeAlign, operand->ScriptPosition)
- handle all unary operators. - handle all binary operators which are already implemented in the code generator. - implemented sizeof/alignof operators in code generator. - rewrote RequestAddress so that its return value is not the writability of an address but the mere existence. Also changed it to not output errors itself because those cannot be dealt with by the calling function.
2016-10-17 18:33:35 +00:00
{
Operand = operand;
Which = which;
}
//==========================================================================
//
//
//
//==========================================================================
FxSizeAlign::~FxSizeAlign()
{
SAFE_DELETE(Operand);
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxSizeAlign::Resolve(FCompileContext& ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE(Operand, ctx);
auto type = Operand->ValueType;
if (Operand->isConstant())
{
- implemented vector operations. Vectors are now fully working as local variables. - removed mulv_kr and divv_kr instructions. The first are redundant and the second are useless. Maybe remove all other vector/const operations as well? They won't get used by the code generator. - fixed disassembly of vector multiplication and division instructions.
2016-10-28 23:39:25 +00:00
ScriptPosition.Message(MSG_ERROR, "cannot determine %s of a constant", Which == TK_AlignOf? "alignment" : "size");
- handle all unary operators. - handle all binary operators which are already implemented in the code generator. - implemented sizeof/alignof operators in code generator. - rewrote RequestAddress so that its return value is not the writability of an address but the mere existence. Also changed it to not output errors itself because those cannot be dealt with by the calling function.
2016-10-17 18:33:35 +00:00
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
- handle all unary operators. - handle all binary operators which are already implemented in the code generator. - implemented sizeof/alignof operators in code generator. - rewrote RequestAddress so that its return value is not the writability of an address but the mere existence. Also changed it to not output errors itself because those cannot be dealt with by the calling function.
2016-10-17 18:33:35 +00:00
}
- added a new variable flag that allows defining variables which can only be modified by internal script code but not by external mods. Currently this is used by the NoBlockmap and NoSector flags which need special handling for changing.
2016-11-08 10:12:56 +00:00
else if (!Operand->RequestAddress(ctx, nullptr))
- handle all unary operators. - handle all binary operators which are already implemented in the code generator. - implemented sizeof/alignof operators in code generator. - rewrote RequestAddress so that its return value is not the writability of an address but the mere existence. Also changed it to not output errors itself because those cannot be dealt with by the calling function.
2016-10-17 18:33:35 +00:00
{
- implemented vector operations. Vectors are now fully working as local variables. - removed mulv_kr and divv_kr instructions. The first are redundant and the second are useless. Maybe remove all other vector/const operations as well? They won't get used by the code generator. - fixed disassembly of vector multiplication and division instructions.
2016-10-28 23:39:25 +00:00
ScriptPosition.Message(MSG_ERROR, "Operand must be addressable to determine %s", Which == TK_AlignOf ? "alignment" : "size");
- handle all unary operators. - handle all binary operators which are already implemented in the code generator. - implemented sizeof/alignof operators in code generator. - rewrote RequestAddress so that its return value is not the writability of an address but the mere existence. Also changed it to not output errors itself because those cannot be dealt with by the calling function.
2016-10-17 18:33:35 +00:00
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
- handle all unary operators. - handle all binary operators which are already implemented in the code generator. - implemented sizeof/alignof operators in code generator. - rewrote RequestAddress so that its return value is not the writability of an address but the mere existence. Also changed it to not output errors itself because those cannot be dealt with by the calling function.
2016-10-17 18:33:35 +00:00
}
else
{
- implemented all assign/modify operators. - use a table to translate from PEX to tokens to make the code easier to read.
2016-10-21 12:18:31 +00:00
FxExpression *x = new FxConstant(Which == TK_AlignOf ? int(type->Align) : int(type->Size), Operand->ScriptPosition);
- handle all unary operators. - handle all binary operators which are already implemented in the code generator. - implemented sizeof/alignof operators in code generator. - rewrote RequestAddress so that its return value is not the writability of an address but the mere existence. Also changed it to not output errors itself because those cannot be dealt with by the calling function.
2016-10-17 18:33:35 +00:00
delete this;
return x->Resolve(ctx);
}
}
ExpEmit FxSizeAlign::Emit(VMFunctionBuilder *build)
{
return ExpEmit();
}
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
//==========================================================================
//
// FxPreIncrDecr
//
//==========================================================================
FxPreIncrDecr::FxPreIncrDecr(FxExpression *base, int token)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_PreIncrDecr, base->ScriptPosition), Token(token), Base(base)
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
{
AddressRequested = false;
AddressWritable = false;
}
FxPreIncrDecr::~FxPreIncrDecr()
{
SAFE_DELETE(Base);
}
- added a new variable flag that allows defining variables which can only be modified by internal script code but not by external mods. Currently this is used by the NoBlockmap and NoSector flags which need special handling for changing.
2016-11-08 10:12:56 +00:00
bool FxPreIncrDecr::RequestAddress(FCompileContext &ctx, bool *writable)
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
{
AddressRequested = true;
- handle all unary operators. - handle all binary operators which are already implemented in the code generator. - implemented sizeof/alignof operators in code generator. - rewrote RequestAddress so that its return value is not the writability of an address but the mere existence. Also changed it to not output errors itself because those cannot be dealt with by the calling function.
2016-10-17 18:33:35 +00:00
if (writable != nullptr) *writable = AddressWritable;
return true;
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
}
FxExpression *FxPreIncrDecr::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE(Base, ctx);
ValueType = Base->ValueType;
if (!Base->IsNumeric())
{
ScriptPosition.Message(MSG_ERROR, "Numeric type expected");
delete this;
return nullptr;
}
else if (Base->ValueType == TypeBool)
{
ScriptPosition.Message(MSG_ERROR, "%s is not allowed on type bool", FScanner::TokenName(Token).GetChars());
delete this;
return nullptr;
}
- added a new variable flag that allows defining variables which can only be modified by internal script code but not by external mods. Currently this is used by the NoBlockmap and NoSector flags which need special handling for changing.
2016-11-08 10:12:56 +00:00
if (!Base->RequestAddress(ctx, &AddressWritable) || !AddressWritable )
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
{
ScriptPosition.Message(MSG_ERROR, "Expression must be a modifiable value");
delete this;
return nullptr;
}
return this;
}
ExpEmit FxPreIncrDecr::Emit(VMFunctionBuilder *build)
{
assert(Token == TK_Incr || Token == TK_Decr);
assert(ValueType == Base->ValueType && IsNumeric());
int zero = build->GetConstantInt(0);
int regtype = ValueType->GetRegType();
ExpEmit pointer = Base->Emit(build);
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
ExpEmit value = pointer;
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
if (!pointer.Target)
{
value = ExpEmit(build, regtype);
build->Emit(ValueType->GetLoadOp(), value.RegNum, pointer.RegNum, zero);
}
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
if (regtype == REGT_INT)
{
- removed all constant versions of vector instructions. The vector code does not use compound constants so there's no need to have instructions for them. - fixed: The code generator had no good safeguards for exceeding the maximum amount of registers. All there was was a handful of pitiful asserts which in production code do nothing at all but generate broken output. Even worse, the VM was hardwired to at most 255 constants per type per function by storing the constant count in a byte! This has been extended to 65535, but since many instructions only have a byte available for the constant index, a workaround had to be added to do a two-instruction setup if larger indices are needed.
2016-11-20 22:00:05 +00:00
build->Emit(OP_ADDI, value.RegNum, value.RegNum, uint8_t((Token == TK_Incr) ? 1 : -1));
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
}
else
{
build->Emit((Token == TK_Incr) ? OP_ADDF_RK : OP_SUBF_RK, value.RegNum, value.RegNum, build->GetConstantFloat(1.));
}
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
if (!pointer.Target)
{
build->Emit(ValueType->GetStoreOp(), pointer.RegNum, value.RegNum, zero);
}
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
if (AddressRequested)
{
value.Free(build);
return pointer;
}
pointer.Free(build);
return value;
}
//==========================================================================
//
// FxPostIncrDecr
//
//==========================================================================
FxPostIncrDecr::FxPostIncrDecr(FxExpression *base, int token)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_PostIncrDecr, base->ScriptPosition), Token(token), Base(base)
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
{
}
FxPostIncrDecr::~FxPostIncrDecr()
{
SAFE_DELETE(Base);
}
FxExpression *FxPostIncrDecr::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE(Base, ctx);
- handle all unary operators. - handle all binary operators which are already implemented in the code generator. - implemented sizeof/alignof operators in code generator. - rewrote RequestAddress so that its return value is not the writability of an address but the mere existence. Also changed it to not output errors itself because those cannot be dealt with by the calling function.
2016-10-17 18:33:35 +00:00
bool AddressWritable;
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
ValueType = Base->ValueType;
if (!Base->IsNumeric())
{
ScriptPosition.Message(MSG_ERROR, "Numeric type expected");
delete this;
return nullptr;
}
else if (Base->ValueType == TypeBool)
{
ScriptPosition.Message(MSG_ERROR, "%s is not allowed on type bool", FScanner::TokenName(Token).GetChars());
delete this;
return nullptr;
}
- added a new variable flag that allows defining variables which can only be modified by internal script code but not by external mods. Currently this is used by the NoBlockmap and NoSector flags which need special handling for changing.
2016-11-08 10:12:56 +00:00
if (!Base->RequestAddress(ctx, &AddressWritable) || !AddressWritable)
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
{
ScriptPosition.Message(MSG_ERROR, "Expression must be a modifiable value");
delete this;
return nullptr;
}
return this;
}
ExpEmit FxPostIncrDecr::Emit(VMFunctionBuilder *build)
{
assert(Token == TK_Incr || Token == TK_Decr);
assert(ValueType == Base->ValueType && IsNumeric());
int zero = build->GetConstantInt(0);
int regtype = ValueType->GetRegType();
ExpEmit pointer = Base->Emit(build);
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
if (!pointer.Target)
{
- scriptified the functions in a_possessed.cpp and added the needed exports and constants. - fixed: Script functions did not receive the function name when being created. - relaxed the asserts for PARAM_STATE, because the VM knows nothing about ATAG_STATE. Any state variable's content (e.g. Actor.SeeState) will receive ATAG_GENERIC, rather than ATAG_STATE. - added a 'NeedResult' flag so that certain operations can create shorter code if the result of the expression is not needed. So far only used for postdecrement/increment statements on local variables (which is the most frequent case where this matters.) - fixed postincrement and decrement for local variables. Due to the result preservation semantics it created faulty code.
2016-10-26 09:30:30 +00:00
ExpEmit out(build, regtype);
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
build->Emit(ValueType->GetLoadOp(), out.RegNum, pointer.RegNum, zero);
- scriptified the functions in a_possessed.cpp and added the needed exports and constants. - fixed: Script functions did not receive the function name when being created. - relaxed the asserts for PARAM_STATE, because the VM knows nothing about ATAG_STATE. Any state variable's content (e.g. Actor.SeeState) will receive ATAG_GENERIC, rather than ATAG_STATE. - added a 'NeedResult' flag so that certain operations can create shorter code if the result of the expression is not needed. So far only used for postdecrement/increment statements on local variables (which is the most frequent case where this matters.) - fixed postincrement and decrement for local variables. Due to the result preservation semantics it created faulty code.
2016-10-26 09:30:30 +00:00
ExpEmit assign(build, regtype);
if (regtype == REGT_INT)
{
- removed all constant versions of vector instructions. The vector code does not use compound constants so there's no need to have instructions for them. - fixed: The code generator had no good safeguards for exceeding the maximum amount of registers. All there was was a handful of pitiful asserts which in production code do nothing at all but generate broken output. Even worse, the VM was hardwired to at most 255 constants per type per function by storing the constant count in a byte! This has been extended to 65535, but since many instructions only have a byte available for the constant index, a workaround had to be added to do a two-instruction setup if larger indices are needed.
2016-11-20 22:00:05 +00:00
build->Emit(OP_ADDI, assign.RegNum, out.RegNum, uint8_t((Token == TK_Incr) ? 1 : -1));
- scriptified the functions in a_possessed.cpp and added the needed exports and constants. - fixed: Script functions did not receive the function name when being created. - relaxed the asserts for PARAM_STATE, because the VM knows nothing about ATAG_STATE. Any state variable's content (e.g. Actor.SeeState) will receive ATAG_GENERIC, rather than ATAG_STATE. - added a 'NeedResult' flag so that certain operations can create shorter code if the result of the expression is not needed. So far only used for postdecrement/increment statements on local variables (which is the most frequent case where this matters.) - fixed postincrement and decrement for local variables. Due to the result preservation semantics it created faulty code.
2016-10-26 09:30:30 +00:00
}
else
{
build->Emit((Token == TK_Incr) ? OP_ADDF_RK : OP_SUBF_RK, assign.RegNum, out.RegNum, build->GetConstantFloat(1.));
}
- fixed bad register use in postincrement operator.
2016-10-27 17:14:16 +00:00
build->Emit(ValueType->GetStoreOp(), pointer.RegNum, assign.RegNum, zero);
- scriptified the functions in a_possessed.cpp and added the needed exports and constants. - fixed: Script functions did not receive the function name when being created. - relaxed the asserts for PARAM_STATE, because the VM knows nothing about ATAG_STATE. Any state variable's content (e.g. Actor.SeeState) will receive ATAG_GENERIC, rather than ATAG_STATE. - added a 'NeedResult' flag so that certain operations can create shorter code if the result of the expression is not needed. So far only used for postdecrement/increment statements on local variables (which is the most frequent case where this matters.) - fixed postincrement and decrement for local variables. Due to the result preservation semantics it created faulty code.
2016-10-26 09:30:30 +00:00
pointer.Free(build);
assign.Free(build);
return out;
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
}
- scriptified the functions in a_possessed.cpp and added the needed exports and constants. - fixed: Script functions did not receive the function name when being created. - relaxed the asserts for PARAM_STATE, because the VM knows nothing about ATAG_STATE. Any state variable's content (e.g. Actor.SeeState) will receive ATAG_GENERIC, rather than ATAG_STATE. - added a 'NeedResult' flag so that certain operations can create shorter code if the result of the expression is not needed. So far only used for postdecrement/increment statements on local variables (which is the most frequent case where this matters.) - fixed postincrement and decrement for local variables. Due to the result preservation semantics it created faulty code.
2016-10-26 09:30:30 +00:00
else if (NeedResult)
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
{
- scriptified the functions in a_possessed.cpp and added the needed exports and constants. - fixed: Script functions did not receive the function name when being created. - relaxed the asserts for PARAM_STATE, because the VM knows nothing about ATAG_STATE. Any state variable's content (e.g. Actor.SeeState) will receive ATAG_GENERIC, rather than ATAG_STATE. - added a 'NeedResult' flag so that certain operations can create shorter code if the result of the expression is not needed. So far only used for postdecrement/increment statements on local variables (which is the most frequent case where this matters.) - fixed postincrement and decrement for local variables. Due to the result preservation semantics it created faulty code.
2016-10-26 09:30:30 +00:00
ExpEmit out(build, regtype);
if (regtype == REGT_INT)
{
build->Emit(OP_MOVE, out.RegNum, pointer.RegNum);
- removed all constant versions of vector instructions. The vector code does not use compound constants so there's no need to have instructions for them. - fixed: The code generator had no good safeguards for exceeding the maximum amount of registers. All there was was a handful of pitiful asserts which in production code do nothing at all but generate broken output. Even worse, the VM was hardwired to at most 255 constants per type per function by storing the constant count in a byte! This has been extended to 65535, but since many instructions only have a byte available for the constant index, a workaround had to be added to do a two-instruction setup if larger indices are needed.
2016-11-20 22:00:05 +00:00
build->Emit(OP_ADDI, pointer.RegNum, pointer.RegNum, uint8_t((Token == TK_Incr) ? 1 : -1));
- scriptified the functions in a_possessed.cpp and added the needed exports and constants. - fixed: Script functions did not receive the function name when being created. - relaxed the asserts for PARAM_STATE, because the VM knows nothing about ATAG_STATE. Any state variable's content (e.g. Actor.SeeState) will receive ATAG_GENERIC, rather than ATAG_STATE. - added a 'NeedResult' flag so that certain operations can create shorter code if the result of the expression is not needed. So far only used for postdecrement/increment statements on local variables (which is the most frequent case where this matters.) - fixed postincrement and decrement for local variables. Due to the result preservation semantics it created faulty code.
2016-10-26 09:30:30 +00:00
}
else
{
build->Emit(OP_MOVEF, out.RegNum, pointer.RegNum);
build->Emit((Token == TK_Incr) ? OP_ADDF_RK : OP_SUBF_RK, pointer.RegNum, pointer.RegNum, build->GetConstantFloat(1.));
}
pointer.Free(build);
return out;
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
}
else
{
- scriptified the functions in a_possessed.cpp and added the needed exports and constants. - fixed: Script functions did not receive the function name when being created. - relaxed the asserts for PARAM_STATE, because the VM knows nothing about ATAG_STATE. Any state variable's content (e.g. Actor.SeeState) will receive ATAG_GENERIC, rather than ATAG_STATE. - added a 'NeedResult' flag so that certain operations can create shorter code if the result of the expression is not needed. So far only used for postdecrement/increment statements on local variables (which is the most frequent case where this matters.) - fixed postincrement and decrement for local variables. Due to the result preservation semantics it created faulty code.
2016-10-26 09:30:30 +00:00
if (regtype == REGT_INT)
{
- removed all constant versions of vector instructions. The vector code does not use compound constants so there's no need to have instructions for them. - fixed: The code generator had no good safeguards for exceeding the maximum amount of registers. All there was was a handful of pitiful asserts which in production code do nothing at all but generate broken output. Even worse, the VM was hardwired to at most 255 constants per type per function by storing the constant count in a byte! This has been extended to 65535, but since many instructions only have a byte available for the constant index, a workaround had to be added to do a two-instruction setup if larger indices are needed.
2016-11-20 22:00:05 +00:00
build->Emit(OP_ADDI, pointer.RegNum, pointer.RegNum, uint8_t((Token == TK_Incr) ? 1 : -1));
- scriptified the functions in a_possessed.cpp and added the needed exports and constants. - fixed: Script functions did not receive the function name when being created. - relaxed the asserts for PARAM_STATE, because the VM knows nothing about ATAG_STATE. Any state variable's content (e.g. Actor.SeeState) will receive ATAG_GENERIC, rather than ATAG_STATE. - added a 'NeedResult' flag so that certain operations can create shorter code if the result of the expression is not needed. So far only used for postdecrement/increment statements on local variables (which is the most frequent case where this matters.) - fixed postincrement and decrement for local variables. Due to the result preservation semantics it created faulty code.
2016-10-26 09:30:30 +00:00
}
else
{
build->Emit((Token == TK_Incr) ? OP_ADDF_RK : OP_SUBF_RK, pointer.RegNum, pointer.RegNum, build->GetConstantFloat(1.));
}
pointer.Free(build);
return ExpEmit();
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
}
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
}
Added the direct assignment operator to DECORATE
2016-07-31 22:32:02 +00:00
//==========================================================================
//
// FxAssign
//
//==========================================================================
- 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
FxAssign::FxAssign(FxExpression *base, FxExpression *right, bool ismodify)
- Fixed Clang compiler errors and some warnings.
2016-10-25 14:53:14 +00:00
: FxExpression(EFX_Assign, base->ScriptPosition), Base(base), Right(right), IsBitWrite(-1), IsModifyAssign(ismodify)
Added the direct assignment operator to DECORATE
2016-07-31 22:32:02 +00:00
{
AddressRequested = false;
AddressWritable = false;
}
FxAssign::~FxAssign()
{
SAFE_DELETE(Base);
SAFE_DELETE(Right);
}
- 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
/* I don't think we should allow constructs like (a = b) = c;...
- added a new variable flag that allows defining variables which can only be modified by internal script code but not by external mods. Currently this is used by the NoBlockmap and NoSector flags which need special handling for changing.
2016-11-08 10:12:56 +00:00
bool FxAssign::RequestAddress(FCompileContext &ctx, bool *writable)
Added the direct assignment operator to DECORATE
2016-07-31 22:32:02 +00:00
{
AddressRequested = true;
- handle all unary operators. - handle all binary operators which are already implemented in the code generator. - implemented sizeof/alignof operators in code generator. - rewrote RequestAddress so that its return value is not the writability of an address but the mere existence. Also changed it to not output errors itself because those cannot be dealt with by the calling function.
2016-10-17 18:33:35 +00:00
if (writable != nullptr) *writable = AddressWritable;
return true;
Added the direct assignment operator to DECORATE
2016-07-31 22:32:02 +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
*/
Added the direct assignment operator to DECORATE
2016-07-31 22:32:02 +00:00
FxExpression *FxAssign::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE(Base, ctx);
ValueType = Base->ValueType;
Added all compound assignment operators to DECORATE
2016-08-01 01:32:02 +00:00
SAFE_RESOLVE(Right, ctx);
- 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
if (IsModifyAssign && Base->ValueType == TypeBool && Right->ValueType != TypeBool)
{
// If the modify operation resulted in a type promotion from bool to int, this must be blocked.
// (this means, for bool, only &=, ^= and |= are allowed, although DECORATE is more lax.)
ScriptPosition.Message(MSG_ERROR, "Invalid modify/assign operation with a boolean operand");
delete this;
return nullptr;
}
- 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
// keep the redundant handling for numeric types here to avoid problems with DECORATE.
// for non-numerics FxTypeCast can be used without issues.
- preparations for null pointer support. - add pointer support to FxAssign.
2016-10-21 17:18:39 +00:00
if (Base->IsNumeric() && Right->IsNumeric())
Added the direct assignment operator to DECORATE
2016-07-31 22:32:02 +00:00
{
- preparations for null pointer support. - add pointer support to FxAssign.
2016-10-21 17:18:39 +00:00
if (Right->ValueType != ValueType)
{
if (ValueType == TypeBool)
{
Right = new FxBoolCast(Right);
}
else if (ValueType->GetRegType() == REGT_INT)
{
Right = new FxIntCast(Right, ctx.FromDecorate);
}
else
{
Right = new FxFloatCast(Right);
}
SAFE_RESOLVE(Right, ctx);
}
}
else if (Base->ValueType == Right->ValueType)
{
if (Base->ValueType->IsKindOf(RUNTIME_CLASS(PArray)))
{
ScriptPosition.Message(MSG_ERROR, "Cannot assign arrays");
delete this;
return nullptr;
}
- implemented vector operations. Vectors are now fully working as local variables. - removed mulv_kr and divv_kr instructions. The first are redundant and the second are useless. Maybe remove all other vector/const operations as well? They won't get used by the code generator. - fixed disassembly of vector multiplication and division instructions.
2016-10-28 23:39:25 +00:00
if (!Base->IsVector() && Base->ValueType->IsKindOf(RUNTIME_CLASS(PStruct)))
- preparations for null pointer support. - add pointer support to FxAssign.
2016-10-21 17:18:39 +00:00
{
ScriptPosition.Message(MSG_ERROR, "Struct assignment not implemented yet");
delete this;
return nullptr;
}
// Both types are the same so this is ok.
}
- scriptified the Minotaur. Interesting tidbit: The damage calculation in P_MinotaurSlam had been incorrect for the Heretic version since the friendly Hexen Dark Servant was added, but nobody ever noticed in 14 years...
2016-11-26 00:14:47 +00:00
else if (Right->ValueType->IsA(RUNTIME_CLASS(PNativeStruct)) && Base->ValueType->IsKindOf(RUNTIME_CLASS(PPointer)) && static_cast<PPointer*>(Base->ValueType)->PointedType == Right->ValueType)
{
// allow conversion of native structs to pointers of the same type. This is necessary to assign elements from global arrays like players, sectors, etc. to local pointers.
// For all other types this is not needed. Structs are not assignable and classes can only exist as references.
bool writable;
Right->RequestAddress(ctx, &writable);
Right->ValueType = Base->ValueType;
}
- preparations for null pointer support. - add pointer support to FxAssign.
2016-10-21 17:18:39 +00:00
else
{
- 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
// pass it to FxTypeCast for complete handling.
Right = new FxTypeCast(Right, Base->ValueType, false);
SAFE_RESOLVE(Right, ctx);
Added the direct assignment operator to DECORATE
2016-07-31 22:32:02 +00:00
}
- 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
- added a new variable flag that allows defining variables which can only be modified by internal script code but not by external mods. Currently this is used by the NoBlockmap and NoSector flags which need special handling for changing.
2016-11-08 10:12:56 +00:00
if (!Base->RequestAddress(ctx, &AddressWritable) || !AddressWritable)
Added the direct assignment operator to DECORATE
2016-07-31 22:32:02 +00:00
{
ScriptPosition.Message(MSG_ERROR, "Expression must be a modifiable value");
delete this;
return nullptr;
}
- 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
// Special case: Assignment to a bitfield.
- split up zscript/shared/inventory.txt. - moved health items to their own file. - scriptified ScoreItem and MapRevealer whose entire functionality was a small TryPickup method. - fixed: bit fields in global variables were not correctly written. This should conclude the inventory cleanup. It is now possible again to find things in there.
2016-11-30 12:36:13 +00:00
IsBitWrite = Base->GetBitValue();
Added the direct assignment operator to DECORATE
2016-07-31 22:32:02 +00:00
return this;
}
ExpEmit FxAssign::Emit(VMFunctionBuilder *build)
{
- tested and fixed the regular assignment statement for both local and member variables. The generated object code can definitely use an optimization pass but that's something left for later when more things are working. Right now it creates one opcode more than necessary for all member accesses (instead of using the offset in the store command it calculates an actual address of the variable in another address register) and can create one too many for non-constant expressions being assigned to local variables (a move between two registers because the emitted expression on the right hand side does not know that it can emit to the actual variable's register.)
2016-10-21 08:09:01 +00:00
static const BYTE loadops[] = { OP_LK, OP_LKF, OP_LKS, OP_LKP };
Added the direct assignment operator to DECORATE
2016-07-31 22:32:02 +00:00
assert(ValueType->GetRegType() == Right->ValueType->GetRegType());
- tested and fixed the regular assignment statement for both local and member variables. The generated object code can definitely use an optimization pass but that's something left for later when more things are working. Right now it creates one opcode more than necessary for all member accesses (instead of using the offset in the store command it calculates an actual address of the variable in another address register) and can create one too many for non-constant expressions being assigned to local variables (a move between two registers because the emitted expression on the right hand side does not know that it can emit to the actual variable's register.)
2016-10-21 08:09:01 +00:00
ExpEmit pointer = Base->Emit(build);
Address = pointer;
- use the immediate versions for loading integer constants when possible.
2016-12-01 23:54:40 +00:00
ExpEmit result;
bool intconst = false;
int intconstval;
if (Right->isConstant() && Right->ValueType->GetRegType() == REGT_INT)
{
intconst = true;
intconstval = static_cast<FxConstant*>(Right)->GetValue().GetInt();
result.Konst = true;
result.RegType = REGT_INT;
}
else
{
result = Right->Emit(build);
}
- implemented all assign/modify operators. - use a table to translate from PEX to tokens to make the code easier to read.
2016-10-21 12:18:31 +00:00
assert(result.RegType <= REGT_TYPE);
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
if (pointer.Target)
Added the direct assignment operator to DECORATE
2016-07-31 22:32:02 +00:00
{
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
if (result.Konst)
{
- use the immediate versions for loading integer constants when possible.
2016-12-01 23:54:40 +00:00
if (intconst) build->EmitLoadInt(pointer.RegNum, intconstval);
else build->Emit(loadops[result.RegType], pointer.RegNum, result.RegNum);
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
}
else
{
build->Emit(Right->ValueType->GetMoveOp(), pointer.RegNum, result.RegNum);
}
Added the direct assignment operator to DECORATE
2016-07-31 22:32:02 +00:00
}
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
else
{
if (result.Konst)
{
ExpEmit temp(build, result.RegType);
- use the immediate versions for loading integer constants when possible.
2016-12-01 23:54:40 +00:00
if (intconst) build->EmitLoadInt(temp.RegNum, intconstval);
else build->Emit(loadops[result.RegType], temp.RegNum, result.RegNum);
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
result.Free(build);
result = temp;
}
Added the direct assignment operator to DECORATE
2016-07-31 22:32:02 +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
if (IsBitWrite == -1)
{
build->Emit(ValueType->GetStoreOp(), pointer.RegNum, result.RegNum, build->GetConstantInt(0));
}
else
{
build->Emit(OP_SBIT, pointer.RegNum, result.RegNum, 1 << IsBitWrite);
}
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
}
Added the direct assignment operator to DECORATE
2016-07-31 22:32:02 +00:00
if (AddressRequested)
{
result.Free(build);
return pointer;
}
pointer.Free(build);
return result;
}
Added all compound assignment operators to DECORATE
2016-08-01 01:32:02 +00:00
//==========================================================================
//
// FxAssignSelf
//
//==========================================================================
FxAssignSelf::FxAssignSelf(const FScriptPosition &pos)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_AssignSelf, pos)
Added all compound assignment operators to DECORATE
2016-08-01 01:32:02 +00:00
{
Assignment = nullptr;
}
FxExpression *FxAssignSelf::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
// This should never happen if FxAssignSelf is used correctly
assert(Assignment != nullptr);
ValueType = Assignment->ValueType;
return this;
}
ExpEmit FxAssignSelf::Emit(VMFunctionBuilder *build)
{
- 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
assert(ValueType == Assignment->ValueType);
Added all compound assignment operators to DECORATE
2016-08-01 01:32:02 +00:00
ExpEmit pointer = Assignment->Address; // FxAssign should have already emitted it
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
if (!pointer.Target)
{
- scriptified Heretic's mace. - fixed: FxAssignSelf did not the correct number of registers for vector operations. - fixed a few asserts in vector2 instructions. - turned the virtual AActor::HitFloor method into a flag MF7_SMASHABLE. The only use of this function was to kill Hexen's pottery when they hit the floor, and this looks like something that can be exposed to modders less clumsily.
2016-11-24 12:45:43 +00:00
ExpEmit out(build, ValueType->GetRegType(), ValueType->GetRegCount());
- 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
if (Assignment->IsBitWrite != -1)
{
build->Emit(OP_LBIT, out.RegNum, pointer.RegNum, 1 << Assignment->IsBitWrite);
}
else
{
build->Emit(ValueType->GetLoadOp(), out.RegNum, pointer.RegNum, build->GetConstantInt(0));
}
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
return out;
}
else
{
return pointer;
}
Added all compound assignment operators to DECORATE
2016-08-01 01:32:02 +00:00
}
- scriptified A_Saw. - implemented multiple-return-value assignment. Due to some grammar conflicts the originally intended Lua-inspired syntax of 'a, b = Function()' could not be done, so it's '[a, b] = Function()'
2016-11-19 23:25:38 +00:00
//==========================================================================
//
//
//
//==========================================================================
FxMultiAssign::FxMultiAssign(FArgumentList &base, FxExpression *right, const FScriptPosition &pos)
:FxExpression(EFX_MultiAssign, pos)
{
Base = std::move(base);
Right = right;
LocalVarContainer = new FxCompoundStatement(ScriptPosition);
}
//==========================================================================
//
//
//
//==========================================================================
FxMultiAssign::~FxMultiAssign()
{
SAFE_DELETE(Right);
SAFE_DELETE(LocalVarContainer);
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxMultiAssign::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE(Right, ctx);
if (Right->ExprType != EFX_VMFunctionCall)
{
Right->ScriptPosition.Message(MSG_ERROR, "Function call expected on right side of multi-assigment");
delete this;
return nullptr;
}
auto VMRight = static_cast<FxVMFunctionCall *>(Right);
auto rets = VMRight->GetReturnTypes();
if (rets.Size() < Base.Size())
{
Right->ScriptPosition.Message(MSG_ERROR, "Insufficient returns in function %s", VMRight->Function->SymbolName.GetChars());
delete this;
return nullptr;
}
// Pack the generated data (temp local variables for the results and necessary type casts and single assignments) into a compound statement for easier management.
for (unsigned i = 0; i < Base.Size(); i++)
{
auto singlevar = new FxLocalVariableDeclaration(rets[i], NAME_None, nullptr, 0, ScriptPosition);
LocalVarContainer->Add(singlevar);
Base[i] = Base[i]->Resolve(ctx);
ABORT(Base[i]);
auto varaccess = new FxLocalVariable(singlevar, ScriptPosition);
auto assignee = new FxTypeCast(varaccess, Base[i]->ValueType, false);
LocalVarContainer->Add(new FxAssign(Base[i], assignee, false));
}
auto x = LocalVarContainer->Resolve(ctx);
LocalVarContainer = nullptr;
ABORT(x);
LocalVarContainer = static_cast<FxCompoundStatement*>(x);
static_cast<FxVMFunctionCall *>(Right)->AssignCount = Base.Size();
ValueType = TypeVoid;
return this;
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxMultiAssign::Emit(VMFunctionBuilder *build)
{
Right->Emit(build);
for (unsigned i = 0; i < Base.Size(); i++)
{
LocalVarContainer->LocalVars[i]->SetReg(static_cast<FxVMFunctionCall *>(Right)->ReturnRegs[i]);
}
static_cast<FxVMFunctionCall *>(Right)->ReturnRegs.Clear();
static_cast<FxVMFunctionCall *>(Right)->ReturnRegs.ShrinkToFit();
return LocalVarContainer->Emit(build);
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
//
//
//==========================================================================
FxBinary::FxBinary(int o, FxExpression *l, FxExpression *r)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_Binary, l->ScriptPosition)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
Operator=o;
left=l;
right=r;
}
//==========================================================================
//
//
//
//==========================================================================
FxBinary::~FxBinary()
{
SAFE_DELETE(left);
SAFE_DELETE(right);
}
//==========================================================================
//
//
//
//==========================================================================
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
bool FxBinary::Promote(FCompileContext &ctx, bool forceint)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
// math operations of unsigned ints results in an unsigned int. (16 and 8 bit values never get here, they get promoted to regular ints elsewhere already.)
if (left->ValueType == TypeUInt32 && right->ValueType == TypeUInt32)
- implemented vector operations. Vectors are now fully working as local variables. - removed mulv_kr and divv_kr instructions. The first are redundant and the second are useless. Maybe remove all other vector/const operations as well? They won't get used by the code generator. - fixed disassembly of vector multiplication and division instructions.
2016-10-28 23:39:25 +00:00
{
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
ValueType = TypeUInt32;
- implemented vector operations. Vectors are now fully working as local variables. - removed mulv_kr and divv_kr instructions. The first are redundant and the second are useless. Maybe remove all other vector/const operations as well? They won't get used by the code generator. - fixed disassembly of vector multiplication and division instructions.
2016-10-28 23:39:25 +00:00
}
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
else if (left->IsInteger() && right->IsInteger())
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
{
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
ValueType = TypeSInt32; // Addition and subtraction forces all integer-derived types to signed int.
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
}
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
else if (!forceint)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
ValueType = TypeFloat64;
if (left->IsFloat() && right->IsInteger())
- 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
{
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
right = (new FxFloatCast(right))->Resolve(ctx);
- 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
}
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
else if (left->IsInteger() && right->IsFloat())
- 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
{
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
left = (new FxFloatCast(left))->Resolve(ctx);
- 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
}
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
else if (ctx.FromDecorate)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
// For DECORATE which allows floats here. ZScript does not.
if (left->IsFloat())
- added 'null' token to the ZScript parser which is needed for null pointers. - removed function declaration parser from DECORATE because it is not needed anymore. - fixed: comparison operators could not handle names.
2016-10-18 22:35:34 +00:00
{
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
left = new FxIntCast(left, ctx.FromDecorate);
left = left->Resolve(ctx);
- added 'null' token to the ZScript parser which is needed for null pointers. - removed function declaration parser from DECORATE because it is not needed anymore. - fixed: comparison operators could not handle names.
2016-10-18 22:35:34 +00:00
}
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
if (right->IsFloat())
- added 'null' token to the ZScript parser which is needed for null pointers. - removed function declaration parser from DECORATE because it is not needed anymore. - fixed: comparison operators could not handle names.
2016-10-18 22:35:34 +00:00
{
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
right = new FxIntCast(right, ctx.FromDecorate);
right = right->Resolve(ctx);
- added 'null' token to the ZScript parser which is needed for null pointers. - removed function declaration parser from DECORATE because it is not needed anymore. - fixed: comparison operators could not handle names.
2016-10-18 22:35:34 +00:00
}
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
if (left == nullptr || right == nullptr)
- added null pointer. - fixed: FxMemberIdentifier checked for ClassPointers instead of object pointers to resolve the left hand side of the expression. - allow comparison of pointers.
2016-10-21 22:50:04 +00:00
{
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
delete this;
return false;
- added null pointer. - fixed: FxMemberIdentifier checked for ClassPointers instead of object pointers to resolve the left hand side of the expression. - allow comparison of pointers.
2016-10-21 22:50:04 +00:00
}
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
ValueType = TypeSInt32;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
ScriptPosition.Message(MSG_ERROR, "Integer operand expected");
- 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
delete this;
return false;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
return true;
}
- same as last commit for FxMulDiv and FxPow. - some streamlining of FxAddSub.
2016-11-18 10:53:18 +00:00
//==========================================================================
//
//
//
//==========================================================================
Normalize line endings
2016-03-01 15:47:10 +00:00
FxAddSub::FxAddSub(int o, FxExpression *l, FxExpression *r)
: FxBinary(o, l, r)
{
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxAddSub::Resolve(FCompileContext& ctx)
{
CHECKRESOLVED();
- started refactoring binary operators by starting to movw the relevant parts or ResolveLR into the respective Resolve methods. FxAddSub complete. This one-size-fits all function has become too unwieldy with all its special cases and makes improvements harder than necessary.
2016-11-18 10:28:15 +00:00
RESOLVE(left, ctx);
RESOLVE(right, ctx);
if (!left || !right)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
delete this;
- implemented the string concatenation operator '..'. This is capable of stringifying all of the common types for output. - gave OP_CONCAT some sane semantics. The way this was defined, by specifying the source operands as a range of registers instead of a pair like everything else made it completely useless for the task at hand. - changed formatting for floats to %.5f which for normal output in a game makes more sense. For special cases there should be a special formatting function for ints and floats that can do more specialized conversions.
2016-11-18 16:44:25 +00:00
return nullptr;
- started refactoring binary operators by starting to movw the relevant parts or ResolveLR into the respective Resolve methods. FxAddSub complete. This one-size-fits all function has become too unwieldy with all its special cases and makes improvements harder than necessary.
2016-11-18 10:28:15 +00:00
}
- scriptified PowerFlight and PowerWeaponLevel2.
2017-01-15 22:21:38 +00:00
if (left->ValueType == TypeTextureID && right->IsInteger())
{
ValueType = TypeTextureID;
}
else if (left->ValueType == TypeState && right->IsInteger() && Operator == '+' && !left->isConstant())
- scriptified Chicken and Pig - not tested yet, because other things have priority.
2016-11-22 11:21:55 +00:00
{
// This is the only special case of pointer addition that will be accepted - because it is used quite often in the existing game code.
ValueType = TypeState;
right = new FxMulDiv('*', right, new FxConstant((int)sizeof(FState), ScriptPosition)); // multiply by size here, so that constants can be better optimized.
right = right->Resolve(ctx);
ABORT(right);
}
else if (left->IsVector() && right->IsVector())
- started refactoring binary operators by starting to movw the relevant parts or ResolveLR into the respective Resolve methods. FxAddSub complete. This one-size-fits all function has become too unwieldy with all its special cases and makes improvements harder than necessary.
2016-11-18 10:28:15 +00:00
{
// a vector2 can be added to or subtracted from a vector 3 but it needs to be the right operand.
if (left->ValueType == right->ValueType || (left->ValueType == TypeVector3 && right->ValueType == TypeVector2))
{
ValueType = left->ValueType;
}
else
{
- same as last commit for FxMulDiv and FxPow. - some streamlining of FxAddSub.
2016-11-18 10:53:18 +00:00
goto error;
- started refactoring binary operators by starting to movw the relevant parts or ResolveLR into the respective Resolve methods. FxAddSub complete. This one-size-fits all function has become too unwieldy with all its special cases and makes improvements harder than necessary.
2016-11-18 10:28:15 +00:00
}
}
else if (left->IsNumeric() && right->IsNumeric())
{
- same as last commit for FxMulDiv and FxPow. - some streamlining of FxAddSub.
2016-11-18 10:53:18 +00:00
Promote(ctx);
- started refactoring binary operators by starting to movw the relevant parts or ResolveLR into the respective Resolve methods. FxAddSub complete. This one-size-fits all function has become too unwieldy with all its special cases and makes improvements harder than necessary.
2016-11-18 10:28:15 +00:00
}
else
{
// To check: It may be that this could pass in DECORATE, although setting TypeVoid here would pretty much prevent that.
- same as last commit for FxMulDiv and FxPow. - some streamlining of FxAddSub.
2016-11-18 10:53:18 +00:00
goto error;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- started refactoring binary operators by starting to movw the relevant parts or ResolveLR into the respective Resolve methods. FxAddSub complete. This one-size-fits all function has become too unwieldy with all its special cases and makes improvements harder than necessary.
2016-11-18 10:28:15 +00:00
if (left->isConstant() && right->isConstant())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
if (IsFloat())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
double v;
double v1 = static_cast<FxConstant *>(left)->GetValue().GetFloat();
double v2 = static_cast<FxConstant *>(right)->GetValue().GetFloat();
v = Operator == '+'? v1 + v2 :
Operator == '-'? v1 - v2 : 0;
FxExpression *e = new FxConstant(v, ScriptPosition);
delete this;
return e;
}
else
{
int v;
int v1 = static_cast<FxConstant *>(left)->GetValue().GetInt();
int v2 = static_cast<FxConstant *>(right)->GetValue().GetInt();
v = Operator == '+'? v1 + v2 :
Operator == '-'? v1 - v2 : 0;
FxExpression *e = new FxConstant(v, ScriptPosition);
delete this;
return e;
}
}
return this;
- same as last commit for FxMulDiv and FxPow. - some streamlining of FxAddSub.
2016-11-18 10:53:18 +00:00
error:
ScriptPosition.Message(MSG_ERROR, "Incompatible operands for %s", Operator == '+' ? "addition" : "subtraction");
delete this;
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxAddSub::Emit(VMFunctionBuilder *build)
{
assert(Operator == '+' || Operator == '-');
ExpEmit op1 = left->Emit(build);
ExpEmit op2 = right->Emit(build);
- scriptified PowerFlight and PowerWeaponLevel2.
2017-01-15 22:21:38 +00:00
ExpEmit to;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (Operator == '+')
{
- scriptified Chicken and Pig - not tested yet, because other things have priority.
2016-11-22 11:21:55 +00:00
if (op1.RegType == REGT_POINTER)
{
assert(!op1.Konst);
assert(op2.RegType == REGT_INT);
op1.Free(build);
op2.Free(build);
ExpEmit opout(build, REGT_POINTER);
build->Emit(op2.Konst? OP_ADDA_RK : OP_ADDA_RR, opout.RegNum, op1.RegNum, op2.RegNum);
return opout;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
// Since addition is commutative, only the second operand may be a constant.
if (op1.Konst)
{
swapvalues(op1, op2);
}
assert(!op1.Konst);
op1.Free(build);
op2.Free(build);
- scriptified PowerFlight and PowerWeaponLevel2.
2017-01-15 22:21:38 +00:00
to = ExpEmit(build, ValueType->GetRegType(), ValueType->GetRegCount());
- implemented vector operations. Vectors are now fully working as local variables. - removed mulv_kr and divv_kr instructions. The first are redundant and the second are useless. Maybe remove all other vector/const operations as well? They won't get used by the code generator. - fixed disassembly of vector multiplication and division instructions.
2016-10-28 23:39:25 +00:00
if (IsVector())
{
assert(op1.RegType == REGT_FLOAT && op2.RegType == REGT_FLOAT);
build->Emit(right->ValueType == TypeVector2? OP_ADDV2_RR : OP_ADDV3_RR, to.RegNum, op1.RegNum, op2.RegNum);
if (left->ValueType == TypeVector3 && right->ValueType == TypeVector2 && to.RegNum != op1.RegNum)
{
// must move the z-coordinate
build->Emit(OP_MOVEF, to.RegNum + 2, op1.RegNum + 2);
}
return to;
}
else if (ValueType->GetRegType() == REGT_FLOAT)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
assert(op1.RegType == REGT_FLOAT && op2.RegType == REGT_FLOAT);
build->Emit(op2.Konst ? OP_ADDF_RK : OP_ADDF_RR, to.RegNum, op1.RegNum, op2.RegNum);
return to;
}
else
{
assert(ValueType->GetRegType() == REGT_INT);
assert(op1.RegType == REGT_INT && op2.RegType == REGT_INT);
build->Emit(op2.Konst ? OP_ADD_RK : OP_ADD_RR, to.RegNum, op1.RegNum, op2.RegNum);
- scriptified PowerFlight and PowerWeaponLevel2.
2017-01-15 22:21:38 +00:00
if (ValueType == TypeTextureID) goto texcheck;
Normalize line endings
2016-03-01 15:47:10 +00:00
return to;
}
}
else
{
// Subtraction is not commutative, so either side may be constant (but not both).
assert(!op1.Konst || !op2.Konst);
op1.Free(build);
op2.Free(build);
- scriptified PowerFlight and PowerWeaponLevel2.
2017-01-15 22:21:38 +00:00
to = ExpEmit(build, ValueType->GetRegType(), ValueType->GetRegCount());
- implemented vector operations. Vectors are now fully working as local variables. - removed mulv_kr and divv_kr instructions. The first are redundant and the second are useless. Maybe remove all other vector/const operations as well? They won't get used by the code generator. - fixed disassembly of vector multiplication and division instructions.
2016-10-28 23:39:25 +00:00
if (IsVector())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
assert(op1.RegType == REGT_FLOAT && op2.RegType == REGT_FLOAT);
- implemented vector operations. Vectors are now fully working as local variables. - removed mulv_kr and divv_kr instructions. The first are redundant and the second are useless. Maybe remove all other vector/const operations as well? They won't get used by the code generator. - fixed disassembly of vector multiplication and division instructions.
2016-10-28 23:39:25 +00:00
build->Emit(right->ValueType == TypeVector2 ? OP_SUBV2_RR : OP_SUBV3_RR, to.RegNum, op1.RegNum, op2.RegNum);
return to;
}
else if (ValueType->GetRegType() == REGT_FLOAT)
{
assert(op1.RegType == REGT_FLOAT && op2.RegType == REGT_FLOAT);
build->Emit(op1.Konst ? OP_SUBF_KR : op2.Konst ? OP_SUBF_RK : OP_SUBF_RR, to.RegNum, op1.RegNum, op2.RegNum);
Normalize line endings
2016-03-01 15:47:10 +00:00
return to;
}
else
{
assert(ValueType->GetRegType() == REGT_INT);
assert(op1.RegType == REGT_INT && op2.RegType == REGT_INT);
- implemented vector operations. Vectors are now fully working as local variables. - removed mulv_kr and divv_kr instructions. The first are redundant and the second are useless. Maybe remove all other vector/const operations as well? They won't get used by the code generator. - fixed disassembly of vector multiplication and division instructions.
2016-10-28 23:39:25 +00:00
build->Emit(op1.Konst ? OP_SUB_KR : op2.Konst ? OP_SUB_RK : OP_SUB_RR, to.RegNum, op1.RegNum, op2.RegNum);
- scriptified PowerFlight and PowerWeaponLevel2.
2017-01-15 22:21:38 +00:00
if (ValueType == TypeTextureID) goto texcheck;
Normalize line endings
2016-03-01 15:47:10 +00:00
return to;
}
}
- scriptified PowerFlight and PowerWeaponLevel2.
2017-01-15 22:21:38 +00:00
texcheck:
// Do a bounds check for the texture index. Note that count can change at run time so this needs to read the value from the texture manager.
auto * ptr = (FArray*)&TexMan.Textures;
auto * countptr = &ptr->Count;
ExpEmit bndp(build, REGT_POINTER);
ExpEmit bndc(build, REGT_INT);
build->Emit(OP_LKP, bndp.RegNum, build->GetConstantAddress(countptr, ATAG_GENERIC));
build->Emit(OP_LW, bndc.RegNum, bndp.RegNum, build->GetConstantInt(0));
build->Emit(OP_BOUND_R, to.RegNum, bndc.RegNum);
bndp.Free(build);
bndc.Free(build);
return to;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
//
//
//==========================================================================
FxMulDiv::FxMulDiv(int o, FxExpression *l, FxExpression *r)
: FxBinary(o, l, r)
{
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxMulDiv::Resolve(FCompileContext& ctx)
{
CHECKRESOLVED();
- same as last commit for FxMulDiv and FxPow. - some streamlining of FxAddSub.
2016-11-18 10:53:18 +00:00
RESOLVE(left, ctx);
RESOLVE(right, ctx);
if (!left || !right)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
delete this;
- implemented the string concatenation operator '..'. This is capable of stringifying all of the common types for output. - gave OP_CONCAT some sane semantics. The way this was defined, by specifying the source operands as a range of registers instead of a pair like everything else made it completely useless for the task at hand. - changed formatting for floats to %.5f which for normal output in a game makes more sense. For special cases there should be a special formatting function for ints and floats that can do more specialized conversions.
2016-11-18 16:44:25 +00:00
return nullptr;
- same as last commit for FxMulDiv and FxPow. - some streamlining of FxAddSub.
2016-11-18 10:53:18 +00:00
}
if (left->IsVector() || right->IsVector())
{
switch (Operator)
{
case '/':
// For division, the vector must be the first operand.
if (right->IsVector()) goto error;
case '*':
if (left->IsVector() && right->IsNumeric())
{
if (right->IsInteger())
{
right = new FxFloatCast(right);
right = right->Resolve(ctx);
if (right == nullptr)
{
delete this;
- implemented the string concatenation operator '..'. This is capable of stringifying all of the common types for output. - gave OP_CONCAT some sane semantics. The way this was defined, by specifying the source operands as a range of registers instead of a pair like everything else made it completely useless for the task at hand. - changed formatting for floats to %.5f which for normal output in a game makes more sense. For special cases there should be a special formatting function for ints and floats that can do more specialized conversions.
2016-11-18 16:44:25 +00:00
return nullptr;
- same as last commit for FxMulDiv and FxPow. - some streamlining of FxAddSub.
2016-11-18 10:53:18 +00:00
}
}
ValueType = left->ValueType;
}
else if (right->IsVector() && left->IsNumeric())
{
if (left->IsInteger())
{
left = new FxFloatCast(left);
left = left->Resolve(ctx);
if (left == nullptr)
{
delete this;
- implemented the string concatenation operator '..'. This is capable of stringifying all of the common types for output. - gave OP_CONCAT some sane semantics. The way this was defined, by specifying the source operands as a range of registers instead of a pair like everything else made it completely useless for the task at hand. - changed formatting for floats to %.5f which for normal output in a game makes more sense. For special cases there should be a special formatting function for ints and floats that can do more specialized conversions.
2016-11-18 16:44:25 +00:00
return nullptr;
- same as last commit for FxMulDiv and FxPow. - some streamlining of FxAddSub.
2016-11-18 10:53:18 +00:00
}
}
ValueType = right->ValueType;
}
break;
default:
// Vector modulus is not permitted
goto error;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- same as last commit for FxMulDiv and FxPow. - some streamlining of FxAddSub.
2016-11-18 10:53:18 +00:00
else if (left->IsNumeric() && right->IsNumeric())
{
Promote(ctx);
}
else
{
// To check: It may be that this could pass in DECORATE, although setting TypeVoid here would pretty much prevent that.
goto error;
}
if (left->isConstant() && right->isConstant())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
if (IsFloat())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
double v;
double v1 = static_cast<FxConstant *>(left)->GetValue().GetFloat();
double v2 = static_cast<FxConstant *>(right)->GetValue().GetFloat();
if (Operator != '*' && v2 == 0)
{
ScriptPosition.Message(MSG_ERROR, "Division by 0");
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
v = Operator == '*'? v1 * v2 :
Operator == '/'? v1 / v2 :
Operator == '%'? fmod(v1, v2) : 0;
FxExpression *e = new FxConstant(v, ScriptPosition);
delete this;
return e;
}
else
{
int v;
int v1 = static_cast<FxConstant *>(left)->GetValue().GetInt();
int v2 = static_cast<FxConstant *>(right)->GetValue().GetInt();
if (Operator != '*' && v2 == 0)
{
ScriptPosition.Message(MSG_ERROR, "Division by 0");
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
v = Operator == '*'? v1 * v2 :
Operator == '/'? v1 / v2 :
Operator == '%'? v1 % v2 : 0;
FxExpression *e = new FxConstant(v, ScriptPosition);
delete this;
return e;
}
}
return this;
- same as last commit for FxMulDiv and FxPow. - some streamlining of FxAddSub.
2016-11-18 10:53:18 +00:00
error:
ScriptPosition.Message(MSG_ERROR, "Incompatible operands for %s", Operator == '*' ? "multiplication" : Operator == '%' ? "modulus" : "division");
delete this;
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxMulDiv::Emit(VMFunctionBuilder *build)
{
ExpEmit op1 = left->Emit(build);
ExpEmit op2 = right->Emit(build);
- implemented vector operations. Vectors are now fully working as local variables. - removed mulv_kr and divv_kr instructions. The first are redundant and the second are useless. Maybe remove all other vector/const operations as well? They won't get used by the code generator. - fixed disassembly of vector multiplication and division instructions.
2016-10-28 23:39:25 +00:00
if (IsVector())
{
assert(Operator != '%');
if (right->IsVector())
{
swapvalues(op1, op2);
}
int op;
if (op2.Konst)
{
op = Operator == '*' ? (ValueType == TypeVector2 ? OP_MULVF2_RK : OP_MULVF3_RK) : (ValueType == TypeVector2 ? OP_DIVVF2_RK : OP_DIVVF3_RK);
}
else
{
op = Operator == '*' ? (ValueType == TypeVector2 ? OP_MULVF2_RR : OP_MULVF3_RR) : (ValueType == TypeVector2 ? OP_DIVVF2_RR : OP_DIVVF3_RR);
}
op1.Free(build);
op2.Free(build);
- removed obsolete code from a_bossbrain.cpp. - fixed: divisions wasted one register for each operation due to a double allocation. - changed math operations to use less registers. There was a well-intended change to allocate the destination first, but the better approach is to first allocate the operands and free then before allocating the destination register.
2016-11-03 13:23:29 +00:00
ExpEmit to(build, ValueType->GetRegType(), ValueType->GetRegCount());
build->Emit(op, to.RegNum, op1.RegNum, op2.RegNum);
- implemented vector operations. Vectors are now fully working as local variables. - removed mulv_kr and divv_kr instructions. The first are redundant and the second are useless. Maybe remove all other vector/const operations as well? They won't get used by the code generator. - fixed disassembly of vector multiplication and division instructions.
2016-10-28 23:39:25 +00:00
return to;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
if (Operator == '*')
{
// Multiplication is commutative, so only the second operand may be constant.
if (op1.Konst)
{
swapvalues(op1, op2);
}
assert(!op1.Konst);
op1.Free(build);
op2.Free(build);
- removed obsolete code from a_bossbrain.cpp. - fixed: divisions wasted one register for each operation due to a double allocation. - changed math operations to use less registers. There was a well-intended change to allocate the destination first, but the better approach is to first allocate the operands and free then before allocating the destination register.
2016-11-03 13:23:29 +00:00
ExpEmit to(build, ValueType->GetRegType());
Normalize line endings
2016-03-01 15:47:10 +00:00
if (ValueType->GetRegType() == REGT_FLOAT)
{
assert(op1.RegType == REGT_FLOAT && op2.RegType == REGT_FLOAT);
build->Emit(op2.Konst ? OP_MULF_RK : OP_MULF_RR, to.RegNum, op1.RegNum, op2.RegNum);
return to;
}
else
{
assert(ValueType->GetRegType() == REGT_INT);
assert(op1.RegType == REGT_INT && op2.RegType == REGT_INT);
build->Emit(op2.Konst ? OP_MUL_RK : OP_MUL_RR, to.RegNum, op1.RegNum, op2.RegNum);
return to;
}
}
else
{
// Division is not commutative, so either side may be constant (but not both).
assert(!op1.Konst || !op2.Konst);
assert(Operator == '%' || Operator == '/');
op1.Free(build);
op2.Free(build);
- removed obsolete code from a_bossbrain.cpp. - fixed: divisions wasted one register for each operation due to a double allocation. - changed math operations to use less registers. There was a well-intended change to allocate the destination first, but the better approach is to first allocate the operands and free then before allocating the destination register.
2016-11-03 13:23:29 +00:00
ExpEmit to(build, ValueType->GetRegType());
Normalize line endings
2016-03-01 15:47:10 +00:00
if (ValueType->GetRegType() == REGT_FLOAT)
{
assert(op1.RegType == REGT_FLOAT && op2.RegType == REGT_FLOAT);
build->Emit(Operator == '/' ? (op1.Konst ? OP_DIVF_KR : op2.Konst ? OP_DIVF_RK : OP_DIVF_RR)
: (op1.Konst ? OP_MODF_KR : op2.Konst ? OP_MODF_RK : OP_MODF_RR),
to.RegNum, op1.RegNum, op2.RegNum);
return to;
}
else
{
assert(ValueType->GetRegType() == REGT_INT);
assert(op1.RegType == REGT_INT && op2.RegType == REGT_INT);
- cleaned up FxCompareRel::Resolve. Also added unsigned integer support to it and FxMulDiv (these, aside from the float cast, are the only two operations where this is important.)
2016-11-18 11:23:58 +00:00
if (ValueType == TypeUInt32)
{
build->Emit(Operator == '/' ? (op1.Konst ? OP_DIVU_KR : op2.Konst ? OP_DIVU_RK : OP_DIVU_RR)
: (op1.Konst ? OP_MODU_KR : op2.Konst ? OP_MODU_RK : OP_MODU_RR),
to.RegNum, op1.RegNum, op2.RegNum);
}
else
{
build->Emit(Operator == '/' ? (op1.Konst ? OP_DIV_KR : op2.Konst ? OP_DIV_RK : OP_DIV_RR)
: (op1.Konst ? OP_MOD_KR : op2.Konst ? OP_MOD_RK : OP_MOD_RR),
to.RegNum, op1.RegNum, op2.RegNum);
}
Normalize line endings
2016-03-01 15:47:10 +00:00
return to;
}
}
}
//==========================================================================
//
//
//
//==========================================================================
- implemented '**' (power) operator. To ensure reliability, acustom 'pow' function will be used to calculate it. - fixed: FxBinary::ResolveLR' check for numeric operations was incomplete. Like far too many other places it just assumed that everything with ValueType->GetRegType() == REGT_INT is a numeric type, but for names this is not the case.
2016-10-17 13:17:48 +00:00
FxPow::FxPow(FxExpression *l, FxExpression *r)
: FxBinary(TK_MulMul, new FxFloatCast(l), new FxFloatCast(r))
{
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxPow::Resolve(FCompileContext& ctx)
{
CHECKRESOLVED();
- same as last commit for FxMulDiv and FxPow. - some streamlining of FxAddSub.
2016-11-18 10:53:18 +00:00
RESOLVE(left, ctx);
RESOLVE(right, ctx);
if (!left || !right)
- preparations for null pointer support. - add pointer support to FxAssign.
2016-10-21 17:18:39 +00:00
{
- same as last commit for FxMulDiv and FxPow. - some streamlining of FxAddSub.
2016-11-18 10:53:18 +00:00
delete this;
- implemented the string concatenation operator '..'. This is capable of stringifying all of the common types for output. - gave OP_CONCAT some sane semantics. The way this was defined, by specifying the source operands as a range of registers instead of a pair like everything else made it completely useless for the task at hand. - changed formatting for floats to %.5f which for normal output in a game makes more sense. For special cases there should be a special formatting function for ints and floats that can do more specialized conversions.
2016-11-18 16:44:25 +00:00
return nullptr;
- same as last commit for FxMulDiv and FxPow. - some streamlining of FxAddSub.
2016-11-18 10:53:18 +00:00
}
if (!left->IsNumeric() || !right->IsNumeric())
{
ScriptPosition.Message(MSG_ERROR, "Numeric type expected for '**'");
- preparations for null pointer support. - add pointer support to FxAssign.
2016-10-21 17:18:39 +00:00
delete this;
return nullptr;
}
- same as last commit for FxMulDiv and FxPow. - some streamlining of FxAddSub.
2016-11-18 10:53:18 +00:00
if (!left->IsFloat())
{
left = (new FxFloatCast(left))->Resolve(ctx);
ABORT(left);
}
if (!right->IsFloat())
{
right = (new FxFloatCast(right))->Resolve(ctx);
ABORT(right);
}
- implemented '**' (power) operator. To ensure reliability, acustom 'pow' function will be used to calculate it. - fixed: FxBinary::ResolveLR' check for numeric operations was incomplete. Like far too many other places it just assumed that everything with ValueType->GetRegType() == REGT_INT is a numeric type, but for names this is not the case.
2016-10-17 13:17:48 +00:00
if (left->isConstant() && right->isConstant())
{
double v1 = static_cast<FxConstant *>(left)->GetValue().GetFloat();
double v2 = static_cast<FxConstant *>(right)->GetValue().GetFloat();
return new FxConstant(g_pow(v1, v2), left->ScriptPosition);
}
return this;
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxPow::Emit(VMFunctionBuilder *build)
{
ExpEmit op1 = left->Emit(build);
ExpEmit op2 = right->Emit(build);
// Pow is not commutative, so either side may be constant (but not both).
assert(!op1.Konst || !op2.Konst);
op1.Free(build);
op2.Free(build);
assert(op1.RegType == REGT_FLOAT && op2.RegType == REGT_FLOAT);
ExpEmit to(build, REGT_FLOAT);
build->Emit((op1.Konst ? OP_POWF_KR : op2.Konst ? OP_POWF_RK : OP_POWF_RR), to.RegNum, op1.RegNum, op2.RegNum);
return to;
}
//==========================================================================
//
//
//
//==========================================================================
Normalize line endings
2016-03-01 15:47:10 +00:00
FxCompareRel::FxCompareRel(int o, FxExpression *l, FxExpression *r)
: FxBinary(o, l, r)
{
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxCompareRel::Resolve(FCompileContext& ctx)
{
CHECKRESOLVED();
- cleaned up FxCompareRel::Resolve. Also added unsigned integer support to it and FxMulDiv (these, aside from the float cast, are the only two operations where this is important.)
2016-11-18 11:23:58 +00:00
RESOLVE(left, ctx);
RESOLVE(right, ctx);
if (!left || !right)
{
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
- cleaned up FxCompareRel::Resolve. Also added unsigned integer support to it and FxMulDiv (these, aside from the float cast, are the only two operations where this is important.)
2016-11-18 11:23:58 +00:00
}
Normalize line endings
2016-03-01 15:47:10 +00:00
- cleaned up FxCompareRel::Resolve. Also added unsigned integer support to it and FxMulDiv (these, aside from the float cast, are the only two operations where this is important.)
2016-11-18 11:23:58 +00:00
if (left->ValueType == TypeString || right->ValueType == TypeString)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- cleaned up FxCompareRel::Resolve. Also added unsigned integer support to it and FxMulDiv (these, aside from the float cast, are the only two operations where this is important.)
2016-11-18 11:23:58 +00:00
if (left->ValueType != TypeString)
{
left = new FxStringCast(left);
left = left->Resolve(ctx);
if (left == nullptr)
{
delete this;
return nullptr;
}
}
if (right->ValueType != TypeString)
{
right = new FxStringCast(right);
right = right->Resolve(ctx);
if (right == nullptr)
{
delete this;
return nullptr;
}
}
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
ValueType = TypeString;
- cleaned up FxCompareRel::Resolve. Also added unsigned integer support to it and FxMulDiv (these, aside from the float cast, are the only two operations where this is important.)
2016-11-18 11:23:58 +00:00
}
else if (left->IsNumeric() && right->IsNumeric())
{
Promote(ctx);
}
else
{
ScriptPosition.Message(MSG_ERROR, "Incompatible operands for relative comparison");
Normalize line endings
2016-03-01 15:47:10 +00:00
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- cleaned up FxCompareRel::Resolve. Also added unsigned integer support to it and FxMulDiv (these, aside from the float cast, are the only two operations where this is important.)
2016-11-18 11:23:58 +00:00
if (left->isConstant() && right->isConstant())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
int v;
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
if (ValueType == TypeString)
{
FString v1 = static_cast<FxConstant *>(left)->GetValue().GetString();
FString v2 = static_cast<FxConstant *>(right)->GetValue().GetString();
int res = v1.Compare(v2);
v = Operator == '<' ? res < 0 :
Operator == '>' ? res > 0 :
Operator == TK_Geq ? res >= 0 :
Operator == TK_Leq ? res <= 0 : 0;
}
else if (IsFloat())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
double v1 = static_cast<FxConstant *>(left)->GetValue().GetFloat();
double v2 = static_cast<FxConstant *>(right)->GetValue().GetFloat();
v = Operator == '<'? v1 < v2 :
Operator == '>'? v1 > v2 :
Operator == TK_Geq? v1 >= v2 :
Operator == TK_Leq? v1 <= v2 : 0;
}
- cleaned up FxCompareRel::Resolve. Also added unsigned integer support to it and FxMulDiv (these, aside from the float cast, are the only two operations where this is important.)
2016-11-18 11:23:58 +00:00
else if (ValueType == TypeUInt32)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- cleaned up FxCompareRel::Resolve. Also added unsigned integer support to it and FxMulDiv (these, aside from the float cast, are the only two operations where this is important.)
2016-11-18 11:23:58 +00:00
int v1 = static_cast<FxConstant *>(left)->GetValue().GetUInt();
int v2 = static_cast<FxConstant *>(right)->GetValue().GetUInt();
Normalize line endings
2016-03-01 15:47:10 +00:00
v = Operator == '<'? v1 < v2 :
Operator == '>'? v1 > v2 :
Operator == TK_Geq? v1 >= v2 :
Operator == TK_Leq? v1 <= v2 : 0;
}
- cleaned up FxCompareRel::Resolve. Also added unsigned integer support to it and FxMulDiv (these, aside from the float cast, are the only two operations where this is important.)
2016-11-18 11:23:58 +00:00
else
{
int v1 = static_cast<FxConstant *>(left)->GetValue().GetInt();
int v2 = static_cast<FxConstant *>(right)->GetValue().GetInt();
v = Operator == '<' ? v1 < v2 :
Operator == '>' ? v1 > v2 :
Operator == TK_Geq ? v1 >= v2 :
Operator == TK_Leq ? v1 <= v2 : 0;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
FxExpression *e = new FxConstant(v, ScriptPosition);
delete this;
return e;
}
- cleaned up FxCompareRel::Resolve. Also added unsigned integer support to it and FxMulDiv (these, aside from the float cast, are the only two operations where this is important.)
2016-11-18 11:23:58 +00:00
CompareType = ValueType; // needs to be preserved for detection of unsigned compare.
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
ValueType = TypeBool;
Normalize line endings
2016-03-01 15:47:10 +00:00
return this;
}
//==========================================================================
//
//
//
//==========================================================================
- branch optimization.
2016-12-01 23:51:29 +00:00
ExpEmit FxCompareRel::EmitCommon(VMFunctionBuilder *build, bool forcompare, bool invert)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
ExpEmit op1 = left->Emit(build);
ExpEmit op2 = right->Emit(build);
assert(op1.RegType == op2.RegType);
assert(!op1.Konst || !op2.Konst);
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
if (op1.RegType == REGT_STRING)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
ExpEmit to(build, REGT_INT);
int a = Operator == '<' ? CMP_LT :
Operator == '>' ? CMP_LE | CMP_CHECK :
Operator == TK_Geq ? CMP_LT | CMP_CHECK : CMP_LE;
if (op1.Konst)
{
a |= CMP_BK;
}
else
{
op1.Free(build);
}
if (op2.Konst)
{
a |= CMP_CK;
}
else
{
op2.Free(build);
}
- branch optimization.
2016-12-01 23:51:29 +00:00
if (invert) a ^= CMP_CHECK;
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
- branch optimization.
2016-12-01 23:51:29 +00:00
if (!forcompare) build->Emit(OP_LI, to.RegNum, 0, 0);
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
build->Emit(OP_CMPS, a, op1.RegNum, op2.RegNum);
- branch optimization.
2016-12-01 23:51:29 +00:00
if (!forcompare)
{
build->Emit(OP_JMP, 1);
build->Emit(OP_LI, to.RegNum, 1);
}
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
return to;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
assert(op1.RegType == REGT_INT || op1.RegType == REGT_FLOAT);
assert(Operator == '<' || Operator == '>' || Operator == TK_Geq || Operator == TK_Leq);
static const VM_UBYTE InstrMap[][4] =
{
- cleaned up FxCompareRel::Resolve. Also added unsigned integer support to it and FxMulDiv (these, aside from the float cast, are the only two operations where this is important.)
2016-11-18 11:23:58 +00:00
{ OP_LT_RR, OP_LTF_RR, OP_LTU_RR, 0 }, // <
{ OP_LE_RR, OP_LEF_RR, OP_LEU_RR, 1 }, // >
{ OP_LT_RR, OP_LTF_RR, OP_LTU_RR, 1 }, // >=
{ OP_LE_RR, OP_LEF_RR, OP_LEU_RR, 0 } // <=
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
};
int instr, check;
ExpEmit to(build, REGT_INT);
int index = Operator == '<' ? 0 :
Operator == '>' ? 1 :
Operator == TK_Geq ? 2 : 3;
Normalize line endings
2016-03-01 15:47:10 +00:00
- cleaned up FxCompareRel::Resolve. Also added unsigned integer support to it and FxMulDiv (these, aside from the float cast, are the only two operations where this is important.)
2016-11-18 11:23:58 +00:00
int mode = op1.RegType == REGT_FLOAT ? 1 : CompareType == TypeUInt32 ? 2 : 0;
instr = InstrMap[index][mode];
check = InstrMap[index][3];
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
if (op2.Konst)
{
instr += 1;
}
else
{
op2.Free(build);
}
if (op1.Konst)
{
instr += 2;
}
else
{
op1.Free(build);
}
- branch optimization.
2016-12-01 23:51:29 +00:00
if (invert) check ^= 1;
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
// See FxBoolCast for comments, since it's the same thing.
- branch optimization.
2016-12-01 23:51:29 +00:00
if (!forcompare) build->Emit(OP_LI, to.RegNum, 0, 0);
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
build->Emit(instr, check, op1.RegNum, op2.RegNum);
- branch optimization.
2016-12-01 23:51:29 +00:00
if (!forcompare)
{
build->Emit(OP_JMP, 1);
build->Emit(OP_LI, to.RegNum, 1);
}
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
return to;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- branch optimization.
2016-12-01 23:51:29 +00:00
ExpEmit FxCompareRel::Emit(VMFunctionBuilder *build)
{
return EmitCommon(build, false, false);
}
void FxCompareRel::EmitCompare(VMFunctionBuilder *build, bool invert, TArray<size_t> &patchspots_yes, TArray<size_t> &patchspots_no)
{
ExpEmit emit = EmitCommon(build, true, invert);
emit.Free(build);
patchspots_no.Push(build->Emit(OP_JMP, 0));
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
//
//
//==========================================================================
FxCompareEq::FxCompareEq(int o, FxExpression *l, FxExpression *r)
: FxBinary(o, l, r)
{
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxCompareEq::Resolve(FCompileContext& ctx)
{
CHECKRESOLVED();
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
RESOLVE(left, ctx);
RESOLVE(right, ctx);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (!left || !right)
{
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
if (left->ValueType != right->ValueType) // identical types are always comparable, if they can be placed in a register, so we can save most checks if this is the case.
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
// Special cases: Compare strings and names with names, sounds, colors, state labels and class types.
// These are all types a string can be implicitly cast into, so for convenience, so they should when doing a comparison.
if ((left->ValueType == TypeString || left->ValueType == TypeName) &&
(right->ValueType == TypeName || right->ValueType == TypeSound || right->ValueType == TypeColor || right->ValueType->IsKindOf(RUNTIME_CLASS(PClassPointer)) || right->ValueType == TypeStateLabel))
{
left = new FxTypeCast(left, right->ValueType, false, true);
left = left->Resolve(ctx);
ABORT(left);
ValueType = right->ValueType;
}
else if ((right->ValueType == TypeString || right->ValueType == TypeName) &&
(left->ValueType == TypeName || left->ValueType == TypeSound || left->ValueType == TypeColor || left->ValueType->IsKindOf(RUNTIME_CLASS(PClassPointer)) || left->ValueType == TypeStateLabel))
{
right = new FxTypeCast(right, left->ValueType, false, true);
right = right->Resolve(ctx);
ABORT(right);
ValueType = left->ValueType;
}
else if (left->IsNumeric() && right->IsNumeric())
{
Promote(ctx);
}
- allow A_M_Refire to be called without state label because this seems to have been used in existing DECORATE mods. This way of calling it will revert to the old behavior of jumping one state forward instead of to a state label.
2016-12-11 12:07:25 +00:00
// allows comparing state labels with null pointers.
else if (left->ValueType == TypeStateLabel && right->ValueType == TypeNullPtr)
{
right = new FxTypeCast(right, TypeStateLabel, false);
SAFE_RESOLVE(right, ctx);
}
else if (right->ValueType == TypeStateLabel && left->ValueType == TypeNullPtr)
{
left = new FxTypeCast(left, TypeStateLabel, false);
SAFE_RESOLVE(left, ctx);
}
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
else if (left->ValueType->GetRegType() == REGT_POINTER && right->ValueType->GetRegType() == REGT_POINTER)
{
if (left->ValueType != right->ValueType && right->ValueType != TypeNullPtr && left->ValueType != TypeNullPtr &&
- scriptified the Minotaur. Interesting tidbit: The damage calculation in P_MinotaurSlam had been incorrect for the Heretic version since the friendly Hexen Dark Servant was added, but nobody ever noticed in 14 years...
2016-11-26 00:14:47 +00:00
!AreCompatiblePointerTypes(left->ValueType, right->ValueType, true))
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
{
goto error;
}
}
else
{
goto error;
}
}
else if (left->ValueType->GetRegType() == REGT_NIL)
{
goto error;
}
else
{
ValueType = left->ValueType;
}
if (Operator == TK_ApproxEq && ValueType->GetRegType() != REGT_FLOAT && ValueType->GetRegType() != REGT_STRING)
{
// Only floats, vectors and strings have handling for '~==', for all other types this is an error.
goto error;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
if (left->isConstant() && right->isConstant())
{
int v;
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
if (ValueType == TypeString)
{
FString v1 = static_cast<FxConstant *>(left)->GetValue().GetString();
FString v2 = static_cast<FxConstant *>(right)->GetValue().GetString();
if (Operator == TK_ApproxEq) v = !v1.CompareNoCase(v2);
else
{
v = !!v1.Compare(v2);
if (Operator == TK_Eq) v = !v;
}
}
else if (ValueType->GetRegType() == REGT_FLOAT)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
double v1 = static_cast<FxConstant *>(left)->GetValue().GetFloat();
double v2 = static_cast<FxConstant *>(right)->GetValue().GetFloat();
- implemented ~== operator. Turned out this was really simple because the functionality was already there.
2016-10-22 07:31:37 +00:00
v = Operator == TK_Eq? v1 == v2 : Operator == TK_Neq? v1 != v2 : fabs(v1-v2) < VM_EPSILON;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
int v1 = static_cast<FxConstant *>(left)->GetValue().GetInt();
int v2 = static_cast<FxConstant *>(right)->GetValue().GetInt();
v = Operator == TK_Eq? v1 == v2 : v1 != v2;
}
FxExpression *e = new FxConstant(v, ScriptPosition);
delete this;
return e;
}
- 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
else
{
- scriptified a_hereticimp.cpp. - fixed the comparison against 0 simplification which did not negate the result for '=='.
2016-11-02 10:44:48 +00:00
// also simplify comparisons against zero. For these a bool cast/unary not on the other value will do just as well and create better code.
if (Operator != TK_ApproxEq)
- 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
{
- scriptified a_hereticimp.cpp. - fixed the comparison against 0 simplification which did not negate the result for '=='.
2016-11-02 10:44:48 +00:00
if (left->isConstant())
- 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
{
- scriptified a_hereticimp.cpp. - fixed the comparison against 0 simplification which did not negate the result for '=='.
2016-11-02 10:44:48 +00:00
bool leftisnull;
switch (left->ValueType->GetRegType())
{
case REGT_INT:
leftisnull = static_cast<FxConstant *>(left)->GetValue().GetInt() == 0;
break;
- 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
- scriptified a_hereticimp.cpp. - fixed the comparison against 0 simplification which did not negate the result for '=='.
2016-11-02 10:44:48 +00:00
case REGT_FLOAT:
assert(left->ValueType->GetRegCount() == 1); // vectors should not be able to get here.
leftisnull = static_cast<FxConstant *>(left)->GetValue().GetFloat() == 0;
break;
- 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
- scriptified a_hereticimp.cpp. - fixed the comparison against 0 simplification which did not negate the result for '=='.
2016-11-02 10:44:48 +00:00
case REGT_POINTER:
leftisnull = static_cast<FxConstant *>(left)->GetValue().GetPointer() == nullptr;
break;
default:
leftisnull = false;
}
if (leftisnull)
{
FxExpression *x;
if (Operator == TK_Eq) x = new FxUnaryNotBoolean(right);
else x = new FxBoolCast(right);
right = nullptr;
delete this;
return x->Resolve(ctx);
}
- 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
}
- scriptified a_hereticimp.cpp. - fixed the comparison against 0 simplification which did not negate the result for '=='.
2016-11-02 10:44:48 +00:00
if (right->isConstant())
- 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
{
- scriptified a_hereticimp.cpp. - fixed the comparison against 0 simplification which did not negate the result for '=='.
2016-11-02 10:44:48 +00:00
bool rightisnull;
switch (right->ValueType->GetRegType())
{
case REGT_INT:
rightisnull = static_cast<FxConstant *>(right)->GetValue().GetInt() == 0;
break;
- 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
- scriptified a_hereticimp.cpp. - fixed the comparison against 0 simplification which did not negate the result for '=='.
2016-11-02 10:44:48 +00:00
case REGT_FLOAT:
assert(right->ValueType->GetRegCount() == 1); // vectors should not be able to get here.
rightisnull = static_cast<FxConstant *>(right)->GetValue().GetFloat() == 0;
break;
- 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
- scriptified a_hereticimp.cpp. - fixed the comparison against 0 simplification which did not negate the result for '=='.
2016-11-02 10:44:48 +00:00
case REGT_POINTER:
rightisnull = static_cast<FxConstant *>(right)->GetValue().GetPointer() == nullptr;
break;
- 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
- scriptified a_hereticimp.cpp. - fixed the comparison against 0 simplification which did not negate the result for '=='.
2016-11-02 10:44:48 +00:00
default:
rightisnull = false;
}
if (rightisnull)
{
FxExpression *x;
if (Operator == TK_Eq) x = new FxUnaryNotBoolean(left);
else x = new FxBoolCast(left);
left = nullptr;
delete this;
return x->Resolve(ctx);
}
- 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
}
}
}
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
ValueType = TypeBool;
Normalize line endings
2016-03-01 15:47:10 +00:00
return this;
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
error:
ScriptPosition.Message(MSG_ERROR, "Incompatible operands for %s comparison", Operator == TK_Eq ? "==" : Operator == TK_Neq ? "!=" : "~==");
delete this;
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
//
//
//==========================================================================
- branch optimization.
2016-12-01 23:51:29 +00:00
ExpEmit FxCompareEq::EmitCommon(VMFunctionBuilder *build, bool forcompare, bool invert)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
ExpEmit op1 = left->Emit(build);
ExpEmit op2 = right->Emit(build);
assert(op1.RegType == op2.RegType);
int instr;
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
if (op1.RegType == REGT_STRING)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
ExpEmit to(build, REGT_INT);
assert(Operator == TK_Eq || Operator == TK_Neq || Operator == TK_ApproxEq);
int a = Operator == TK_Eq ? CMP_EQ :
Operator == TK_Neq ? CMP_EQ | CMP_CHECK : CMP_EQ | CMP_APPROX;
Normalize line endings
2016-03-01 15:47:10 +00:00
- branch optimization.
2016-12-01 23:51:29 +00:00
if (op1.Konst) a |= CMP_BK;
- fixed: String comparisons with constants did not work.
2016-11-09 19:28:46 +00:00
if (op2.Konst) a |= CMP_CK;
- branch optimization.
2016-12-01 23:51:29 +00:00
if (invert) a ^= CMP_CHECK;
- fixed: String comparisons with constants did not work.
2016-11-09 19:28:46 +00:00
- branch optimization.
2016-12-01 23:51:29 +00:00
if (!forcompare) build->Emit(OP_LI, to.RegNum, 0, 0);
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
build->Emit(OP_CMPS, a, op1.RegNum, op2.RegNum);
- branch optimization.
2016-12-01 23:51:29 +00:00
if (!forcompare)
{
build->Emit(OP_JMP, 1);
build->Emit(OP_LI, to.RegNum, 1);
}
- fixed: String comparisons with constants did not work.
2016-11-09 19:28:46 +00:00
op1.Free(build);
op2.Free(build);
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
return to;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
// Only the second operand may be constant.
if (op1.Konst)
{
swapvalues(op1, op2);
}
assert(!op1.Konst);
assert(op1.RegCount >= 1 && op1.RegCount <= 3);
ExpEmit to(build, REGT_INT);
static int flops[] = { OP_EQF_R, OP_EQV2_R, OP_EQV3_R };
instr = op1.RegType == REGT_INT ? OP_EQ_R :
op1.RegType == REGT_FLOAT ? flops[op1.RegCount - 1] :
OP_EQA_R;
op1.Free(build);
if (!op2.Konst)
{
op2.Free(build);
}
else
{
instr += 1;
}
// See FxUnaryNotBoolean for comments, since it's the same thing.
- branch optimization.
2016-12-01 23:51:29 +00:00
if (!forcompare) build->Emit(OP_LI, to.RegNum, 0, 0);
build->Emit(instr, int(invert) ^ (Operator == TK_ApproxEq ? CMP_APPROX : ((Operator != TK_Eq) ? CMP_CHECK : 0)), op1.RegNum, op2.RegNum);
if (!forcompare)
{
build->Emit(OP_JMP, 1);
build->Emit(OP_LI, to.RegNum, 1);
}
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
return to;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- branch optimization.
2016-12-01 23:51:29 +00:00
ExpEmit FxCompareEq::Emit(VMFunctionBuilder *build)
{
return EmitCommon(build, false, false);
}
void FxCompareEq::EmitCompare(VMFunctionBuilder *build, bool invert, TArray<size_t> &patchspots_yes, TArray<size_t> &patchspots_no)
{
ExpEmit emit = EmitCommon(build, true, invert);
emit.Free(build);
patchspots_no.Push(build->Emit(OP_JMP, 0));
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
//
//
//==========================================================================
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
FxBitOp::FxBitOp(int o, FxExpression *l, FxExpression *r)
Normalize line endings
2016-03-01 15:47:10 +00:00
: FxBinary(o, l, r)
{
ValueType = TypeSInt32;
}
//==========================================================================
//
//
//
//==========================================================================
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
FxExpression *FxBitOp::Resolve(FCompileContext& ctx)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
CHECKRESOLVED();
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
RESOLVE(left, ctx);
RESOLVE(right, ctx);
if (!left || !right)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
delete this;
- implemented the string concatenation operator '..'. This is capable of stringifying all of the common types for output. - gave OP_CONCAT some sane semantics. The way this was defined, by specifying the source operands as a range of registers instead of a pair like everything else made it completely useless for the task at hand. - changed formatting for floats to %.5f which for normal output in a game makes more sense. For special cases there should be a special formatting function for ints and floats that can do more specialized conversions.
2016-11-18 16:44:25 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
if (left->ValueType == TypeBool && right->ValueType == TypeBool)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
ValueType = TypeBool;
}
else if (left->IsNumeric() && right->IsNumeric())
{
if (!Promote(ctx, true)) return nullptr;
}
else
{
ScriptPosition.Message(MSG_ERROR, "Incompatible operands for bit operation");
Normalize line endings
2016-03-01 15:47:10 +00:00
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
if (left->isConstant() && right->isConstant())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
int v1 = static_cast<FxConstant *>(left)->GetValue().GetInt();
int v2 = static_cast<FxConstant *>(right)->GetValue().GetInt();
FxExpression *e = new FxConstant(
Operator == '&'? v1 & v2 :
Operator == '|'? v1 | v2 :
Operator == '^'? v1 ^ v2 : 0, ScriptPosition);
delete this;
return e;
}
return this;
}
//==========================================================================
//
//
//
//==========================================================================
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
ExpEmit FxBitOp::Emit(VMFunctionBuilder *build)
{
assert(left->ValueType->GetRegType() == REGT_INT);
assert(right->ValueType->GetRegType() == REGT_INT);
int instr, rop;
ExpEmit op1, op2;
op1 = left->Emit(build);
op2 = right->Emit(build);
if (op1.Konst)
{
swapvalues(op1, op2);
}
assert(!op1.Konst);
rop = op2.RegNum;
op2.Free(build);
op1.Free(build);
instr = Operator == '&' ? OP_AND_RR :
Operator == '|' ? OP_OR_RR :
Operator == '^' ? OP_XOR_RR : -1;
assert(instr > 0);
ExpEmit to(build, REGT_INT);
build->Emit(instr + op2.Konst, to.RegNum, op1.RegNum, rop);
return to;
}
//==========================================================================
//
//
//
//==========================================================================
FxShift::FxShift(int o, FxExpression *l, FxExpression *r)
: FxBinary(o, l, r)
{
ValueType = TypeSInt32;
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxShift::Resolve(FCompileContext& ctx)
{
CHECKRESOLVED();
RESOLVE(left, ctx);
RESOLVE(right, ctx);
if (!left || !right)
{
delete this;
- implemented the string concatenation operator '..'. This is capable of stringifying all of the common types for output. - gave OP_CONCAT some sane semantics. The way this was defined, by specifying the source operands as a range of registers instead of a pair like everything else made it completely useless for the task at hand. - changed formatting for floats to %.5f which for normal output in a game makes more sense. For special cases there should be a special formatting function for ints and floats that can do more specialized conversions.
2016-11-18 16:44:25 +00:00
return nullptr;
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
}
if (left->IsNumeric() && right->IsNumeric())
{
if (!Promote(ctx, true)) return nullptr;
if (ValueType == TypeUInt32 && Operator == TK_RShift) Operator = TK_URShift;
}
else
{
ScriptPosition.Message(MSG_ERROR, "Incompatible operands for shift operation");
delete this;
return nullptr;
}
if (left->isConstant() && right->isConstant())
{
int v1 = static_cast<FxConstant *>(left)->GetValue().GetInt();
int v2 = static_cast<FxConstant *>(right)->GetValue().GetInt();
FxExpression *e = new FxConstant(
Operator == TK_LShift ? v1 << v2 :
Operator == TK_RShift ? v1 >> v2 :
Operator == TK_URShift ? int((unsigned int)(v1) >> v2) : 0, ScriptPosition);
delete this;
return e;
}
return this;
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxShift::Emit(VMFunctionBuilder *build)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
assert(left->ValueType->GetRegType() == REGT_INT);
assert(right->ValueType->GetRegType() == REGT_INT);
static const VM_UBYTE InstrMap[][4] =
{
{ OP_SLL_RR, OP_SLL_KR, OP_SLL_RI }, // TK_LShift
{ OP_SRA_RR, OP_SRA_KR, OP_SRA_RI }, // TK_RShift
{ OP_SRL_RR, OP_SRL_KR, OP_SRL_RI }, // TK_URShift
};
int index, instr, rop;
ExpEmit op1, op2;
index = Operator == TK_LShift ? 0 :
Operator == TK_RShift ? 1 :
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
Operator == TK_URShift ? 2 : -1;
Normalize line endings
2016-03-01 15:47:10 +00:00
assert(index >= 0);
op1 = left->Emit(build);
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
// Shift instructions use right-hand immediates instead of constant registers.
if (right->isConstant())
{
rop = static_cast<FxConstant *>(right)->GetValue().GetInt();
op2.Konst = true;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
{
Normalize line endings
2016-03-01 15:47:10 +00:00
op2 = right->Emit(build);
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
assert(!op2.Konst);
Normalize line endings
2016-03-01 15:47:10 +00:00
op2.Free(build);
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
rop = op2.RegNum;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
Normalize line endings
2016-03-01 15:47:10 +00:00
if (!op1.Konst)
{
op1.Free(build);
- implemented pass-by-reference arguments - so far only for memory based variables. - changed Dehacked weapon function lookup to check the symbol table instead of directly referencing the VM functions. Once scriptified these pointers will no longer be available. - removed all special ATAGs from the VM. While well intentioned any pointer tagged with them is basically unusable because it'd trigger asserts all over the place. - scriptified A_Punch for testing pass-by-reference parameters and stack variables.
2016-11-19 00:23:56 +00:00
instr = InstrMap[index][op2.Konst? 2:0];
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
assert(!op2.Konst);
instr = InstrMap[index][1];
}
- added missing unsigned casts to the VM. - make the pointer to string cast a bit more useful by using the actual object's type rather than 'Object' which can be a great asset when debugging. - fixed a few bad asserts.
2016-11-18 13:50:21 +00:00
assert(instr != 0);
Normalize line endings
2016-03-01 15:47:10 +00:00
ExpEmit to(build, REGT_INT);
build->Emit(instr, to.RegNum, op1.RegNum, rop);
return to;
}
//==========================================================================
//
//
//
//==========================================================================
- implemented the '<>=' operator - more as a VM coding exercise than for its usefulness, though.
2016-10-21 14:35:07 +00:00
FxLtGtEq::FxLtGtEq(FxExpression *l, FxExpression *r)
: FxBinary(TK_LtGtEq, l, r)
{
ValueType = TypeSInt32;
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxLtGtEq::Resolve(FCompileContext& ctx)
{
CHECKRESOLVED();
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
RESOLVE(left, ctx);
RESOLVE(right, ctx);
if (!left || !right)
- implemented the '<>=' operator - more as a VM coding exercise than for its usefulness, though.
2016-10-21 14:35:07 +00:00
{
delete this;
- implemented the string concatenation operator '..'. This is capable of stringifying all of the common types for output. - gave OP_CONCAT some sane semantics. The way this was defined, by specifying the source operands as a range of registers instead of a pair like everything else made it completely useless for the task at hand. - changed formatting for floats to %.5f which for normal output in a game makes more sense. For special cases there should be a special formatting function for ints and floats that can do more specialized conversions.
2016-11-18 16:44:25 +00:00
return nullptr;
- implemented the '<>=' operator - more as a VM coding exercise than for its usefulness, though.
2016-10-21 14:35:07 +00:00
}
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
if (left->IsNumeric() && right->IsNumeric())
- implemented the '<>=' operator - more as a VM coding exercise than for its usefulness, though.
2016-10-21 14:35:07 +00:00
{
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
Promote(ctx);
}
else
{
ScriptPosition.Message(MSG_ERROR, "<>= expects two numeric operands");
delete this;
return nullptr;
- implemented the '<>=' operator - more as a VM coding exercise than for its usefulness, though.
2016-10-21 14:35:07 +00:00
}
- cleanup of the remaining FxBinary operators. - changed FxCompareEq with strings and other types that can be cast to from a string always convert the string to the other type before comparing.
2016-11-18 13:19:55 +00:00
if (left->isConstant() && right->isConstant())
- implemented the '<>=' operator - more as a VM coding exercise than for its usefulness, though.
2016-10-21 14:35:07 +00:00
{
// let's cut this short and always compare doubles. For integers the result will be exactly the same as with an integer comparison, either signed or unsigned.
auto v1 = static_cast<FxConstant *>(left)->GetValue().GetFloat();
auto v2 = static_cast<FxConstant *>(right)->GetValue().GetFloat();
auto e = new FxConstant(v1 < v2 ? -1 : v1 > v2 ? 1 : 0, ScriptPosition);
delete this;
return e;
}
return this;
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxLtGtEq::Emit(VMFunctionBuilder *build)
{
ExpEmit op1 = left->Emit(build);
ExpEmit op2 = right->Emit(build);
assert(op1.RegType == op2.RegType);
assert(op1.RegType == REGT_INT || op1.RegType == REGT_FLOAT);
assert(!op1.Konst || !op2.Konst);
ExpEmit to(build, REGT_INT);
int instr = op1.RegType == REGT_INT ? (left->ValueType == TypeUInt32? OP_LTU_RR : OP_LT_RR) : OP_LTF_RR;
if (op1.Konst) instr += 2;
if (op2.Konst) instr++;
build->Emit(OP_LI, to.RegNum, 1); // default to 1
build->Emit(instr, 0, op1.RegNum, op2.RegNum); // if (left < right)
auto j1 = build->Emit(OP_JMP, 1);
build->Emit(OP_LI, to.RegNum, -1); // result is -1
auto j2 = build->Emit(OP_JMP, 1); // jump to end
build->BackpatchToHere(j1);
build->Emit(instr + OP_LE_RR - OP_LT_RR, 0, op1.RegNum, op2.RegNum); // if (left == right)
auto j3 = build->Emit(OP_JMP, 1);
build->Emit(OP_LI, to.RegNum, 0); // result is 0
build->BackpatchToHere(j2);
build->BackpatchToHere(j3);
return to;
}
//==========================================================================
//
//
//
//==========================================================================
- implemented the string concatenation operator '..'. This is capable of stringifying all of the common types for output. - gave OP_CONCAT some sane semantics. The way this was defined, by specifying the source operands as a range of registers instead of a pair like everything else made it completely useless for the task at hand. - changed formatting for floats to %.5f which for normal output in a game makes more sense. For special cases there should be a special formatting function for ints and floats that can do more specialized conversions.
2016-11-18 16:44:25 +00:00
FxConcat::FxConcat(FxExpression *l, FxExpression *r)
: FxBinary(TK_DotDot, l, r)
{
ValueType = TypeString;
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxConcat::Resolve(FCompileContext& ctx)
{
CHECKRESOLVED();
RESOLVE(left, ctx);
RESOLVE(right, ctx);
if (!left || !right)
{
delete this;
return nullptr;
}
// To concatenate two operands the only requirement is that they are integral types, i.e. can occupy a register
if (left->ValueType->GetRegType() == REGT_NIL || right->ValueType->GetRegType() == REGT_NIL)
{
ScriptPosition.Message(MSG_ERROR, "Invalid operand for string concatenation");
delete this;
return nullptr;
}
if (left->isConstant() && right->isConstant() && (left->ValueType == TypeString || left->ValueType == TypeName) && (right->ValueType == TypeString || right->ValueType == TypeName))
{
// for now this is only types which have a constant string representation.
auto v1 = static_cast<FxConstant *>(left)->GetValue().GetString();
auto v2 = static_cast<FxConstant *>(right)->GetValue().GetString();
auto e = new FxConstant(v1 + v2, ScriptPosition);
delete this;
return e;
}
return this;
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxConcat::Emit(VMFunctionBuilder *build)
{
ExpEmit op1 = left->Emit(build);
ExpEmit op2 = right->Emit(build);
ExpEmit strng, strng2;
if (op1.RegType == REGT_STRING && op1.Konst)
{
strng = ExpEmit(build, REGT_STRING);
build->Emit(OP_LKS, strng.RegNum, op1.RegNum);
}
else if (op1.RegType == REGT_STRING)
{
strng = op1;
}
else
{
- fixed uninitialized variable warning in codegen.cpp
2017-01-06 09:33:58 +00:00
int cast = 0;
- implemented the string concatenation operator '..'. This is capable of stringifying all of the common types for output. - gave OP_CONCAT some sane semantics. The way this was defined, by specifying the source operands as a range of registers instead of a pair like everything else made it completely useless for the task at hand. - changed formatting for floats to %.5f which for normal output in a game makes more sense. For special cases there should be a special formatting function for ints and floats that can do more specialized conversions.
2016-11-18 16:44:25 +00:00
strng = ExpEmit(build, REGT_STRING);
if (op1.Konst)
{
ExpEmit nonconst(build, op1.RegType);
build->Emit(op1.RegType == REGT_INT ? OP_LK : op1.RegType == REGT_FLOAT ? OP_LKF : OP_LKP, nonconst.RegNum, op1.RegNum);
op1 = nonconst;
}
if (op1.RegType == REGT_FLOAT) cast = op1.RegCount == 1 ? CAST_F2S : op1.RegCount == 2 ? CAST_V22S : CAST_V32S;
else if (left->ValueType == TypeUInt32) cast = CAST_U2S;
else if (left->ValueType == TypeName) cast = CAST_N2S;
else if (left->ValueType == TypeSound) cast = CAST_So2S;
else if (left->ValueType == TypeColor) cast = CAST_Co2S;
- added two new integral types SpriteID and TextureID, both are needed to allow proper serialization as they require something different to be written out than a regular integer.
2016-11-21 12:45:33 +00:00
else if (left->ValueType == TypeSpriteID) cast = CAST_SID2S;
else if (left->ValueType == TypeTextureID) cast = CAST_TID2S;
- implemented the string concatenation operator '..'. This is capable of stringifying all of the common types for output. - gave OP_CONCAT some sane semantics. The way this was defined, by specifying the source operands as a range of registers instead of a pair like everything else made it completely useless for the task at hand. - changed formatting for floats to %.5f which for normal output in a game makes more sense. For special cases there should be a special formatting function for ints and floats that can do more specialized conversions.
2016-11-18 16:44:25 +00:00
else if (op1.RegType == REGT_POINTER) cast = CAST_P2S;
else if (op1.RegType == REGT_INT) cast = CAST_I2S;
else assert(false && "Bad type for string concatenation");
build->Emit(OP_CAST, strng.RegNum, op1.RegNum, cast);
op1.Free(build);
}
if (op2.RegType == REGT_STRING && op2.Konst)
{
strng2 = ExpEmit(build, REGT_STRING);
build->Emit(OP_LKS, strng2.RegNum, op2.RegNum);
}
else if (op2.RegType == REGT_STRING)
{
strng2 = op2;
}
else
{
Fixed warning reported by GCC/Clang when optimization is enabled src/scripting/codegeneration/codegen.cpp:4097:12: warning: variable 'cast' is used uninitialized whenever 'if' condition is false
2017-01-22 15:00:36 +00:00
int cast = 0;
- implemented the string concatenation operator '..'. This is capable of stringifying all of the common types for output. - gave OP_CONCAT some sane semantics. The way this was defined, by specifying the source operands as a range of registers instead of a pair like everything else made it completely useless for the task at hand. - changed formatting for floats to %.5f which for normal output in a game makes more sense. For special cases there should be a special formatting function for ints and floats that can do more specialized conversions.
2016-11-18 16:44:25 +00:00
strng2 = ExpEmit(build, REGT_STRING);
if (op2.Konst)
{
ExpEmit nonconst(build, op2.RegType);
build->Emit(op2.RegType == REGT_INT ? OP_LK : op2.RegType == REGT_FLOAT ? OP_LKF : OP_LKP, nonconst.RegNum, op2.RegNum);
op2 = nonconst;
}
if (op2.RegType == REGT_FLOAT) cast = op2.RegCount == 1 ? CAST_F2S : op2.RegCount == 2 ? CAST_V22S : CAST_V32S;
else if (right->ValueType == TypeUInt32) cast = CAST_U2S;
else if (right->ValueType == TypeName) cast = CAST_N2S;
else if (right->ValueType == TypeSound) cast = CAST_So2S;
else if (right->ValueType == TypeColor) cast = CAST_Co2S;
- added two new integral types SpriteID and TextureID, both are needed to allow proper serialization as they require something different to be written out than a regular integer.
2016-11-21 12:45:33 +00:00
else if (right->ValueType == TypeSpriteID) cast = CAST_SID2S;
else if (right->ValueType == TypeTextureID) cast = CAST_TID2S;
- implemented the string concatenation operator '..'. This is capable of stringifying all of the common types for output. - gave OP_CONCAT some sane semantics. The way this was defined, by specifying the source operands as a range of registers instead of a pair like everything else made it completely useless for the task at hand. - changed formatting for floats to %.5f which for normal output in a game makes more sense. For special cases there should be a special formatting function for ints and floats that can do more specialized conversions.
2016-11-18 16:44:25 +00:00
else if (op2.RegType == REGT_POINTER) cast = CAST_P2S;
else if (op2.RegType == REGT_INT) cast = CAST_I2S;
else assert(false && "Bad type for string concatenation");
build->Emit(OP_CAST, strng2.RegNum, op2.RegNum, cast);
op2.Free(build);
}
strng.Free(build);
strng2.Free(build);
ExpEmit dest(build, REGT_STRING);
assert(strng.RegType == strng2.RegType && strng.RegType == REGT_STRING);
build->Emit(OP_CONCAT, dest.RegNum, strng.RegNum, strng2.RegNum);
return dest;
}
//==========================================================================
//
//
//
//==========================================================================
Normalize line endings
2016-03-01 15:47:10 +00:00
FxBinaryLogical::FxBinaryLogical(int o, FxExpression *l, FxExpression *r)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_BinaryLogical, l->ScriptPosition)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
Operator=o;
left=l;
right=r;
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
ValueType = TypeBool;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
//
//
//==========================================================================
FxBinaryLogical::~FxBinaryLogical()
{
SAFE_DELETE(left);
SAFE_DELETE(right);
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxBinaryLogical::Resolve(FCompileContext& ctx)
{
CHECKRESOLVED();
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
RESOLVE(left, ctx);
RESOLVE(right, ctx);
ABORT(right && left);
if (left->ValueType != TypeBool)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
left = new FxBoolCast(left);
SAFE_RESOLVE(left, ctx);
}
if (right->ValueType != TypeBool)
{
right = new FxBoolCast(right);
SAFE_RESOLVE(right, ctx);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
int b_left=-1, b_right=-1;
if (left->isConstant()) b_left = static_cast<FxConstant *>(left)->GetValue().GetBool();
if (right->isConstant()) b_right = static_cast<FxConstant *>(right)->GetValue().GetBool();
// Do some optimizations. This will throw out all sub-expressions that are not
// needed to retrieve the final result.
if (Operator == TK_AndAnd)
{
if (b_left==0 || b_right==0)
{
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
FxExpression *x = new FxConstant(true, ScriptPosition);
Normalize line endings
2016-03-01 15:47:10 +00:00
delete this;
return x;
}
else if (b_left==1 && b_right==1)
{
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
FxExpression *x = new FxConstant(false, ScriptPosition);
Normalize line endings
2016-03-01 15:47:10 +00:00
delete this;
return x;
}
else if (b_left==1)
{
FxExpression *x = right;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
right=nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
delete this;
return x;
}
else if (b_right==1)
{
FxExpression *x = left;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
left=nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
delete this;
return x;
}
}
else if (Operator == TK_OrOr)
{
if (b_left==1 || b_right==1)
{
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
FxExpression *x = new FxConstant(true, ScriptPosition);
Normalize line endings
2016-03-01 15:47:10 +00:00
delete this;
return x;
}
if (b_left==0 && b_right==0)
{
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
FxExpression *x = new FxConstant(false, ScriptPosition);
Normalize line endings
2016-03-01 15:47:10 +00:00
delete this;
return x;
}
else if (b_left==0)
{
FxExpression *x = right;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
right=nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
delete this;
return x;
}
else if (b_right==0)
{
FxExpression *x = left;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
left=nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
delete this;
return x;
}
}
- flatten FxBinaryLogical chains into a single node for more efficient processing.
2016-11-02 14:46:15 +00:00
Flatten();
Normalize line endings
2016-03-01 15:47:10 +00:00
return this;
}
//==========================================================================
//
- flatten FxBinaryLogical chains into a single node for more efficient processing.
2016-11-02 14:46:15 +00:00
// flatten a list of the same operator into a single node.
Normalize line endings
2016-03-01 15:47:10 +00:00
//
//==========================================================================
- flatten FxBinaryLogical chains into a single node for more efficient processing.
2016-11-02 14:46:15 +00:00
void FxBinaryLogical::Flatten()
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- flatten FxBinaryLogical chains into a single node for more efficient processing.
2016-11-02 14:46:15 +00:00
if (left->ExprType == EFX_BinaryLogical && static_cast<FxBinaryLogical *>(left)->Operator == Operator)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- flatten FxBinaryLogical chains into a single node for more efficient processing.
2016-11-02 14:46:15 +00:00
list = std::move(static_cast<FxBinaryLogical *>(left)->list);
delete left;
}
else
{
list.Push(left);
}
Normalize line endings
2016-03-01 15:47:10 +00:00
- flatten FxBinaryLogical chains into a single node for more efficient processing.
2016-11-02 14:46:15 +00:00
if (right->ExprType == EFX_BinaryLogical && static_cast<FxBinaryLogical *>(right)->Operator == Operator)
{
auto &rlist = static_cast<FxBinaryLogical *>(right)->list;
auto cnt = rlist.Size();
auto v = list.Reserve(cnt);
for (unsigned i = 0; i < cnt; i++)
{
list[v + i] = rlist[i];
rlist[i] = nullptr;
}
delete right;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
- flatten FxBinaryLogical chains into a single node for more efficient processing.
2016-11-02 14:46:15 +00:00
list.Push(right);
}
left = right = nullptr;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
- flatten FxBinaryLogical chains into a single node for more efficient processing.
2016-11-02 14:46:15 +00:00
//==========================================================================
//
//
//
//==========================================================================
Normalize line endings
2016-03-01 15:47:10 +00:00
- flatten FxBinaryLogical chains into a single node for more efficient processing.
2016-11-02 14:46:15 +00:00
ExpEmit FxBinaryLogical::Emit(VMFunctionBuilder *build)
{
- partial optimization of chained comparisons.
2016-12-02 00:16:32 +00:00
TArray<size_t> yes, no;
bool invert = Operator == TK_OrOr;
- flatten FxBinaryLogical chains into a single node for more efficient processing.
2016-11-02 14:46:15 +00:00
for (unsigned i = 0; i < list.Size(); i++)
{
- partial optimization of chained comparisons.
2016-12-02 00:16:32 +00:00
list[i]->EmitCompare(build, invert, yes, no);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- partial optimization of chained comparisons.
2016-12-02 00:16:32 +00:00
build->BackpatchListToHere(yes);
- flatten FxBinaryLogical chains into a single node for more efficient processing.
2016-11-02 14:46:15 +00:00
ExpEmit to(build, REGT_INT);
build->Emit(OP_LI, to.RegNum, (Operator == TK_AndAnd) ? 1 : 0);
build->Emit(OP_JMP, 1);
- partial optimization of chained comparisons.
2016-12-02 00:16:32 +00:00
build->BackpatchListToHere(no);
- flatten FxBinaryLogical chains into a single node for more efficient processing.
2016-11-02 14:46:15 +00:00
auto ctarget = build->Emit(OP_LI, to.RegNum, (Operator == TK_AndAnd) ? 0 : 1);
- allow defining native fields through scripts. Internally this only requires exporting the address, but not the entire field. - added new VARF_Transient flag so that the decision whether to serialize a field does not depend solely on its native status. It may actually make a lot of sense to use the auto-serializer for native fields, too, as this would eliminate a lot of maintenance code. - defined (u)int8/16 as aliases to the byte and short types (Can't we not just get rid of this naming convention already...?) - exporting the fields of Actor revealed a few name clashes between them and some global types, so Actor.Sector was renamed to CurSector and Actor.Inventory was renamed to Actor.Inv.
2016-11-22 18:20:31 +00:00
list.DeleteAndClear();
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
list.ShrinkToFit();
- flatten FxBinaryLogical chains into a single node for more efficient processing.
2016-11-02 14:46:15 +00:00
return to;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
- implemented dot and cross products (not that I'd ever expect these to become useful in a game like Doom...)
2016-10-29 08:16:00 +00:00
//
//
//
//==========================================================================
FxDotCross::FxDotCross(int o, FxExpression *l, FxExpression *r)
: FxExpression(EFX_DotCross, l->ScriptPosition)
{
Operator = o;
left = l;
right = r;
}
//==========================================================================
//
//
//
//==========================================================================
FxDotCross::~FxDotCross()
{
SAFE_DELETE(left);
SAFE_DELETE(right);
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxDotCross::Resolve(FCompileContext& ctx)
{
CHECKRESOLVED();
RESOLVE(left, ctx);
RESOLVE(right, ctx);
ABORT(right && left);
if (!left->IsVector() || left->ValueType != right->ValueType || (Operator == TK_Cross && left->ValueType != TypeVector3))
{
ScriptPosition.Message(MSG_ERROR, "Incompatible operants for %sproduct", Operator == TK_Cross ? "cross-" : "dot-");
delete this;
return nullptr;
}
ValueType = Operator == TK_Cross ? (PType*)TypeVector3 : TypeFloat64;
return this;
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxDotCross::Emit(VMFunctionBuilder *build)
{
ExpEmit to(build, ValueType->GetRegType(), ValueType->GetRegCount());
ExpEmit op1 = left->Emit(build);
ExpEmit op2 = right->Emit(build);
int op = Operator == TK_Cross ? OP_CROSSV_RR : left->ValueType == TypeVector3 ? OP_DOTV3_RR : OP_DOTV2_RR;
build->Emit(op, to.RegNum, op1.RegNum, op2.RegNum);
op1.Free(build);
op2.Free(build);
return to;
}
//==========================================================================
Normalize line endings
2016-03-01 15:47:10 +00:00
//
//
//
//==========================================================================
- implemented the 'is' operator (i.e. class type check.)
2016-10-29 23:05:56 +00:00
FxTypeCheck::FxTypeCheck(FxExpression *l, FxExpression *r)
: FxExpression(EFX_TypeCheck, l->ScriptPosition)
{
- scriptified cht_Give and cht_Take and made them virtual function of PlayerPawn so that this can be better configured for mods that want other options in here. - improved the class pointer to string cast to print the actual type it describes and not the class pointer's own type. - fixed: The 'is' operator created non-working code when checking the inheritance of a class pointer, it only worked for objects.
2017-01-17 16:31:54 +00:00
left = l;
right = r;
- implemented the 'is' operator (i.e. class type check.)
2016-10-29 23:05:56 +00:00
ValueType = TypeBool;
}
//==========================================================================
//
//
//
//==========================================================================
FxTypeCheck::~FxTypeCheck()
{
SAFE_DELETE(left);
SAFE_DELETE(right);
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxTypeCheck::Resolve(FCompileContext& ctx)
{
CHECKRESOLVED();
- scriptified cht_Give and cht_Take and made them virtual function of PlayerPawn so that this can be better configured for mods that want other options in here. - improved the class pointer to string cast to print the actual type it describes and not the class pointer's own type. - fixed: The 'is' operator created non-working code when checking the inheritance of a class pointer, it only worked for objects.
2017-01-17 16:31:54 +00:00
// This must resolve the cast separately so that it can set the proper type for class descriptors.
- implemented the 'is' operator (i.e. class type check.)
2016-10-29 23:05:56 +00:00
RESOLVE(left, ctx);
RESOLVE(right, ctx);
ABORT(right && left);
- scriptified cht_Give and cht_Take and made them virtual function of PlayerPawn so that this can be better configured for mods that want other options in here. - improved the class pointer to string cast to print the actual type it describes and not the class pointer's own type. - fixed: The 'is' operator created non-working code when checking the inheritance of a class pointer, it only worked for objects.
2017-01-17 16:31:54 +00:00
if (left->ValueType->IsKindOf(RUNTIME_CLASS(PClassPointer)))
{
- fixed: only explicit class type casts must obey strict namespace rules, i.e. only '(class<type>)(variable_to_cast)' The general rule is as follows: A class name as a string will always be looked up fully, even if the class name gets shadows by another variable because strings are not identifiers. It is only class names as identifiers that must obey the rule that if it is not known yet or hidden by something else that it may not be found to ensure that the older variable does not take over the name if it gets reused.
2017-01-24 09:04:46 +00:00
left = new FxClassTypeCast(NewClassPointer(RUNTIME_CLASS(DObject)), left, false);
- scriptified cht_Give and cht_Take and made them virtual function of PlayerPawn so that this can be better configured for mods that want other options in here. - improved the class pointer to string cast to print the actual type it describes and not the class pointer's own type. - fixed: The 'is' operator created non-working code when checking the inheritance of a class pointer, it only worked for objects.
2017-01-17 16:31:54 +00:00
ClassCheck = true;
}
else
{
left = new FxTypeCast(left, NewPointer(RUNTIME_CLASS(DObject)), false);
ClassCheck = false;
}
- fixed: only explicit class type casts must obey strict namespace rules, i.e. only '(class<type>)(variable_to_cast)' The general rule is as follows: A class name as a string will always be looked up fully, even if the class name gets shadows by another variable because strings are not identifiers. It is only class names as identifiers that must obey the rule that if it is not known yet or hidden by something else that it may not be found to ensure that the older variable does not take over the name if it gets reused.
2017-01-24 09:04:46 +00:00
right = new FxClassTypeCast(NewClassPointer(RUNTIME_CLASS(DObject)), right, false);
- scriptified cht_Give and cht_Take and made them virtual function of PlayerPawn so that this can be better configured for mods that want other options in here. - improved the class pointer to string cast to print the actual type it describes and not the class pointer's own type. - fixed: The 'is' operator created non-working code when checking the inheritance of a class pointer, it only worked for objects.
2017-01-17 16:31:54 +00:00
RESOLVE(left, ctx);
RESOLVE(right, ctx);
ABORT(right && left);
- implemented the 'is' operator (i.e. class type check.)
2016-10-29 23:05:56 +00:00
return this;
}
//==========================================================================
//
//
//
//==========================================================================
- make dynamic object casts a dedicated VM instruction instead of a builtin function. This can see some heavy use in iterators where saving several hundreds of function calls can be achieved. In these cases, using a function to do the job will become a significant time waster.
2016-12-05 13:52:34 +00:00
ExpEmit FxTypeCheck::EmitCommon(VMFunctionBuilder *build)
- implemented the 'is' operator (i.e. class type check.)
2016-10-29 23:05:56 +00:00
{
- make dynamic object casts a dedicated VM instruction instead of a builtin function. This can see some heavy use in iterators where saving several hundreds of function calls can be achieved. In these cases, using a function to do the job will become a significant time waster.
2016-12-05 13:52:34 +00:00
ExpEmit castee = left->Emit(build);
ExpEmit casttype = right->Emit(build);
castee.Free(build);
casttype.Free(build);
ExpEmit ares(build, REGT_POINTER);
- scriptified cht_Give and cht_Take and made them virtual function of PlayerPawn so that this can be better configured for mods that want other options in here. - improved the class pointer to string cast to print the actual type it describes and not the class pointer's own type. - fixed: The 'is' operator created non-working code when checking the inheritance of a class pointer, it only worked for objects.
2017-01-17 16:31:54 +00:00
if (!ClassCheck) build->Emit(casttype.Konst ? OP_DYNCAST_K : OP_DYNCAST_R, ares.RegNum, castee.RegNum, casttype.RegNum);
else build->Emit(casttype.Konst ? OP_DYNCASTC_K : OP_DYNCASTC_R, ares.RegNum, castee.RegNum, casttype.RegNum);
- make dynamic object casts a dedicated VM instruction instead of a builtin function. This can see some heavy use in iterators where saving several hundreds of function calls can be achieved. In these cases, using a function to do the job will become a significant time waster.
2016-12-05 13:52:34 +00:00
return ares;
- implemented the 'is' operator (i.e. class type check.)
2016-10-29 23:05:56 +00:00
}
- make dynamic object casts a dedicated VM instruction instead of a builtin function. This can see some heavy use in iterators where saving several hundreds of function calls can be achieved. In these cases, using a function to do the job will become a significant time waster.
2016-12-05 13:52:34 +00:00
ExpEmit FxTypeCheck::Emit(VMFunctionBuilder *build)
- implemented the 'is' operator (i.e. class type check.)
2016-10-29 23:05:56 +00:00
{
- make dynamic object casts a dedicated VM instruction instead of a builtin function. This can see some heavy use in iterators where saving several hundreds of function calls can be achieved. In these cases, using a function to do the job will become a significant time waster.
2016-12-05 13:52:34 +00:00
ExpEmit ares = EmitCommon(build);
ares.Free(build);
ExpEmit bres(build, REGT_INT);
build->Emit(OP_CASTB, bres.RegNum, ares.RegNum, CASTB_A);
return bres;
- implemented the 'is' operator (i.e. class type check.)
2016-10-29 23:05:56 +00:00
}
- make dynamic object casts a dedicated VM instruction instead of a builtin function. This can see some heavy use in iterators where saving several hundreds of function calls can be achieved. In these cases, using a function to do the job will become a significant time waster.
2016-12-05 13:52:34 +00:00
void FxTypeCheck::EmitCompare(VMFunctionBuilder *build, bool invert, TArray<size_t> &patchspots_yes, TArray<size_t> &patchspots_no)
- implemented the 'is' operator (i.e. class type check.)
2016-10-29 23:05:56 +00:00
{
- make dynamic object casts a dedicated VM instruction instead of a builtin function. This can see some heavy use in iterators where saving several hundreds of function calls can be achieved. In these cases, using a function to do the job will become a significant time waster.
2016-12-05 13:52:34 +00:00
ExpEmit ares = EmitCommon(build);
ares.Free(build);
build->Emit(OP_EQA_K, !invert, ares.RegNum, build->GetConstantAddress(nullptr, ATAG_OBJECT));
patchspots_no.Push(build->Emit(OP_JMP, 0));
- implemented the 'is' operator (i.e. class type check.)
2016-10-29 23:05:56 +00:00
}
//==========================================================================
//
//
//
//==========================================================================
- 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
FxDynamicCast::FxDynamicCast(PClass * cls, FxExpression *r)
: FxExpression(EFX_DynamicCast, r->ScriptPosition)
{
- 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
expr = r;
- 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
CastType = cls;
}
//==========================================================================
//
//
//
//==========================================================================
FxDynamicCast::~FxDynamicCast()
{
SAFE_DELETE(expr);
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxDynamicCast::Resolve(FCompileContext& ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE(expr, ctx);
- added readonly pointers. They need to be defined with 'readonly<classtype>'. These are significantly different from declaring a field readonly in that they do not disallow modification of the variable itself but what it points to. For the actor defaults this is necessary to prevent accidental modification. A readonly pointer is actually a different type than a regular pointer. - fixed code generation for dynamic cast. It was missing the jump instruction after the compare.
2016-11-05 12:51:46 +00:00
bool constflag = expr->ValueType->IsKindOf(RUNTIME_CLASS(PPointer)) && static_cast<PPointer *>(expr->ValueType)->IsConst;
- fixed: Readonly pointers never were flagged as such. - fixed: Assignment from a readonly to a read-allowed pointer must be an error. - made GetDefaultByType a builtin so that it can do proper type assignment to the result, which for a function would be problematic in this case, even if automatic type deduction was implemented. Since this returns the class defaults which are not a real object, the result cannot be subjected to a type cast. - error out if a type cast of a readonly pointer is attempted. - fixed: FxBooleanNot could clobber a local variable because it used the source register to manipulate the result.
2016-11-27 14:50:58 +00:00
if (constflag)
{
// readonly pointers are normally only used for class defaults which lack type information to be cast properly, so we have to error out here.
ScriptPosition.Message(MSG_ERROR, "Cannot cast a readonly pointer");
delete this;
return nullptr;
}
- 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
expr = new FxTypeCast(expr, NewPointer(RUNTIME_CLASS(DObject), constflag), true, true);
expr = expr->Resolve(ctx);
if (expr == nullptr)
{
delete this;
return nullptr;
}
ValueType = NewPointer(CastType, constflag);
- 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
return this;
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxDynamicCast::Emit(VMFunctionBuilder *build)
{
- make dynamic object casts a dedicated VM instruction instead of a builtin function. This can see some heavy use in iterators where saving several hundreds of function calls can be achieved. In these cases, using a function to do the job will become a significant time waster.
2016-12-05 13:52:34 +00:00
ExpEmit castee = expr->Emit(build);
castee.Free(build);
ExpEmit ares(build, REGT_POINTER);
build->Emit(OP_DYNCAST_K, ares.RegNum, castee.RegNum, build->GetConstantAddress(CastType, ATAG_OBJECT));
return ares;
- 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
}
//==========================================================================
//
//
//
//==========================================================================
Normalize line endings
2016-03-01 15:47:10 +00:00
FxConditional::FxConditional(FxExpression *c, FxExpression *t, FxExpression *f)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_Conditional, c->ScriptPosition)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
condition = c;
truex=t;
falsex=f;
}
//==========================================================================
//
//
//
//==========================================================================
FxConditional::~FxConditional()
{
SAFE_DELETE(condition);
SAFE_DELETE(truex);
SAFE_DELETE(falsex);
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxConditional::Resolve(FCompileContext& ctx)
{
CHECKRESOLVED();
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
RESOLVE(condition, ctx);
Normalize line endings
2016-03-01 15:47:10 +00:00
RESOLVE(truex, ctx);
RESOLVE(falsex, ctx);
ABORT(condition && truex && falsex);
- implemented vector operations. Vectors are now fully working as local variables. - removed mulv_kr and divv_kr instructions. The first are redundant and the second are useless. Maybe remove all other vector/const operations as well? They won't get used by the code generator. - fixed disassembly of vector multiplication and division instructions.
2016-10-28 23:39:25 +00:00
if (truex->ValueType == falsex->ValueType)
ValueType = truex->ValueType;
else if (truex->ValueType == TypeBool && falsex->ValueType == TypeBool)
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
ValueType = TypeBool;
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
else if (truex->IsInteger() && falsex->IsInteger())
Normalize line endings
2016-03-01 15:47:10 +00:00
ValueType = TypeSInt32;
else if (truex->IsNumeric() && falsex->IsNumeric())
ValueType = TypeFloat64;
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
else if (truex->IsPointer() && falsex->ValueType == TypeNullPtr)
ValueType = truex->ValueType;
else if (falsex->IsPointer() && truex->ValueType == TypeNullPtr)
ValueType = falsex->ValueType;
- implemented vector operations. Vectors are now fully working as local variables. - removed mulv_kr and divv_kr instructions. The first are redundant and the second are useless. Maybe remove all other vector/const operations as well? They won't get used by the code generator. - fixed disassembly of vector multiplication and division instructions.
2016-10-28 23:39:25 +00:00
else
ValueType = TypeVoid;
Normalize line endings
2016-03-01 15:47:10 +00:00
//else if (truex->ValueType != falsex->ValueType)
- scriptified a_archvile.cpp. - fixed the type checks for the conditional operator.
2016-10-30 17:41:39 +00:00
if (ValueType->GetRegType() == REGT_NIL)
- implemented vector operations. Vectors are now fully working as local variables. - removed mulv_kr and divv_kr instructions. The first are redundant and the second are useless. Maybe remove all other vector/const operations as well? They won't get used by the code generator. - fixed disassembly of vector multiplication and division instructions.
2016-10-28 23:39:25 +00:00
{
ScriptPosition.Message(MSG_ERROR, "Incompatible types for ?: operator");
delete this;
- Fixed GCC/Clang errors from recent commits.
2016-10-30 12:43:20 +00:00
return nullptr;
- implemented vector operations. Vectors are now fully working as local variables. - removed mulv_kr and divv_kr instructions. The first are redundant and the second are useless. Maybe remove all other vector/const operations as well? They won't get used by the code generator. - fixed disassembly of vector multiplication and division instructions.
2016-10-28 23:39:25 +00:00
}
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
if (condition->ValueType != TypeBool)
{
condition = new FxBoolCast(condition);
SAFE_RESOLVE(condition, ctx);
}
Normalize line endings
2016-03-01 15:47:10 +00:00
if (condition->isConstant())
{
ExpVal condval = static_cast<FxConstant *>(condition)->GetValue();
bool result = condval.GetBool();
FxExpression *e = result? truex:falsex;
delete (result? falsex:truex);
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
falsex = truex = nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
delete this;
return e;
}
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
if (IsFloat())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
if (truex->ValueType->GetRegType() != REGT_FLOAT)
{
truex = new FxFloatCast(truex);
RESOLVE(truex, ctx);
}
if (falsex->ValueType->GetRegType() != REGT_FLOAT)
{
falsex = new FxFloatCast(falsex);
RESOLVE(falsex, ctx);
}
}
return this;
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxConditional::Emit(VMFunctionBuilder *build)
{
- branch optimization.
2016-12-01 23:51:29 +00:00
size_t truejump;
ExpEmit out, falseout;
Normalize line endings
2016-03-01 15:47:10 +00:00
// The true and false expressions ought to be assigned to the
// same temporary instead of being copied to it. Oh well; good enough
// for now.
- branch optimization.
2016-12-01 23:51:29 +00:00
TArray<size_t> yes, no;
condition->EmitCompare(build, false, yes, no);
Normalize line endings
2016-03-01 15:47:10 +00:00
- branch optimization.
2016-12-01 23:51:29 +00:00
build->BackpatchListToHere(yes);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (truex->isConstant() && truex->ValueType->GetRegType() == REGT_INT)
{
out = ExpEmit(build, REGT_INT);
build->EmitLoadInt(out.RegNum, static_cast<FxConstant *>(truex)->GetValue().GetInt());
}
else
{
ExpEmit trueop = truex->Emit(build);
if (trueop.Konst)
{
- fixed: RegAvailability never set the number of allocated registers to more than 32. - fixed register allocation in ?: operator which was quite broken.
2016-11-07 00:10:56 +00:00
trueop.Free(build);
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
if (trueop.RegType == REGT_FLOAT)
{
out = ExpEmit(build, REGT_FLOAT);
build->Emit(OP_LKF, out.RegNum, trueop.RegNum);
}
else if (trueop.RegType == REGT_POINTER)
{
out = ExpEmit(build, REGT_POINTER);
build->Emit(OP_LKP, out.RegNum, trueop.RegNum);
}
else
{
assert(trueop.RegType == REGT_STRING);
out = ExpEmit(build, REGT_STRING);
build->Emit(OP_LKS, out.RegNum, trueop.RegNum);
}
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
// Use the register returned by the true condition as the
- fixed: The conditional operator could clobber a local variable if it was the result of the true expression.
2017-01-02 21:26:36 +00:00
// target for the false condition, if temporary.
// If this is a local variable we need another register for the result.
if (trueop.Fixed)
{
out = ExpEmit(build, trueop.RegType);
build->Emit(truex->ValueType->GetMoveOp(), out.RegNum, trueop.RegNum, 0);
}
else out = trueop;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
Fixed: conditionals didn't properly compile to vm code
2016-07-04 17:54:26 +00:00
// Make sure to skip the false path.
truejump = build->Emit(OP_JMP, 0);
Normalize line endings
2016-03-01 15:47:10 +00:00
// Evaluate false expression.
- branch optimization.
2016-12-01 23:51:29 +00:00
build->BackpatchListToHere(no);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (falsex->isConstant() && falsex->ValueType->GetRegType() == REGT_INT)
{
build->EmitLoadInt(out.RegNum, static_cast<FxConstant *>(falsex)->GetValue().GetInt());
}
else
{
ExpEmit falseop = falsex->Emit(build);
if (falseop.Konst)
{
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
if (falseop.RegType == REGT_FLOAT)
{
build->Emit(OP_LKF, out.RegNum, falseop.RegNum);
}
else if (falseop.RegType == REGT_POINTER)
{
build->Emit(OP_LKP, out.RegNum, falseop.RegNum);
}
else
{
assert(falseop.RegType == REGT_STRING);
build->Emit(OP_LKS, out.RegNum, falseop.RegNum);
}
- fixed: RegAvailability never set the number of allocated registers to more than 32. - fixed register allocation in ?: operator which was quite broken.
2016-11-07 00:10:56 +00:00
falseop.Free(build);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
// Move result from the register returned by "false" to the one
// returned by "true" so that only one register is returned by
// this tree.
falseop.Free(build);
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
build->Emit(falsex->ValueType->GetMoveOp(), out.RegNum, falseop.RegNum, 0);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
Fixed: conditionals didn't properly compile to vm code
2016-07-04 17:54:26 +00:00
build->BackpatchToHere(truejump);
Normalize line endings
2016-03-01 15:47:10 +00:00
return out;
}
//==========================================================================
//
//
//
//==========================================================================
FxAbs::FxAbs(FxExpression *v)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_Abs, v->ScriptPosition)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
val = v;
ValueType = v->ValueType;
}
//==========================================================================
//
//
//
//==========================================================================
FxAbs::~FxAbs()
{
SAFE_DELETE(val);
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxAbs::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE(val, ctx);
- partial optimization of chained comparisons.
2016-12-02 00:16:32 +00:00
if (val->ValueType == TypeBool) // abs of a boolean is always the same as the operand
{
auto v = val;
val = nullptr;
delete this;
return v;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
if (!val->IsNumeric())
{
ScriptPosition.Message(MSG_ERROR, "Numeric type expected");
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else if (val->isConstant())
{
ExpVal value = static_cast<FxConstant *>(val)->GetValue();
switch (value.Type->GetRegType())
{
case REGT_INT:
value.Int = abs(value.Int);
break;
case REGT_FLOAT:
value.Float = fabs(value.Float);
break;
default:
// shouldn't happen
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
FxExpression *x = new FxConstant(value, ScriptPosition);
delete this;
return x;
}
ValueType = val->ValueType;
return this;
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxAbs::Emit(VMFunctionBuilder *build)
{
- scriptified Hexen's Dragon. - fixed several places in the code generator that did not consider locked registers for local variables: array indices, abs and floating point builtin functions. - added some debug aids to the bounds opcode. Just triggering an exception here which loses all relevant info is perfectly useless in a debug situation.
2016-11-16 18:18:21 +00:00
assert(ValueType == val->ValueType);
ExpEmit from = val->Emit(build);
ExpEmit to;
assert(from.Konst == 0);
assert(ValueType->GetRegCount() == 1);
// Do it in-place, unless a local variable
if (from.Fixed)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- scriptified Hexen's Dragon. - fixed several places in the code generator that did not consider locked registers for local variables: array indices, abs and floating point builtin functions. - added some debug aids to the bounds opcode. Just triggering an exception here which loses all relevant info is perfectly useless in a debug situation.
2016-11-16 18:18:21 +00:00
to = ExpEmit(build, from.RegType);
from.Free(build);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
- scriptified Hexen's Dragon. - fixed several places in the code generator that did not consider locked registers for local variables: array indices, abs and floating point builtin functions. - added some debug aids to the bounds opcode. Just triggering an exception here which loses all relevant info is perfectly useless in a debug situation.
2016-11-16 18:18:21 +00:00
to = from;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- scriptified Hexen's Dragon. - fixed several places in the code generator that did not consider locked registers for local variables: array indices, abs and floating point builtin functions. - added some debug aids to the bounds opcode. Just triggering an exception here which loses all relevant info is perfectly useless in a debug situation.
2016-11-16 18:18:21 +00:00
if (ValueType->GetRegType() == REGT_INT)
{
build->Emit(OP_ABS, to.RegNum, from.RegNum, 0);
}
else
{
build->Emit(OP_FLOP, to.RegNum, from.RegNum, FLOP_ABS);
}
return to;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
Add atan2, which was conspicuously absent, to the VM - DECORATE now has atan2(y,x) and VectorAngle(x,y) functions. They are identical except for the order of their parameters. The returned angle is in degrees (not radians).
2016-04-19 04:06:17 +00:00
//==========================================================================
//
//
//
//==========================================================================
FxATan2::FxATan2(FxExpression *y, FxExpression *x, const FScriptPosition &pos)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_ATan2, pos)
Add atan2, which was conspicuously absent, to the VM - DECORATE now has atan2(y,x) and VectorAngle(x,y) functions. They are identical except for the order of their parameters. The returned angle is in degrees (not radians).
2016-04-19 04:06:17 +00:00
{
yval = y;
xval = x;
}
//==========================================================================
//
//
//
//==========================================================================
FxATan2::~FxATan2()
{
SAFE_DELETE(yval);
SAFE_DELETE(xval);
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxATan2::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE(yval, ctx);
SAFE_RESOLVE(xval, ctx);
if (!yval->IsNumeric() || !xval->IsNumeric())
{
ScriptPosition.Message(MSG_ERROR, "numeric value expected for parameter");
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Add atan2, which was conspicuously absent, to the VM - DECORATE now has atan2(y,x) and VectorAngle(x,y) functions. They are identical except for the order of their parameters. The returned angle is in degrees (not radians).
2016-04-19 04:06:17 +00:00
}
if (yval->isConstant() && xval->isConstant())
{
double y = static_cast<FxConstant *>(yval)->GetValue().GetFloat();
double x = static_cast<FxConstant *>(xval)->GetValue().GetFloat();
FxExpression *z = new FxConstant(g_atan2(y, x) * (180 / M_PI), ScriptPosition);
delete this;
return z;
}
if (yval->ValueType->GetRegType() != REGT_FLOAT && !yval->isConstant())
{
yval = new FxFloatCast(yval);
}
if (xval->ValueType->GetRegType() != REGT_FLOAT && !xval->isConstant())
{
xval = new FxFloatCast(xval);
}
ValueType = TypeFloat64;
return this;
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxATan2::Emit(VMFunctionBuilder *build)
{
ExpEmit yreg = ToReg(build, yval);
ExpEmit xreg = ToReg(build, xval);
yreg.Free(build);
xreg.Free(build);
ExpEmit out(build, REGT_FLOAT);
build->Emit(OP_ATAN2, out.RegNum, yreg.RegNum, xreg.RegNum);
return out;
}
- added a 'new' intrinsic to create new objects from inside scripts. This is not tested yet and likely to not working correctly yet. Will be fixed once I get far enough to use it later.
2017-02-03 21:56:03 +00:00
//==========================================================================
//
//
//
//==========================================================================
FxNew::FxNew(FxExpression *v)
: FxExpression(EFX_New, v->ScriptPosition)
{
val = new FxClassTypeCast(NewClassPointer(RUNTIME_CLASS(DObject)), v, false);
ValueType = NewPointer(RUNTIME_CLASS(DObject));
}
//==========================================================================
//
//
//
//==========================================================================
FxNew::~FxNew()
{
SAFE_DELETE(val);
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxNew::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE(val, ctx);
if (!val->ValueType->IsKindOf(RUNTIME_CLASS(PClassPointer)))
{
ScriptPosition.Message(MSG_ERROR, "Class type expected");
delete this;
return nullptr;
}
if (val->isConstant())
{
auto cls = static_cast<PClass *>(static_cast<FxConstant*>(val)->GetValue().GetPointer());
ValueType = NewPointer(cls);
}
return this;
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxNew::Emit(VMFunctionBuilder *build)
{
assert(ValueType == val->ValueType);
ExpEmit from = val->Emit(build);
from.Free(build);
ExpEmit to(build, REGT_POINTER);
build->Emit(from.Konst ? OP_NEW_K : OP_NEW, to.RegNum, from.RegNum);
return to;
}
Add atan2, which was conspicuously absent, to the VM - DECORATE now has atan2(y,x) and VectorAngle(x,y) functions. They are identical except for the order of their parameters. The returned angle is in degrees (not radians).
2016-04-19 04:06:17 +00:00
//==========================================================================
//
// The atan2 opcode only takes registers as parameters, so any constants
// must be loaded into registers first.
//
//==========================================================================
ExpEmit FxATan2::ToReg(VMFunctionBuilder *build, FxExpression *val)
{
if (val->isConstant())
{
ExpEmit reg(build, REGT_FLOAT);
build->Emit(OP_LKF, reg.RegNum, build->GetConstantFloat(static_cast<FxConstant*>(val)->GetValue().GetFloat()));
return reg;
}
return val->Emit(build);
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
//
//
//==========================================================================
FxMinMax::FxMinMax(TArray<FxExpression*> &expr, FName type, const FScriptPosition &pos)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_MinMax, pos), Type(type)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
assert(expr.Size() > 0);
assert(type == NAME_Min || type == NAME_Max);
choices.Resize(expr.Size());
for (unsigned i = 0; i < expr.Size(); ++i)
{
choices[i] = expr[i];
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
expr[i] = nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxMinMax::Resolve(FCompileContext &ctx)
{
unsigned int i;
int intcount, floatcount;
CHECKRESOLVED();
// Determine if float or int
intcount = floatcount = 0;
for (i = 0; i < choices.Size(); ++i)
{
RESOLVE(choices[i], ctx);
ABORT(choices[i]);
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
if (choices[i]->IsFloat())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
floatcount++;
}
- added string handling to comparison operators.
2016-10-29 16:57:56 +00:00
else if (choices[i]->IsInteger())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
intcount++;
}
else
{
ScriptPosition.Message(MSG_ERROR, "Arguments must be of type int or float");
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
if (floatcount != 0)
{
ValueType = TypeFloat64;
if (intcount != 0)
{ // There are some ints that need to be cast to floats
for (i = 0; i < choices.Size(); ++i)
{
if (choices[i]->ValueType->GetRegType() == REGT_INT)
{
choices[i] = new FxFloatCast(choices[i]);
RESOLVE(choices[i], ctx);
ABORT(choices[i]);
}
}
}
}
else
{
ValueType = TypeSInt32;
}
// If at least two arguments are constants, they can be solved now.
// Look for first constant
for (i = 0; i < choices.Size(); ++i)
{
if (choices[i]->isConstant())
{
ExpVal best = static_cast<FxConstant *>(choices[i])->GetValue();
// Compare against remaining constants, which are removed.
// The best value gets stored in this one.
for (unsigned j = i + 1; j < choices.Size(); )
{
if (!choices[j]->isConstant())
{
j++;
}
else
{
ExpVal value = static_cast<FxConstant *>(choices[j])->GetValue();
assert(value.Type == ValueType);
if (Type == NAME_Min)
{
if (value.Type->GetRegType() == REGT_FLOAT)
{
if (value.Float < best.Float)
{
best.Float = value.Float;
}
}
else
{
if (value.Int < best.Int)
{
best.Int = value.Int;
}
}
}
else
{
if (value.Type->GetRegType() == REGT_FLOAT)
{
if (value.Float > best.Float)
{
best.Float = value.Float;
}
}
else
{
if (value.Int > best.Int)
{
best.Int = value.Int;
}
}
}
delete choices[j];
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
choices[j] = nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
choices.Delete(j);
}
}
FxExpression *x = new FxConstant(best, ScriptPosition);
if (i == 0 && choices.Size() == 1)
{ // Every choice was constant
delete this;
return x;
}
delete choices[i];
choices[i] = x;
break;
}
}
return this;
}
//==========================================================================
//
//
//
//==========================================================================
static void EmitLoad(VMFunctionBuilder *build, const ExpEmit resultreg, const ExpVal &value)
{
if (resultreg.RegType == REGT_FLOAT)
{
build->Emit(OP_LKF, resultreg.RegNum, build->GetConstantFloat(value.GetFloat()));
}
else
{
build->EmitLoadInt(resultreg.RegNum, value.GetInt());
}
}
ExpEmit FxMinMax::Emit(VMFunctionBuilder *build)
{
unsigned i;
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
int opcode;
Normalize line endings
2016-03-01 15:47:10 +00:00
assert(choices.Size() > 0);
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
assert(OP_MAXF_RK == OP_MAXF_RR+1);
assert(OP_MAX_RK == OP_MAX_RR+1);
assert(OP_MIN_RK == OP_MIN_RR+1);
assert(OP_MIN_RK == OP_MIN_RR+1);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (Type == NAME_Min)
{
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
opcode = ValueType->GetRegType() == REGT_FLOAT ? OP_MINF_RR : OP_MIN_RR;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
opcode = ValueType->GetRegType() == REGT_FLOAT ? OP_MAXF_RR : OP_MAX_RR;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
ExpEmit bestreg;
// Get first value into a register. This will also be the result register.
if (choices[0]->isConstant())
{
bestreg = ExpEmit(build, ValueType->GetRegType());
EmitLoad(build, bestreg, static_cast<FxConstant *>(choices[0])->GetValue());
}
else
{
bestreg = choices[0]->Emit(build);
}
// Compare every choice. Better matches get copied to the bestreg.
for (i = 1; i < choices.Size(); ++i)
{
ExpEmit checkreg = choices[i]->Emit(build);
assert(checkreg.RegType == bestreg.RegType);
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
build->Emit(opcode + checkreg.Konst, bestreg.RegNum, bestreg.RegNum, checkreg.RegNum);
checkreg.Free(build);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
return bestreg;
}
//==========================================================================
//
//
//
//==========================================================================
- the compile context now knows if it is invoked by ZScript or DECORATE, so that it can be more strict with ZScript if needed. - added a truncation warning to FxIntCast, which only occurs with ZScript, not with DECORATE. FxBoolCast is intentionally left out because it would defeat the reason for this cast type.
2016-10-15 19:35:31 +00:00
FxRandom::FxRandom(FRandom * r, FxExpression *mi, FxExpression *ma, const FScriptPosition &pos, bool nowarn)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_Random, pos)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
EmitTail = false;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
if (mi != nullptr && ma != nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- the compile context now knows if it is invoked by ZScript or DECORATE, so that it can be more strict with ZScript if needed. - added a truncation warning to FxIntCast, which only occurs with ZScript, not with DECORATE. FxBoolCast is intentionally left out because it would defeat the reason for this cast type.
2016-10-15 19:35:31 +00:00
min = new FxIntCast(mi, nowarn);
max = new FxIntCast(ma, nowarn);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
else min = max = nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
rng = r;
ValueType = TypeSInt32;
}
//==========================================================================
//
//
//
//==========================================================================
FxRandom::~FxRandom()
{
SAFE_DELETE(min);
SAFE_DELETE(max);
}
//==========================================================================
//
//
//
//==========================================================================
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
PPrototype *FxRandom::ReturnProto()
{
EmitTail = true;
return FxExpression::ReturnProto();
}
//==========================================================================
//
//
//
//==========================================================================
Normalize line endings
2016-03-01 15:47:10 +00:00
FxExpression *FxRandom::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
if (min && max)
{
RESOLVE(min, ctx);
RESOLVE(max, ctx);
ABORT(min && max);
assert(min->ValueType == ValueType);
assert(max->ValueType == ValueType);
}
return this;
};
//==========================================================================
//
//
//
//==========================================================================
- allow the VM to run on one global stack per thread. It is utterly pointless to require every function that wants to make a VM call to allocate a new stack first. The allocation overhead doubles the time to set up the call. With one stack, previously allocated memory can be reused. The only important thing is, if this ever gets used in a multithreaded environment to have the stack being declared as thread_local, although for ZDoom this is of no consequence. - eliminated all cases where native code was calling other native code through the VM interface. After scriptifying the game code, only 5 places were left which were quickly eliminated. This was mostly to ensure that the native VM function parameters do not need to be propagated further than absolutely necessary.
2016-11-30 16:15:01 +00:00
int BuiltinRandom(VMValue *param, TArray<VMValue> &defaultparam, int numparam, VMReturn *ret, int numret)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
assert(numparam >= 1 && numparam <= 3);
FRandom *rng = reinterpret_cast<FRandom *>(param[0].a);
if (numparam == 1)
{
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
ACTION_RETURN_INT((*rng)());
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else if (numparam == 2)
{
int maskval = param[1].i;
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
ACTION_RETURN_INT(rng->Random2(maskval));
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else if (numparam == 3)
{
int min = param[1].i, max = param[2].i;
if (max < min)
{
swapvalues(max, min);
}
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
ACTION_RETURN_INT((*rng)(max - min + 1) + min);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
// Shouldn't happen
return 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
ExpEmit FxRandom::Emit(VMFunctionBuilder *build)
{
// Call DecoRandom to generate a random number.
VMFunction *callfunc;
- implemented the 'is' operator (i.e. class type check.)
2016-10-29 23:05:56 +00:00
PSymbol *sym = FindBuiltinFunction(NAME_BuiltinRandom, BuiltinRandom);
Normalize line endings
2016-03-01 15:47:10 +00:00
assert(sym->IsKindOf(RUNTIME_CLASS(PSymbolVMFunction)));
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
assert(((PSymbolVMFunction *)sym)->Function != nullptr);
Normalize line endings
2016-03-01 15:47:10 +00:00
callfunc = ((PSymbolVMFunction *)sym)->Function;
- added the ability to attach a constructor or destructor to an internally defined struct. There are a few which require explicit native construction or destruction that need to be exported to the VM, e.g. FCheckPosition. The VM cannot handle this directly, it needs two special functions to be attached to handle such elements.
2017-01-11 22:46:03 +00:00
if (build->FramePointer.Fixed) EmitTail = false; // do not tail call if the stack is in use
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
int opcode = (EmitTail ? OP_TAIL_K : OP_CALL_K);
Normalize line endings
2016-03-01 15:47:10 +00:00
build->Emit(OP_PARAM, 0, REGT_POINTER | REGT_KONST, build->GetConstantAddress(rng, ATAG_RNG));
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
if (min != nullptr && max != nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
EmitParameter(build, min, ScriptPosition);
EmitParameter(build, max, ScriptPosition);
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
build->Emit(opcode, build->GetConstantAddress(callfunc, ATAG_OBJECT), 3, 1);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
build->Emit(opcode, build->GetConstantAddress(callfunc, ATAG_OBJECT), 1, 1);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
if (EmitTail)
{
ExpEmit call;
call.Final = true;
return call;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
ExpEmit out(build, REGT_INT);
build->Emit(OP_RESULT, 0, REGT_INT, out.RegNum);
return out;
}
//==========================================================================
//
//
//
//==========================================================================
- the compile context now knows if it is invoked by ZScript or DECORATE, so that it can be more strict with ZScript if needed. - added a truncation warning to FxIntCast, which only occurs with ZScript, not with DECORATE. FxBoolCast is intentionally left out because it would defeat the reason for this cast type.
2016-10-15 19:35:31 +00:00
FxRandomPick::FxRandomPick(FRandom *r, TArray<FxExpression*> &expr, bool floaty, const FScriptPosition &pos, bool nowarn)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_RandomPick, pos)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
assert(expr.Size() > 0);
choices.Resize(expr.Size());
for (unsigned int index = 0; index < expr.Size(); index++)
{
if (floaty)
{
choices[index] = new FxFloatCast(expr[index]);
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
expr[index] = nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
- the compile context now knows if it is invoked by ZScript or DECORATE, so that it can be more strict with ZScript if needed. - added a truncation warning to FxIntCast, which only occurs with ZScript, not with DECORATE. FxBoolCast is intentionally left out because it would defeat the reason for this cast type.
2016-10-15 19:35:31 +00:00
choices[index] = new FxIntCast(expr[index], nowarn);
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
expr[index] = nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
rng = r;
if (floaty)
{
ValueType = TypeFloat64;
}
else
{
ValueType = TypeSInt32;
}
}
//==========================================================================
//
//
//
//==========================================================================
FxRandomPick::~FxRandomPick()
{
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxRandomPick::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
for (unsigned int index = 0; index < choices.Size(); index++)
{
RESOLVE(choices[index], ctx);
ABORT(choices[index]);
assert(choices[index]->ValueType == ValueType);
}
return this;
};
//==========================================================================
//
// FxPick :: Emit
//
// The expression:
// a = pick[rng](i_0, i_1, i_2, ..., i_n)
// [where i_x is a complete expression and not just a value]
// is syntactic sugar for:
//
// switch(random[rng](0, n)) {
// case 0: a = i_0;
// case 1: a = i_1;
// case 2: a = i_2;
// ...
// case n: a = i_n;
// }
//
//==========================================================================
ExpEmit FxRandomPick::Emit(VMFunctionBuilder *build)
{
unsigned i;
assert(choices.Size() > 0);
- implemented the 'is' operator (i.e. class type check.)
2016-10-29 23:05:56 +00:00
// Call BuiltinRandom to generate a random number.
Normalize line endings
2016-03-01 15:47:10 +00:00
VMFunction *callfunc;
- implemented the 'is' operator (i.e. class type check.)
2016-10-29 23:05:56 +00:00
PSymbol *sym = FindBuiltinFunction(NAME_BuiltinRandom, BuiltinRandom);
Normalize line endings
2016-03-01 15:47:10 +00:00
assert(sym->IsKindOf(RUNTIME_CLASS(PSymbolVMFunction)));
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
assert(((PSymbolVMFunction *)sym)->Function != nullptr);
Normalize line endings
2016-03-01 15:47:10 +00:00
callfunc = ((PSymbolVMFunction *)sym)->Function;
build->Emit(OP_PARAM, 0, REGT_POINTER | REGT_KONST, build->GetConstantAddress(rng, ATAG_RNG));
build->EmitParamInt(0);
build->EmitParamInt(choices.Size() - 1);
build->Emit(OP_CALL_K, build->GetConstantAddress(callfunc, ATAG_OBJECT), 3, 1);
ExpEmit resultreg(build, REGT_INT);
build->Emit(OP_RESULT, 0, REGT_INT, resultreg.RegNum);
build->Emit(OP_IJMP, resultreg.RegNum, 0);
// Free the result register now. The simple code generation algorithm should
// automatically pick it as the destination register for each case.
resultreg.Free(build);
// For floating point results, we need to get a new register, since we can't
// reuse the integer one used to store the random result.
if (ValueType->GetRegType() == REGT_FLOAT)
{
resultreg = ExpEmit(build, REGT_FLOAT);
resultreg.Free(build);
}
// Allocate space for the jump table.
size_t jumptable = build->Emit(OP_JMP, 0);
for (i = 1; i < choices.Size(); ++i)
{
build->Emit(OP_JMP, 0);
}
// Emit each case
TArray<size_t> finishes(choices.Size() - 1);
for (unsigned i = 0; i < choices.Size(); ++i)
{
build->BackpatchToHere(jumptable + i);
if (choices[i]->isConstant())
{
EmitLoad(build, resultreg, static_cast<FxConstant *>(choices[i])->GetValue());
}
else
{
ExpEmit casereg = choices[i]->Emit(build);
if (casereg.RegNum != resultreg.RegNum)
{ // The result of the case is in a different register from what
// was expected. Copy it to the one we wanted.
resultreg.Reuse(build); // This is really just for the assert in Reuse()
build->Emit(ValueType->GetRegType() == REGT_INT ? OP_MOVE : OP_MOVEF, resultreg.RegNum, casereg.RegNum, 0);
resultreg.Free(build);
}
// Free this register so the remaining cases can use it.
casereg.Free(build);
}
// All but the final case needs a jump to the end of the expression's code.
if (i + 1 < choices.Size())
{
size_t loc = build->Emit(OP_JMP, 0);
finishes.Push(loc);
}
}
// Backpatch each case (except the last, since it ends here) to jump to here.
for (i = 0; i < choices.Size() - 1; ++i)
{
build->BackpatchToHere(finishes[i]);
}
// The result register needs to be in-use when we return.
// It should have been freed earlier, so restore its in-use flag.
resultreg.Reuse(build);
- allow defining native fields through scripts. Internally this only requires exporting the address, but not the entire field. - added new VARF_Transient flag so that the decision whether to serialize a field does not depend solely on its native status. It may actually make a lot of sense to use the auto-serializer for native fields, too, as this would eliminate a lot of maintenance code. - defined (u)int8/16 as aliases to the byte and short types (Can't we not just get rid of this naming convention already...?) - exporting the fields of Actor revealed a few name clashes between them and some global types, so Actor.Sector was renamed to CurSector and Actor.Inventory was renamed to Actor.Inv.
2016-11-22 18:20:31 +00:00
choices.DeleteAndClear();
choices.ShrinkToFit();
Normalize line endings
2016-03-01 15:47:10 +00:00
return resultreg;
}
//==========================================================================
//
//
//
//==========================================================================
FxFRandom::FxFRandom(FRandom *r, FxExpression *mi, FxExpression *ma, const FScriptPosition &pos)
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
: FxRandom(r, nullptr, nullptr, pos, true)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
if (mi != nullptr && ma != nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
min = new FxFloatCast(mi);
max = new FxFloatCast(ma);
}
ValueType = TypeFloat64;
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
ExprType = EFX_FRandom;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
//
//
//==========================================================================
- allow the VM to run on one global stack per thread. It is utterly pointless to require every function that wants to make a VM call to allocate a new stack first. The allocation overhead doubles the time to set up the call. With one stack, previously allocated memory can be reused. The only important thing is, if this ever gets used in a multithreaded environment to have the stack being declared as thread_local, although for ZDoom this is of no consequence. - eliminated all cases where native code was calling other native code through the VM interface. After scriptifying the game code, only 5 places were left which were quickly eliminated. This was mostly to ensure that the native VM function parameters do not need to be propagated further than absolutely necessary.
2016-11-30 16:15:01 +00:00
int BuiltinFRandom(VMValue *param, TArray<VMValue> &defaultparam, int numparam, VMReturn *ret, int numret)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
assert(numparam == 1 || numparam == 3);
FRandom *rng = reinterpret_cast<FRandom *>(param[0].a);
int random = (*rng)(0x40000000);
double frandom = random / double(0x40000000);
if (numparam == 3)
{
double min = param[1].f, max = param[2].f;
if (max < min)
{
swapvalues(max, min);
}
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
ACTION_RETURN_FLOAT(frandom * (max - min) + min);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
ACTION_RETURN_FLOAT(frandom);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
ExpEmit FxFRandom::Emit(VMFunctionBuilder *build)
{
- implemented the 'is' operator (i.e. class type check.)
2016-10-29 23:05:56 +00:00
// Call the BuiltinFRandom function to generate a floating point random number..
Normalize line endings
2016-03-01 15:47:10 +00:00
VMFunction *callfunc;
- implemented the 'is' operator (i.e. class type check.)
2016-10-29 23:05:56 +00:00
PSymbol *sym = FindBuiltinFunction(NAME_BuiltinFRandom, BuiltinFRandom);
Normalize line endings
2016-03-01 15:47:10 +00:00
assert(sym->IsKindOf(RUNTIME_CLASS(PSymbolVMFunction)));
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
assert(((PSymbolVMFunction *)sym)->Function != nullptr);
Normalize line endings
2016-03-01 15:47:10 +00:00
callfunc = ((PSymbolVMFunction *)sym)->Function;
- added the ability to attach a constructor or destructor to an internally defined struct. There are a few which require explicit native construction or destruction that need to be exported to the VM, e.g. FCheckPosition. The VM cannot handle this directly, it needs two special functions to be attached to handle such elements.
2017-01-11 22:46:03 +00:00
if (build->FramePointer.Fixed) EmitTail = false; // do not tail call if the stack is in use
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
int opcode = (EmitTail ? OP_TAIL_K : OP_CALL_K);
Normalize line endings
2016-03-01 15:47:10 +00:00
build->Emit(OP_PARAM, 0, REGT_POINTER | REGT_KONST, build->GetConstantAddress(rng, ATAG_RNG));
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
if (min != nullptr && max != nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
EmitParameter(build, min, ScriptPosition);
EmitParameter(build, max, ScriptPosition);
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
build->Emit(opcode, build->GetConstantAddress(callfunc, ATAG_OBJECT), 3, 1);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
build->Emit(opcode, build->GetConstantAddress(callfunc, ATAG_OBJECT), 1, 1);
}
if (EmitTail)
{
ExpEmit call;
call.Final = true;
return call;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
Normalize line endings
2016-03-01 15:47:10 +00:00
ExpEmit out(build, REGT_FLOAT);
build->Emit(OP_RESULT, 0, REGT_FLOAT, out.RegNum);
return out;
}
//==========================================================================
//
//
//
//==========================================================================
- the compile context now knows if it is invoked by ZScript or DECORATE, so that it can be more strict with ZScript if needed. - added a truncation warning to FxIntCast, which only occurs with ZScript, not with DECORATE. FxBoolCast is intentionally left out because it would defeat the reason for this cast type.
2016-10-15 19:35:31 +00:00
FxRandom2::FxRandom2(FRandom *r, FxExpression *m, const FScriptPosition &pos, bool nowarn)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_Random2, pos)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
EmitTail = false;
Normalize line endings
2016-03-01 15:47:10 +00:00
rng = r;
- the compile context now knows if it is invoked by ZScript or DECORATE, so that it can be more strict with ZScript if needed. - added a truncation warning to FxIntCast, which only occurs with ZScript, not with DECORATE. FxBoolCast is intentionally left out because it would defeat the reason for this cast type.
2016-10-15 19:35:31 +00:00
if (m) mask = new FxIntCast(m, nowarn);
Normalize line endings
2016-03-01 15:47:10 +00:00
else mask = new FxConstant(-1, pos);
ValueType = TypeSInt32;
}
//==========================================================================
//
//
//
//==========================================================================
FxRandom2::~FxRandom2()
{
SAFE_DELETE(mask);
}
//==========================================================================
//
//
//
//==========================================================================
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
PPrototype *FxRandom2::ReturnProto()
{
EmitTail = true;
return FxExpression::ReturnProto();
}
//==========================================================================
//
//
//
//==========================================================================
Normalize line endings
2016-03-01 15:47:10 +00:00
FxExpression *FxRandom2::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE(mask, ctx);
return this;
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxRandom2::Emit(VMFunctionBuilder *build)
{
- implemented the 'is' operator (i.e. class type check.)
2016-10-29 23:05:56 +00:00
// Call the BuiltinRandom function to generate the random number.
Normalize line endings
2016-03-01 15:47:10 +00:00
VMFunction *callfunc;
- implemented the 'is' operator (i.e. class type check.)
2016-10-29 23:05:56 +00:00
PSymbol *sym = FindBuiltinFunction(NAME_BuiltinRandom, BuiltinRandom);
Normalize line endings
2016-03-01 15:47:10 +00:00
assert(sym->IsKindOf(RUNTIME_CLASS(PSymbolVMFunction)));
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
assert(((PSymbolVMFunction *)sym)->Function != nullptr);
Normalize line endings
2016-03-01 15:47:10 +00:00
callfunc = ((PSymbolVMFunction *)sym)->Function;
- added the ability to attach a constructor or destructor to an internally defined struct. There are a few which require explicit native construction or destruction that need to be exported to the VM, e.g. FCheckPosition. The VM cannot handle this directly, it needs two special functions to be attached to handle such elements.
2017-01-11 22:46:03 +00:00
if (build->FramePointer.Fixed) EmitTail = false; // do not tail call if the stack is in use
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
int opcode = (EmitTail ? OP_TAIL_K : OP_CALL_K);
Normalize line endings
2016-03-01 15:47:10 +00:00
build->Emit(OP_PARAM, 0, REGT_POINTER | REGT_KONST, build->GetConstantAddress(rng, ATAG_RNG));
EmitParameter(build, mask, ScriptPosition);
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
build->Emit(opcode, build->GetConstantAddress(callfunc, ATAG_OBJECT), 2, 1);
if (EmitTail)
{
ExpEmit call;
call.Final = true;
return call;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
ExpEmit out(build, REGT_INT);
build->Emit(OP_RESULT, 0, REGT_INT, out.RegNum);
return out;
}
//==========================================================================
//
//
//
//==========================================================================
FxIdentifier::FxIdentifier(FName name, const FScriptPosition &pos)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_Identifier, pos)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
Identifier = name;
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxIdentifier::Resolve(FCompileContext& ctx)
{
PSymbol * sym;
- pass the current function to the compile context instead of just the containing class.
2016-10-15 15:40:27 +00:00
FxExpression *newex = nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
int num;
CHECKRESOLVED();
- pass the current function to the compile context instead of just the containing class.
2016-10-15 15:40:27 +00:00
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
// Local variables have highest priority.
FxLocalVariableDeclaration *local = ctx.FindLocalVariable(Identifier);
if (local != nullptr)
{
- added static constant arrays. At the moment they can only be defined inside functions due to lack of dedicated storage inside classes for static data. - added new VM instructions to access the constant tables with a variable index. - refactored VMFunctionBuilder's constant tables so that they are not limited to one entry per value. While this works fine for single values, it makes it impossible to store constant arrays in here.
2016-11-20 17:00:37 +00:00
if (local->ExprType == EFX_StaticArray)
{
auto x = new FxStaticArrayVariable(local, ScriptPosition);
delete this;
return x->Resolve(ctx);
}
else if (local->ValueType->GetRegType() != REGT_NIL)
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
{
auto x = new FxLocalVariable(local, ScriptPosition);
delete this;
return x->Resolve(ctx);
}
else
{
auto x = new FxStackVariable(local->ValueType, local->StackOffset, ScriptPosition);
delete this;
return x->Resolve(ctx);
}
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
}
- 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
if (Identifier == NAME_Default)
{
- no more simplify in state parameters. - resolving constants with the backend requires a few more error checks.
2017-01-22 22:53:50 +00:00
if (ctx.Function == nullptr)
{
ScriptPosition.Message(MSG_ERROR, "Unable to access class defaults from constant declaration");
delete this;
return nullptr;
}
- 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
if (ctx.Function->Variants[0].SelfClass == nullptr)
{
ScriptPosition.Message(MSG_ERROR, "Unable to access class defaults from static function");
delete this;
return nullptr;
}
- allow functions in structs. This is needed for several internal data types like players, sectors, lines, etc. - added a new type 'NativeStruct'. This will be used for types that cannot be instantiated, and is also needed to cleanly handle many internal types that only can exist as reference.
2016-11-19 11:12:29 +00:00
if (!ctx.Function->Variants[0].SelfClass->IsKindOf(RUNTIME_CLASS(PClassActor)))
- 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
{
ScriptPosition.Message(MSG_ERROR, "'Default' requires an actor type.");
delete this;
return nullptr;
}
FxExpression * x = new FxClassDefaults(new FxSelf(ScriptPosition), ScriptPosition);
delete this;
return x->Resolve(ctx);
}
- pass the current function to the compile context instead of just the containing class.
2016-10-15 15:40:27 +00:00
// Ugh, the horror. Constants need to be taken from the owning class, but members from the self class to catch invalid accesses here...
Normalize line endings
2016-03-01 15:47:10 +00:00
// see if the current class (if valid) defines something with this name.
- pass the current function to the compile context instead of just the containing class.
2016-10-15 15:40:27 +00:00
PSymbolTable *symtbl;
- fixed identifier resolution in FxIdentifier for action functions with a different invoker than self. - fixed creation of direct function invocations on a state line. In order to receive the implicit arguments this needs to be wrapped into a compound statement so that the local variable getter works.
2016-11-12 14:21:59 +00:00
// first check fields in self
if ((sym = ctx.FindInSelfClass(Identifier, symtbl)) != nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- fixed identifier resolution in FxIdentifier for action functions with a different invoker than self. - fixed creation of direct function invocations on a state line. In order to receive the implicit arguments this needs to be wrapped into a compound statement so that the local variable getter works.
2016-11-12 14:21:59 +00:00
if (sym->IsKindOf(RUNTIME_CLASS(PField)))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- no more simplify in state parameters. - resolving constants with the backend requires a few more error checks.
2017-01-22 22:53:50 +00:00
if (ctx.Function == nullptr)
{
ScriptPosition.Message(MSG_ERROR, "Unable to access class member %s from constant declaration", sym->SymbolName.GetChars());
delete this;
return nullptr;
}
Fixed: A StateProvider actor could no longer use its own user variables Refactored the FxIdentifier code a bit to avoid code duplication
2016-11-13 08:34:05 +00:00
FxExpression *self = new FxSelf(ScriptPosition);
self = self->Resolve(ctx);
newex = ResolveMember(ctx, ctx.Function->Variants[0].SelfClass, self, ctx.Function->Variants[0].SelfClass);
ABORT(newex);
- fixed: FxIdentifier::Resolve checked all cases of what an identifier can be, even if it already found a proper match.
2016-11-30 08:53:16 +00:00
goto foundit;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- fixed identifier resolution in FxIdentifier for action functions with a different invoker than self. - fixed creation of direct function invocations on a state line. In order to receive the implicit arguments this needs to be wrapped into a compound statement so that the local variable getter works.
2016-11-12 14:21:59 +00:00
}
Fixed: A StateProvider actor could no longer use its own user variables Refactored the FxIdentifier code a bit to avoid code duplication
2016-11-13 08:34:05 +00:00
// now check in the owning class.
- fixed identifier resolution in FxIdentifier for action functions with a different invoker than self. - fixed creation of direct function invocations on a state line. In order to receive the implicit arguments this needs to be wrapped into a compound statement so that the local variable getter works.
2016-11-12 14:21:59 +00:00
if (newex == nullptr && (sym = ctx.FindInClass(Identifier, symtbl)) != nullptr)
{
if (sym->IsKindOf(RUNTIME_CLASS(PSymbolConst)))
{
ScriptPosition.Message(MSG_DEBUGLOG, "Resolving name '%s' as class constant\n", Identifier.GetChars());
newex = FxConstant::MakeConstant(sym, ScriptPosition);
- fixed: FxIdentifier::Resolve checked all cases of what an identifier can be, even if it already found a proper match.
2016-11-30 08:53:16 +00:00
goto foundit;
- fixed identifier resolution in FxIdentifier for action functions with a different invoker than self. - fixed creation of direct function invocations on a state line. In order to receive the implicit arguments this needs to be wrapped into a compound statement so that the local variable getter works.
2016-11-12 14:21:59 +00:00
}
- no more simplify in state parameters. - resolving constants with the backend requires a few more error checks.
2017-01-22 22:53:50 +00:00
else if (ctx.Function == nullptr)
{
ScriptPosition.Message(MSG_ERROR, "Unable to access class member %s from constant declaration", sym->SymbolName.GetChars());
delete this;
return nullptr;
}
- added compile time checks for bad state links and state label references. - preserve a state's source line information for the postprocessing phase so that the checker can output more useful information. - added missing check for weapon psprites to DPSprite::SetState.
2016-11-15 10:21:08 +00:00
// Do this check for ZScript as well, so that a clearer error message can be printed. MSG_OPTERROR will default to MSG_ERROR there.
else if (ctx.Function->Variants[0].SelfClass != ctx.Class && sym->IsKindOf(RUNTIME_CLASS(PField)))
Fixed: A StateProvider actor could no longer use its own user variables Refactored the FxIdentifier code a bit to avoid code duplication
2016-11-13 08:34:05 +00:00
{
FxExpression *self = new FxSelf(ScriptPosition, true);
self = self->Resolve(ctx);
newex = ResolveMember(ctx, ctx.Class, self, ctx.Class);
ABORT(newex);
- added compile time checks for bad state links and state label references. - preserve a state's source line information for the postprocessing phase so that the checker can output more useful information. - added missing check for weapon psprites to DPSprite::SetState.
2016-11-15 10:21:08 +00:00
ScriptPosition.Message(MSG_OPTERROR, "Self pointer used in ambiguous context; VM execution may abort!");
removed some unneeded checks - since we now look for fields in the base class first the restriction check is no longer needed as it was for a different mode of looking up the identifier. - In DECORATE we do not need to bother with non-action functions. Non-action functions cannot be defined from DECORATE so there's no need to check if we are in one. - make the warning for unsafe access a debug message because this can affect legitimate code.
2016-11-13 11:37:28 +00:00
ctx.Unsafe = true;
- fixed: FxIdentifier::Resolve checked all cases of what an identifier can be, even if it already found a proper match.
2016-11-30 08:53:16 +00:00
goto foundit;
Fixed: A StateProvider actor could no longer use its own user variables Refactored the FxIdentifier code a bit to avoid code duplication
2016-11-13 08:34:05 +00:00
}
Normalize line endings
2016-03-01 15:47:10 +00:00
else
{
Print a clearer error message if a function name is encountered without parentheses.
2016-11-05 00:24:52 +00:00
if (sym->IsKindOf(RUNTIME_CLASS(PFunction)))
{
ScriptPosition.Message(MSG_ERROR, "Function '%s' used without ().\n", Identifier.GetChars());
}
else
{
ScriptPosition.Message(MSG_ERROR, "Invalid member identifier '%s'.\n", Identifier.GetChars());
}
- implemented class member access for variables. (Struct members and functions not done yet.)
2016-10-21 15:41:39 +00:00
delete this;
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
- pass the current function to the compile context instead of just the containing class.
2016-10-15 15:40:27 +00:00
- scriptified A_Saw. - implemented multiple-return-value assignment. Due to some grammar conflicts the originally intended Lua-inspired syntax of 'a, b = Function()' could not be done, so it's '[a, b] = Function()'
2016-11-19 23:25:38 +00:00
if (noglobal)
{
// This is needed to properly resolve class names on the left side of the member access operator
ValueType = TypeError;
return this;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
// now check the global identifiers.
- fixed identifier resolution in FxIdentifier for action functions with a different invoker than self. - fixed creation of direct function invocations on a state line. In order to receive the implicit arguments this needs to be wrapped into a compound statement so that the local variable getter works.
2016-11-12 14:21:59 +00:00
if (newex == nullptr && (sym = ctx.FindGlobal(Identifier)) != nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
if (sym->IsKindOf(RUNTIME_CLASS(PSymbolConst)))
{
ScriptPosition.Message(MSG_DEBUGLOG, "Resolving name '%s' as global constant\n", Identifier.GetChars());
newex = FxConstant::MakeConstant(sym, ScriptPosition);
- fixed: FxIdentifier::Resolve checked all cases of what an identifier can be, even if it already found a proper match.
2016-11-30 08:53:16 +00:00
goto foundit;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- 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
else if (sym->IsKindOf(RUNTIME_CLASS(PField)))
{
// internally defined global variable
ScriptPosition.Message(MSG_DEBUGLOG, "Resolving name '%s' as global variable\n", Identifier.GetChars());
newex = new FxGlobalVariable(static_cast<PField *>(sym), ScriptPosition);
- fixed: FxIdentifier::Resolve checked all cases of what an identifier can be, even if it already found a proper match.
2016-11-30 08:53:16 +00:00
goto foundit;
- 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
}
Normalize line endings
2016-03-01 15:47:10 +00:00
else
{
ScriptPosition.Message(MSG_ERROR, "Invalid global identifier '%s'\n", Identifier.GetChars());
- fixed: FxIdentifier::Resolve checked all cases of what an identifier can be, even if it already found a proper match.
2016-11-30 08:53:16 +00:00
delete this;
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
// and line specials
- fixed identifier resolution in FxIdentifier for action functions with a different invoker than self. - fixed creation of direct function invocations on a state line. In order to receive the implicit arguments this needs to be wrapped into a compound statement so that the local variable getter works.
2016-11-12 14:21:59 +00:00
if (newex == nullptr && (num = P_FindLineSpecial(Identifier, nullptr, nullptr)))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
ScriptPosition.Message(MSG_DEBUGLOG, "Resolving name '%s' as line special %d\n", Identifier.GetChars(), num);
newex = new FxConstant(num, ScriptPosition);
- fixed: FxIdentifier::Resolve checked all cases of what an identifier can be, even if it already found a proper match.
2016-11-30 08:53:16 +00:00
goto foundit;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- implemented direct CVar access.
2016-11-20 19:24:39 +00:00
- Fixed GCC compilation error. It didn't like 'cvar' being declared between 'goto foundit' and the 'foundit' label.
2016-11-30 15:51:20 +00:00
if (auto *cvar = FindCVar(Identifier.GetChars(), nullptr))
- implemented direct CVar access.
2016-11-20 19:24:39 +00:00
{
if (cvar->GetFlags() & CVAR_USERINFO)
{
ScriptPosition.Message(MSG_ERROR, "Cannot access userinfo CVARs directly. Use GetCVar() instead.");
delete this;
return nullptr;
}
newex = new FxCVar(cvar, ScriptPosition);
- fixed: FxIdentifier::Resolve checked all cases of what an identifier can be, even if it already found a proper match.
2016-11-30 08:53:16 +00:00
goto foundit;
- implemented direct CVar access.
2016-11-20 19:24:39 +00:00
}
- fixed identifier resolution in FxIdentifier for action functions with a different invoker than self. - fixed creation of direct function invocations on a state line. In order to receive the implicit arguments this needs to be wrapped into a compound statement so that the local variable getter works.
2016-11-12 14:21:59 +00:00
- fixed: FxIdentifier::Resolve checked all cases of what an identifier can be, even if it already found a proper match.
2016-11-30 08:53:16 +00:00
ScriptPosition.Message(MSG_ERROR, "Unknown identifier '%s'", Identifier.GetChars());
delete this;
return nullptr;
foundit:
- implemented class member access for variables. (Struct members and functions not done yet.)
2016-10-21 15:41:39 +00:00
delete this;
return newex? newex->Resolve(ctx) : nullptr;
}
Fixed: A StateProvider actor could no longer use its own user variables Refactored the FxIdentifier code a bit to avoid code duplication
2016-11-13 08:34:05 +00:00
//==========================================================================
//
//
//
//==========================================================================
- allow functions in structs. This is needed for several internal data types like players, sectors, lines, etc. - added a new type 'NativeStruct'. This will be used for types that cannot be instantiated, and is also needed to cleanly handle many internal types that only can exist as reference.
2016-11-19 11:12:29 +00:00
FxExpression *FxIdentifier::ResolveMember(FCompileContext &ctx, PStruct *classctx, FxExpression *&object, PStruct *objtype)
Fixed: A StateProvider actor could no longer use its own user variables Refactored the FxIdentifier code a bit to avoid code duplication
2016-11-13 08:34:05 +00:00
{
PSymbol *sym;
PSymbolTable *symtbl;
bool isclass = objtype->IsKindOf(RUNTIME_CLASS(PClass));
- scriptified D'Sparil. - added retrieval of defaults from an actor pointer.
2016-11-24 00:23:35 +00:00
if (Identifier == NAME_Default)
{
if (!objtype->IsKindOf(RUNTIME_CLASS(PClassActor)))
{
ScriptPosition.Message(MSG_ERROR, "'Default' requires an actor type.");
delete this;
return nullptr;
}
FxExpression * x = new FxClassDefaults(object, ScriptPosition);
object = nullptr;
delete this;
return x->Resolve(ctx);
}
- no more Simplify for global constants as well.
2017-01-23 00:10:40 +00:00
if (objtype != nullptr && (sym = objtype->Symbols.FindSymbolInTable(Identifier, symtbl)) != nullptr)
Fixed: A StateProvider actor could no longer use its own user variables Refactored the FxIdentifier code a bit to avoid code duplication
2016-11-13 08:34:05 +00:00
{
if (sym->IsKindOf(RUNTIME_CLASS(PSymbolConst)))
{
ScriptPosition.Message(MSG_DEBUGLOG, "Resolving name '%s' as %s constant\n", Identifier.GetChars(), isclass ? "class" : "struct");
delete object;
object = nullptr;
return FxConstant::MakeConstant(sym, ScriptPosition);
}
else if (sym->IsKindOf(RUNTIME_CLASS(PField)))
{
PField *vsym = static_cast<PField*>(sym);
// We have 4 cases to consider here:
// 1. The symbol is a static/meta member (not implemented yet) which is always accessible.
// 2. This is a static function
// 3. This is an action function with a restricted self pointer
// 4. This is a normal member or unrestricted action function.
if (vsym->Flags & VARF_Deprecated && !ctx.FromDecorate)
{
ScriptPosition.Message(MSG_WARNING, "Accessing deprecated member variable %s", vsym->SymbolName.GetChars());
}
if ((vsym->Flags & VARF_Private) && symtbl != &classctx->Symbols)
{
ScriptPosition.Message(MSG_ERROR, "Private member %s not accessible", vsym->SymbolName.GetChars());
return nullptr;
}
auto x = isclass ? new FxClassMember(object, vsym, ScriptPosition) : new FxStructMember(object, vsym, ScriptPosition);
object = nullptr;
return x->Resolve(ctx);
}
else
{
if (sym->IsKindOf(RUNTIME_CLASS(PFunction)))
{
ScriptPosition.Message(MSG_ERROR, "Function '%s' used without ().\n", Identifier.GetChars());
}
else
{
ScriptPosition.Message(MSG_ERROR, "Invalid member identifier '%s'.\n", Identifier.GetChars());
}
delete object;
object = nullptr;
return nullptr;
}
}
else
{
ScriptPosition.Message(MSG_ERROR, "Unknown identifier '%s'", Identifier.GetChars());
delete object;
object = nullptr;
return nullptr;
}
}
- implemented class member access for variables. (Struct members and functions not done yet.)
2016-10-21 15:41:39 +00:00
//==========================================================================
//
//
//
//==========================================================================
FxMemberIdentifier::FxMemberIdentifier(FxExpression *left, FName name, const FScriptPosition &pos)
: FxIdentifier(name, pos)
{
Object = left;
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
ExprType = EFX_MemberIdentifier;
- implemented class member access for variables. (Struct members and functions not done yet.)
2016-10-21 15:41:39 +00:00
}
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
FxMemberIdentifier::~FxMemberIdentifier()
{
SAFE_DELETE(Object);
}
- implemented class member access for variables. (Struct members and functions not done yet.)
2016-10-21 15:41:39 +00:00
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxMemberIdentifier::Resolve(FCompileContext& ctx)
{
- scriptified the Minotaur. Interesting tidbit: The damage calculation in P_MinotaurSlam had been incorrect for the Heretic version since the friendly Hexen Dark Servant was added, but nobody ever noticed in 14 years...
2016-11-26 00:14:47 +00:00
PStruct *ccls = nullptr;
- implemented class member access for variables. (Struct members and functions not done yet.)
2016-10-21 15:41:39 +00:00
CHECKRESOLVED();
- scriptified the Minotaur. Interesting tidbit: The damage calculation in P_MinotaurSlam had been incorrect for the Heretic version since the friendly Hexen Dark Servant was added, but nobody ever noticed in 14 years...
2016-11-26 00:14:47 +00:00
if (Object->ExprType == EFX_Identifier)
{
// If the left side is a class name for a static member function call it needs to be resolved manually
// because the resulting value type would cause problems in nearly every other place where identifiers are being used.
- fixed: Class and struct name lookup was not context aware. If a later module reused an existing name for a different class or struct type, this new name would completely shadow the old one, even in the base files. Changed it so that each compilation unit (i.e. each ZScript and DECORATE lump) get their own symbol table and can only see the symbol tables that got defined in lower numbered resource files so that later definitions do not pollute the available list of symbols when running the compiler backend and code generator - which happens after everything has been parsed. Another effect of this is that a mod that reuses the name of an internal global constant will only see its own constant, again reducing the risk of potential errors in case the internal definitions add some new values. Global constants are still discouraged from being used because what this does not and can not handle is the case that a mod defines a global constant with the same name as a class variable. In such a case the class variable will always take precedence for code inside that class. Note that the internal struct String had to be renamed for this because the stricter checks did not let the type String pass on the left side of a '.' anymore. - made PEnum inherit from PInt and not from PNamedType. The old inheritance broke nearly every check for integer compatibility in the compiler, so this hopefully leads to a working enum implementation.
2017-01-23 18:09:36 +00:00
ccls = FindStructType(static_cast<FxIdentifier *>(Object)->Identifier, ctx);
- scriptified the Minotaur. Interesting tidbit: The damage calculation in P_MinotaurSlam had been incorrect for the Heretic version since the friendly Hexen Dark Servant was added, but nobody ever noticed in 14 years...
2016-11-26 00:14:47 +00:00
if (ccls != nullptr) static_cast<FxIdentifier *>(Object)->noglobal = true;
}
- implemented class member access for variables. (Struct members and functions not done yet.)
2016-10-21 15:41:39 +00:00
SAFE_RESOLVE(Object, ctx);
- split up zscript/shared/inventory.txt. - moved health items to their own file. - scriptified ScoreItem and MapRevealer whose entire functionality was a small TryPickup method. - fixed: bit fields in global variables were not correctly written. This should conclude the inventory cleanup. It is now possible again to find things in there.
2016-11-30 12:36:13 +00:00
if (Identifier == FName("allmap"))
{
int a = 2;
}
- scriptified the Minotaur. Interesting tidbit: The damage calculation in P_MinotaurSlam had been incorrect for the Heretic version since the friendly Hexen Dark Servant was added, but nobody ever noticed in 14 years...
2016-11-26 00:14:47 +00:00
// check for class or struct constants if the left side is a type name.
if (Object->ValueType == TypeError)
{
if (ccls != nullptr)
{
if (!ccls->IsKindOf(RUNTIME_CLASS(PClass)) || static_cast<PClass *>(ccls)->bExported)
{
PSymbol *sym;
if ((sym = ccls->Symbols.FindSymbol(Identifier, true)) != nullptr)
{
if (sym->IsKindOf(RUNTIME_CLASS(PSymbolConst)))
{
ScriptPosition.Message(MSG_DEBUGLOG, "Resolving name '%s.%s' as constant\n", ccls->TypeName.GetChars(), Identifier.GetChars());
delete this;
return FxConstant::MakeConstant(sym, ScriptPosition);
}
else
{
ScriptPosition.Message(MSG_ERROR, "Unable to access '%s.%s' in a static context\n", ccls->TypeName.GetChars(), Identifier.GetChars());
delete this;
return nullptr;
}
}
}
}
}
// allow accessing the color channels by mapping the type to a matching struct which defines them.
if (Object->ValueType == TypeColor)
- scriptified Strife's coins. - added a String class to allow attaching methods to the builtin string type. This works by checking if the left side of the member accessor is a string and just replacing the tyoe in this one place, all the rest is automatic.
2016-11-28 17:15:18 +00:00
{
- added per-channel access for color variables. However, since they are locally stored in registers, it required a minor bit of fudging for this case. - make sure that a PFunction's implementation is always initialized before starting the code generator.
2016-11-21 11:38:39 +00:00
Object->ValueType = TypeColorStruct;
- scriptified Strife's coins. - added a String class to allow attaching methods to the builtin string type. This works by checking if the left side of the member accessor is a string and just replacing the tyoe in this one place, all the rest is automatic.
2016-11-28 17:15:18 +00:00
}
- scriptified PowerStrength. This revealed an interesting bug: When the berserk fadout formula was changed in 2005 the result was essentially broken, resulting in values around 7000 - it only worked by happenstance because the lower 8 bits of the resulting values just happened to work to some degree and never overflowed. But the resulting fade was far too weak and a slightly different handling of the color composition code for the VM made it break down entirely. This restores the pre-2005 formula but weakened intensity which now comes a lot closer to how it is supposed to look.
2017-01-16 21:27:49 +00:00
if (Object->ValueType->IsKindOf(RUNTIME_CLASS(PPointer)))
- implemented class member access for variables. (Struct members and functions not done yet.)
2016-10-21 15:41:39 +00:00
{
- added null pointer. - fixed: FxMemberIdentifier checked for ClassPointers instead of object pointers to resolve the left hand side of the expression. - allow comparison of pointers.
2016-10-21 22:50:04 +00:00
auto ptype = static_cast<PPointer *>(Object->ValueType)->PointedType;
Fixed: A StateProvider actor could no longer use its own user variables Refactored the FxIdentifier code a bit to avoid code duplication
2016-11-13 08:34:05 +00:00
if (ptype->IsKindOf(RUNTIME_CLASS(PStruct)))
- implemented class member access for variables. (Struct members and functions not done yet.)
2016-10-21 15:41:39 +00:00
{
Fixed: A StateProvider actor could no longer use its own user variables Refactored the FxIdentifier code a bit to avoid code duplication
2016-11-13 08:34:05 +00:00
auto ret = ResolveMember(ctx, ctx.Class, Object, static_cast<PStruct *>(ptype));
delete this;
return ret;
- implemented class member access for variables. (Struct members and functions not done yet.)
2016-10-21 15:41:39 +00:00
}
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- implemented State as an actual native struct, so that its fields can be accessed from scripts. - refactored state bitfield members into a flag word because the address of a bitfield cannot be taken, making such variables inaccessible to scripts. - actually use PNativeStruct for representing native structs defined in a script.
2016-11-21 20:34:34 +00:00
else if (Object->ValueType->IsKindOf(RUNTIME_CLASS(PStruct)))
- implemented class member access for variables. (Struct members and functions not done yet.)
2016-10-21 15:41:39 +00:00
{
Fixed: A StateProvider actor could no longer use its own user variables Refactored the FxIdentifier code a bit to avoid code duplication
2016-11-13 08:34:05 +00:00
auto ret = ResolveMember(ctx, ctx.Class, Object, static_cast<PStruct *>(Object->ValueType));
delete this;
return ret;
- implemented class member access for variables. (Struct members and functions not done yet.)
2016-10-21 15:41:39 +00:00
}
ScriptPosition.Message(MSG_ERROR, "Left side of %s is not a struct or class", Identifier.GetChars());
Normalize line endings
2016-03-01 15:47:10 +00:00
delete this;
- implemented class member access for variables. (Struct members and functions not done yet.)
2016-10-21 15:41:39 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
//==========================================================================
//
//
//
//==========================================================================
FxLocalVariable::FxLocalVariable(FxLocalVariableDeclaration *var, const FScriptPosition &sc)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_LocalVariable, sc)
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
{
Variable = var;
- tested and fixed the regular assignment statement for both local and member variables. The generated object code can definitely use an optimization pass but that's something left for later when more things are working. Right now it creates one opcode more than necessary for all member accesses (instead of using the offset in the store command it calculates an actual address of the variable in another address register) and can create one too many for non-constant expressions being assigned to local variables (a move between two registers because the emitted expression on the right hand side does not know that it can emit to the actual variable's register.)
2016-10-21 08:09:01 +00:00
ValueType = var->ValueType;
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
AddressRequested = false;
- implemented vector operations. Vectors are now fully working as local variables. - removed mulv_kr and divv_kr instructions. The first are redundant and the second are useless. Maybe remove all other vector/const operations as well? They won't get used by the code generator. - fixed disassembly of vector multiplication and division instructions.
2016-10-28 23:39:25 +00:00
RegOffset = 0;
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
}
FxExpression *FxLocalVariable::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
return this;
}
- added a new variable flag that allows defining variables which can only be modified by internal script code but not by external mods. Currently this is used by the NoBlockmap and NoSector flags which need special handling for changing.
2016-11-08 10:12:56 +00:00
bool FxLocalVariable::RequestAddress(FCompileContext &ctx, bool *writable)
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
{
AddressRequested = true;
- added a new variable flag that allows defining variables which can only be modified by internal script code but not by external mods. Currently this is used by the NoBlockmap and NoSector flags which need special handling for changing.
2016-11-08 10:12:56 +00:00
if (writable != nullptr) *writable = !ctx.CheckReadOnly(Variable->VarFlags);
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
return true;
}
ExpEmit FxLocalVariable::Emit(VMFunctionBuilder *build)
{
- scriptified a_strifeitems.cpp and a_debris.cpp. - Changed the glass shards so that they do not have to override FloorBounceMissile. It was the only place where this was virtually overridden and provided little usefulness. - made 'out' variables work. - fixed virtual call handling for HandlePickup.
2016-11-29 11:17:05 +00:00
// 'Out' variables are actually pointers but this fact must be hidden to the script.
if (Variable->VarFlags & VARF_Out)
{
if (!AddressRequested)
{
ExpEmit reg(build, ValueType->GetRegType(), ValueType->GetRegCount());
build->Emit(ValueType->GetLoadOp(), reg.RegNum, Variable->RegNum, build->GetConstantInt(RegOffset));
return reg;
}
else
{
if (RegOffset == 0) return ExpEmit(Variable->RegNum, REGT_POINTER, false, true);
ExpEmit reg(build, REGT_POINTER);
build->Emit(OP_ADDA_RK, reg.RegNum, Variable->RegNum, build->GetConstantInt(RegOffset));
return reg;
}
}
else
{
ExpEmit ret(Variable->RegNum + RegOffset, Variable->ValueType->GetRegType(), false, true);
ret.RegCount = ValueType->GetRegCount();
if (AddressRequested) ret.Target = true;
return ret;
}
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
}
- added static constant arrays. At the moment they can only be defined inside functions due to lack of dedicated storage inside classes for static data. - added new VM instructions to access the constant tables with a variable index. - refactored VMFunctionBuilder's constant tables so that they are not limited to one entry per value. While this works fine for single values, it makes it impossible to store constant arrays in here.
2016-11-20 17:00:37 +00:00
//==========================================================================
//
//
//
//==========================================================================
FxStaticArrayVariable::FxStaticArrayVariable(FxLocalVariableDeclaration *var, const FScriptPosition &sc)
: FxExpression(EFX_StaticArrayVariable, sc)
{
Variable = static_cast<FxStaticArray*>(var);
ValueType = Variable->ValueType;
}
FxExpression *FxStaticArrayVariable::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
return this;
}
bool FxStaticArrayVariable::RequestAddress(FCompileContext &ctx, bool *writable)
{
AddressRequested = true;
if (writable != nullptr) *writable = false;
return true;
}
ExpEmit FxStaticArrayVariable::Emit(VMFunctionBuilder *build)
{
// returns the first const register for this array
return ExpEmit(Variable->StackOffset, Variable->ElementType->GetRegType(), true, false);
}
- fixed initialization of local variables with other local variables. - fixed several occurenced where vectors were treated as floats. NOTE: The entire codegen.cpp file needs to be carefully reviewed for bad use of the REGT_ constants, there's probably more places where using them has broken some type checks. - fixed: committed test version of zscript.txt instead of changed actor.txt by accident. Initialization and assignment for strings is working with this commit.
2016-10-29 14:49:21 +00:00
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
//
//
//==========================================================================
Fixed: A StateProvider actor could no longer use its own user variables Refactored the FxIdentifier code a bit to avoid code duplication
2016-11-13 08:34:05 +00:00
FxSelf::FxSelf(const FScriptPosition &pos, bool deccheck)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_Self, pos)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
Fixed: A StateProvider actor could no longer use its own user variables Refactored the FxIdentifier code a bit to avoid code duplication
2016-11-13 08:34:05 +00:00
check = deccheck;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxSelf::Resolve(FCompileContext& ctx)
{
CHECKRESOLVED();
- pass the current function to the compile context instead of just the containing class.
2016-10-15 15:40:27 +00:00
if (ctx.Function == nullptr || ctx.Function->Variants[0].SelfClass == nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
ScriptPosition.Message(MSG_ERROR, "self used outside of a member function");
delete this;
- pass the current function to the compile context instead of just the containing class.
2016-10-15 15:40:27 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- pass the current function to the compile context instead of just the containing class.
2016-10-15 15:40:27 +00:00
ValueType = NewPointer(ctx.Function->Variants[0].SelfClass);
Normalize line endings
2016-03-01 15:47:10 +00:00
return this;
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxSelf::Emit(VMFunctionBuilder *build)
{
Fixed: A StateProvider actor could no longer use its own user variables Refactored the FxIdentifier code a bit to avoid code duplication
2016-11-13 08:34:05 +00:00
if (check)
{
build->Emit(OP_EQA_R, 1, 0, 1);
build->Emit(OP_JMP, 1);
build->Emit(OP_THROW, 2, X_BAD_SELF);
}
Normalize line endings
2016-03-01 15:47:10 +00:00
// self is always the first pointer passed to the function
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
return ExpEmit(0, REGT_POINTER, false, true);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- implemented super calls and proper dispatch of scripted virtual overrides for Destroy.
2016-11-11 20:52:08 +00:00
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxSuper::Resolve(FCompileContext& ctx)
{
CHECKRESOLVED();
if (ctx.Function == nullptr || ctx.Function->Variants[0].SelfClass == nullptr)
{
ScriptPosition.Message(MSG_ERROR, "super used outside of a member function");
delete this;
return nullptr;
}
ValueType = TypeError; // this intentionally resolves to an invalid type so that it cannot be used outside of super calls.
return this;
}
- 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
//==========================================================================
//
//
//
//==========================================================================
FxClassDefaults::FxClassDefaults(FxExpression *X, const FScriptPosition &pos)
: FxExpression(EFX_ClassDefaults, pos)
{
obj = X;
EmitTail = false;
}
FxClassDefaults::~FxClassDefaults()
{
SAFE_DELETE(obj);
}
//==========================================================================
//
//
//
//==========================================================================
PPrototype *FxClassDefaults::ReturnProto()
{
EmitTail = true;
return FxExpression::ReturnProto();
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxClassDefaults::Resolve(FCompileContext& ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE(obj, ctx);
assert(obj->ValueType->IsKindOf(RUNTIME_CLASS(PPointer)));
ValueType = NewPointer(static_cast<PPointer*>(obj->ValueType)->PointedType, true);
return this;
}
//==========================================================================
//
//
//
//==========================================================================
ExpEmit FxClassDefaults::Emit(VMFunctionBuilder *build)
{
- scriptified Heretic's blaster. - scriptified all Effect functions of Fastprojectile's children - implemented access to class meta data. - added a VM instruction to retrieve the class metadata, to eliminate the overhead of the function call that would otherwise be needed. - made GetClass() a builtin so that it can use the new instruction Important note about this commit: Scriptifying CFlameMissile::Effect revealed a problem with the virtual function interface: In order to work, this needs to be explicitly enabled for each single native class that may be used as a base for a scripted class. Needless to say, this will end up way too much work, as there are over 100 native classes, excluding those which will be scriptified. But in order to fix the problem this partially broken state needs to be committed first.
2016-11-24 19:02:44 +00:00
ExpEmit ob = obj->Emit(build);
ob.Free(build);
ExpEmit meta(build, REGT_POINTER);
build->Emit(OP_META, meta.RegNum, ob.RegNum);
build->Emit(OP_LO, meta.RegNum, meta.RegNum, build->GetConstantInt(myoffsetof(PClass, Defaults)));
return meta;
- 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
}
- 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
//==========================================================================
//
//
//
//==========================================================================
FxGlobalVariable::FxGlobalVariable(PField* mem, const FScriptPosition &pos)
: FxExpression(EFX_GlobalVariable, pos)
{
membervar = mem;
AddressRequested = false;
AddressWritable = true; // must be true unless classx tells us otherwise if requested.
}
//==========================================================================
//
//
//
//==========================================================================
- added a new variable flag that allows defining variables which can only be modified by internal script code but not by external mods. Currently this is used by the NoBlockmap and NoSector flags which need special handling for changing.
2016-11-08 10:12:56 +00:00
bool FxGlobalVariable::RequestAddress(FCompileContext &ctx, bool *writable)
- 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
{
AddressRequested = true;
- added a new variable flag that allows defining variables which can only be modified by internal script code but not by external mods. Currently this is used by the NoBlockmap and NoSector flags which need special handling for changing.
2016-11-08 10:12:56 +00:00
if (writable != nullptr) *writable = AddressWritable && !ctx.CheckReadOnly(membervar->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
return true;
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxGlobalVariable::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
ValueType = membervar->Type;
return this;
}
ExpEmit FxGlobalVariable::Emit(VMFunctionBuilder *build)
{
ExpEmit obj(build, REGT_POINTER);
build->Emit(OP_LKP, obj.RegNum, build->GetConstantAddress((void*)(intptr_t)membervar->Offset, ATAG_GENERIC));
if (AddressRequested)
{
return obj;
}
ExpEmit loc(build, membervar->Type->GetRegType(), membervar->Type->GetRegCount());
if (membervar->BitValue == -1)
{
int offsetreg = build->GetConstantInt(0);
build->Emit(membervar->Type->GetLoadOp(), loc.RegNum, obj.RegNum, offsetreg);
}
else
{
build->Emit(OP_LBIT, loc.RegNum, obj.RegNum, 1 << membervar->BitValue);
}
obj.Free(build);
return loc;
}
- implemented direct CVar access.
2016-11-20 19:24:39 +00:00
//==========================================================================
//
//
//
//==========================================================================
FxCVar::FxCVar(FBaseCVar *cvar, const FScriptPosition &pos)
: FxExpression(EFX_CVar, pos)
{
CVar = cvar;
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxCVar::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
switch (CVar->GetRealType())
{
case CVAR_Bool:
case CVAR_DummyBool:
ValueType = TypeBool;
break;
case CVAR_Int:
case CVAR_DummyInt:
ValueType = TypeSInt32;
break;
case CVAR_Color:
ValueType = TypeColor;
break;
case CVAR_Float:
ValueType = TypeFloat64;
break;
case CVAR_String:
ValueType = TypeString;
break;
default:
ScriptPosition.Message(MSG_ERROR, "Unknown CVar type for %s", CVar->GetName());
delete this;
return nullptr;
}
return this;
}
ExpEmit FxCVar::Emit(VMFunctionBuilder *build)
{
ExpEmit dest(build, ValueType->GetRegType());
ExpEmit addr(build, REGT_POINTER);
int nul = build->GetConstantInt(0);
switch (CVar->GetRealType())
{
case CVAR_Int:
build->Emit(OP_LKP, addr.RegNum, build->GetConstantAddress(&static_cast<FIntCVar *>(CVar)->Value, ATAG_GENERIC));
build->Emit(OP_LW, dest.RegNum, addr.RegNum, nul);
break;
case CVAR_Color:
build->Emit(OP_LKP, addr.RegNum, build->GetConstantAddress(&static_cast<FColorCVar *>(CVar)->Value, ATAG_GENERIC));
build->Emit(OP_LW, dest.RegNum, addr.RegNum, nul);
break;
case CVAR_Float:
build->Emit(OP_LKP, addr.RegNum, build->GetConstantAddress(&static_cast<FFloatCVar *>(CVar)->Value, ATAG_GENERIC));
build->Emit(OP_LSP, dest.RegNum, addr.RegNum, nul);
break;
case CVAR_Bool:
build->Emit(OP_LKP, addr.RegNum, build->GetConstantAddress(&static_cast<FBoolCVar *>(CVar)->Value, ATAG_GENERIC));
build->Emit(OP_LBU, dest.RegNum, addr.RegNum, nul);
break;
case CVAR_String:
build->Emit(OP_LKP, addr.RegNum, build->GetConstantAddress(&static_cast<FStringCVar *>(CVar)->Value, ATAG_GENERIC));
build->Emit(OP_LS, dest.RegNum, addr.RegNum, nul);
break;
case CVAR_DummyBool:
- implemented named arguments. - fixed flag CVAR access. As it turned out, OP_LBIT is a bit messy to set up properly when accessing integers that may or may not be big endian, so it now uses a shift and bit masking to do its work. - used the SpawnPlayerMissile call in A_FireBFG to test named arguments.
2016-11-21 00:32:01 +00:00
{
auto cv = static_cast<FFlagCVar *>(CVar);
build->Emit(OP_LKP, addr.RegNum, build->GetConstantAddress(&cv->ValueVar.Value, ATAG_GENERIC));
build->Emit(OP_LW, dest.RegNum, addr.RegNum, nul);
build->Emit(OP_SRL_RI, dest.RegNum, dest.RegNum, cv->BitNum);
build->Emit(OP_AND_RK, dest.RegNum, dest.RegNum, build->GetConstantInt(1));
- implemented direct CVar access.
2016-11-20 19:24:39 +00:00
break;
- implemented named arguments. - fixed flag CVAR access. As it turned out, OP_LBIT is a bit messy to set up properly when accessing integers that may or may not be big endian, so it now uses a shift and bit masking to do its work. - used the SpawnPlayerMissile call in A_FireBFG to test named arguments.
2016-11-21 00:32:01 +00:00
}
- implemented direct CVar access.
2016-11-20 19:24:39 +00:00
case CVAR_DummyInt:
{
auto cv = static_cast<FMaskCVar *>(CVar);
build->Emit(OP_LKP, addr.RegNum, build->GetConstantAddress(&cv->ValueVar.Value, ATAG_GENERIC));
build->Emit(OP_LW, dest.RegNum, addr.RegNum, nul);
build->Emit(OP_AND_RK, dest.RegNum, dest.RegNum, build->GetConstantInt(cv->BitVal));
build->Emit(OP_SRL_RI, dest.RegNum, dest.RegNum, cv->BitNum);
break;
}
default:
assert(false && "Unsupported CVar type");
break;
}
- fixed: FxCVar must free its address register.
2016-11-20 22:26:32 +00:00
addr.Free(build);
- implemented direct CVar access.
2016-11-20 19:24:39 +00:00
return dest;
}
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
//==========================================================================
//
//
//
//==========================================================================
FxStackVariable::FxStackVariable(PType *type, int offset, const FScriptPosition &pos)
: FxExpression(EFX_StackVariable, pos)
{
membervar = new PField(NAME_None, type, 0, offset);
AddressRequested = false;
AddressWritable = true; // must be true unless classx tells us otherwise if requested.
}
//==========================================================================
//
// force delete the PField because we know we won't need it anymore
// and it won't get GC'd until the compiler finishes.
//
//==========================================================================
FxStackVariable::~FxStackVariable()
{
// Q: Is this good or bad? Needs testing if this is fine or better left to the GC anyway. DObject's destructor is anything but cheap.
membervar->ObjectFlags |= OF_YesReallyDelete;
delete membervar;
}
//==========================================================================
//
//
//==========================================================================
void FxStackVariable::ReplaceField(PField *newfield)
{
membervar->ObjectFlags |= OF_YesReallyDelete;
delete membervar;
membervar = newfield;
}
//==========================================================================
//
//
//
//==========================================================================
bool FxStackVariable::RequestAddress(FCompileContext &ctx, bool *writable)
{
AddressRequested = true;
if (writable != nullptr) *writable = AddressWritable && !ctx.CheckReadOnly(membervar->Flags);
return true;
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxStackVariable::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
ValueType = membervar->Type;
return this;
}
ExpEmit FxStackVariable::Emit(VMFunctionBuilder *build)
{
int offsetreg = -1;
if (membervar->Offset != 0) offsetreg = build->GetConstantInt((int)membervar->Offset);
if (AddressRequested)
{
if (offsetreg >= 0)
{
- optimize access to array members with constant index. Like with struct members this can be combined with the outer index/address. - fixed register allocation with array indices and stack variables.
2016-11-17 17:06:56 +00:00
ExpEmit obj(build, REGT_POINTER);
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
build->Emit(OP_ADDA_RK, obj.RegNum, build->FramePointer.RegNum, offsetreg);
return obj;
}
- optimize access to array members with constant index. Like with struct members this can be combined with the outer index/address. - fixed register allocation with array indices and stack variables.
2016-11-17 17:06:56 +00:00
else
{
return build->FramePointer;
}
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
}
ExpEmit loc(build, membervar->Type->GetRegType(), membervar->Type->GetRegCount());
if (membervar->BitValue == -1)
{
if (offsetreg == -1) offsetreg = build->GetConstantInt(0);
- fixed: Stack based local VM object pointers should not be subjected to a read barrier. This isn't done for register based variables so for consistency it should not be done for stack based variables, too. This difference in handling made it impossible to check the target of a hitscan attack if it was destroyed by getting damaged.
2017-02-04 15:23:14 +00:00
auto op = membervar->Type->GetLoadOp();
if (op == OP_LO) op = OP_LOS;
build->Emit(op, loc.RegNum, build->FramePointer.RegNum, offsetreg);
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
}
else
{
ExpEmit obj(build, REGT_POINTER);
if (offsetreg >= 0) build->Emit(OP_ADDA_RK, obj.RegNum, build->FramePointer.RegNum, offsetreg);
obj.Free(build);
build->Emit(OP_LBIT, loc.RegNum, obj.RegNum, 1 << membervar->BitValue);
}
return loc;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
//
//
//==========================================================================
- added handling for structs. When defined inside classes or other structs the double member access will be merged, so there is no performance hit by using structs to group data.
2016-10-24 11:18:13 +00:00
FxStructMember::FxStructMember(FxExpression *x, PField* mem, const FScriptPosition &pos)
: FxExpression(EFX_StructMember, pos)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
classx = x;
membervar = mem;
AddressRequested = false;
- added handling for structs. When defined inside classes or other structs the double member access will be merged, so there is no performance hit by using structs to group data.
2016-10-24 11:18:13 +00:00
AddressWritable = true; // must be true unless classx tells us otherwise if requested.
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
//
//
//==========================================================================
- added handling for structs. When defined inside classes or other structs the double member access will be merged, so there is no performance hit by using structs to group data.
2016-10-24 11:18:13 +00:00
FxStructMember::~FxStructMember()
Normalize line endings
2016-03-01 15:47:10 +00:00
{
SAFE_DELETE(classx);
}
//==========================================================================
//
//
//
//==========================================================================
- added a new variable flag that allows defining variables which can only be modified by internal script code but not by external mods. Currently this is used by the NoBlockmap and NoSector flags which need special handling for changing.
2016-11-08 10:12:56 +00:00
bool FxStructMember::RequestAddress(FCompileContext &ctx, bool *writable)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- scriptified Heretic's blaster. - scriptified all Effect functions of Fastprojectile's children - implemented access to class meta data. - added a VM instruction to retrieve the class metadata, to eliminate the overhead of the function call that would otherwise be needed. - made GetClass() a builtin so that it can use the new instruction Important note about this commit: Scriptifying CFlameMissile::Effect revealed a problem with the virtual function interface: In order to work, this needs to be explicitly enabled for each single native class that may be used as a base for a scripted class. Needless to say, this will end up way too much work, as there are over 100 native classes, excluding those which will be scriptified. But in order to fix the problem this partially broken state needs to be committed first.
2016-11-24 19:02:44 +00:00
// Cannot take the address of metadata variables.
- added property definitions to the ZScript parser. This will allow defining custom properties for the default block in custom base classes. See 'Health' for an example. - support transient object member variables for information that does not need to be put in a savegame. - fixed: special initialization of objects needs to pass the proper defaults along, otherwise the parent classes will use their own, inappropriate one.
2017-01-15 15:55:30 +00:00
if (membervar->Flags & VARF_Meta)
- scriptified Heretic's blaster. - scriptified all Effect functions of Fastprojectile's children - implemented access to class meta data. - added a VM instruction to retrieve the class metadata, to eliminate the overhead of the function call that would otherwise be needed. - made GetClass() a builtin so that it can use the new instruction Important note about this commit: Scriptifying CFlameMissile::Effect revealed a problem with the virtual function interface: In order to work, this needs to be explicitly enabled for each single native class that may be used as a base for a scripted class. Needless to say, this will end up way too much work, as there are over 100 native classes, excluding those which will be scriptified. But in order to fix the problem this partially broken state needs to be committed first.
2016-11-24 19:02:44 +00:00
{
return false;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
AddressRequested = true;
- added a new variable flag that allows defining variables which can only be modified by internal script code but not by external mods. Currently this is used by the NoBlockmap and NoSector flags which need special handling for changing.
2016-11-08 10:12:56 +00:00
if (writable != nullptr) *writable = (AddressWritable && !ctx.CheckReadOnly(membervar->Flags) &&
- 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
(!classx->ValueType->IsKindOf(RUNTIME_CLASS(PPointer)) || !static_cast<PPointer*>(classx->ValueType)->IsConst));
- handle all unary operators. - handle all binary operators which are already implemented in the code generator. - implemented sizeof/alignof operators in code generator. - rewrote RequestAddress so that its return value is not the writability of an address but the mere existence. Also changed it to not output errors itself because those cannot be dealt with by the calling function.
2016-10-17 18:33:35 +00:00
return true;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
//
//
//==========================================================================
- added handling for structs. When defined inside classes or other structs the double member access will be merged, so there is no performance hit by using structs to group data.
2016-10-24 11:18:13 +00:00
FxExpression *FxStructMember::Resolve(FCompileContext &ctx)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
CHECKRESOLVED();
SAFE_RESOLVE(classx, ctx);
- 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
if (membervar->SymbolName == NAME_Default)
{
if (!classx->ValueType->IsKindOf(RUNTIME_CLASS(PPointer))
|| !static_cast<PPointer *>(classx->ValueType)->PointedType->IsKindOf(RUNTIME_CLASS(AActor)))
{
ScriptPosition.Message(MSG_ERROR, "'Default' requires an actor type.");
delete this;
return nullptr;
}
FxExpression * x = new FxClassDefaults(classx, ScriptPosition);
classx = nullptr;
delete this;
return x->Resolve(ctx);
}
- added handling for structs. When defined inside classes or other structs the double member access will be merged, so there is no performance hit by using structs to group data.
2016-10-24 11:18:13 +00:00
if (classx->ValueType->IsKindOf(RUNTIME_CLASS(PPointer)))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- added handling for structs. When defined inside classes or other structs the double member access will be merged, so there is no performance hit by using structs to group data.
2016-10-24 11:18:13 +00:00
PPointer *ptrtype = dyn_cast<PPointer>(classx->ValueType);
- 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
if (ptrtype == nullptr || !ptrtype->PointedType->IsKindOf(RUNTIME_CLASS(PStruct)))
- added handling for structs. When defined inside classes or other structs the double member access will be merged, so there is no performance hit by using structs to group data.
2016-10-24 11:18:13 +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
ScriptPosition.Message(MSG_ERROR, "Member variable requires a struct or class object.");
- added handling for structs. When defined inside classes or other structs the double member access will be merged, so there is no performance hit by using structs to group data.
2016-10-24 11:18:13 +00:00
delete this;
return nullptr;
}
}
- implemented State as an actual native struct, so that its fields can be accessed from scripts. - refactored state bitfield members into a flag word because the address of a bitfield cannot be taken, making such variables inaccessible to scripts. - actually use PNativeStruct for representing native structs defined in a script.
2016-11-21 20:34:34 +00:00
else if (classx->ValueType->IsKindOf(RUNTIME_CLASS(PStruct)))
- added handling for structs. When defined inside classes or other structs the double member access will be merged, so there is no performance hit by using structs to group data.
2016-10-24 11:18:13 +00:00
{
// if this is a struct within a class or another struct we can simplify the expression by creating a new PField with a cumulative offset.
if (classx->ExprType == EFX_ClassMember || classx->ExprType == EFX_StructMember)
{
auto parentfield = static_cast<FxStructMember *>(classx)->membervar;
// PFields are garbage collected so this will be automatically taken care of later.
- allow defining native fields through scripts. Internally this only requires exporting the address, but not the entire field. - added new VARF_Transient flag so that the decision whether to serialize a field does not depend solely on its native status. It may actually make a lot of sense to use the auto-serializer for native fields, too, as this would eliminate a lot of maintenance code. - defined (u)int8/16 as aliases to the byte and short types (Can't we not just get rid of this naming convention already...?) - exporting the fields of Actor revealed a few name clashes between them and some global types, so Actor.Sector was renamed to CurSector and Actor.Inventory was renamed to Actor.Inv.
2016-11-22 18:20:31 +00:00
auto newfield = new PField(membervar->SymbolName, membervar->Type, membervar->Flags | parentfield->Flags, membervar->Offset + parentfield->Offset);
newfield->BitValue = membervar->BitValue;
- added handling for structs. When defined inside classes or other structs the double member access will be merged, so there is no performance hit by using structs to group data.
2016-10-24 11:18:13 +00:00
static_cast<FxStructMember *>(classx)->membervar = newfield;
classx->isresolved = false; // re-resolve the parent so it can also check if it can be optimized away.
auto x = classx->Resolve(ctx);
classx = nullptr;
return x;
}
- 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
else if (classx->ExprType == EFX_GlobalVariable)
{
auto parentfield = static_cast<FxGlobalVariable *>(classx)->membervar;
- allow defining native fields through scripts. Internally this only requires exporting the address, but not the entire field. - added new VARF_Transient flag so that the decision whether to serialize a field does not depend solely on its native status. It may actually make a lot of sense to use the auto-serializer for native fields, too, as this would eliminate a lot of maintenance code. - defined (u)int8/16 as aliases to the byte and short types (Can't we not just get rid of this naming convention already...?) - exporting the fields of Actor revealed a few name clashes between them and some global types, so Actor.Sector was renamed to CurSector and Actor.Inventory was renamed to Actor.Inv.
2016-11-22 18:20:31 +00:00
auto newfield = new PField(membervar->SymbolName, membervar->Type, membervar->Flags | parentfield->Flags, membervar->Offset + parentfield->Offset);
newfield->BitValue = membervar->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
static_cast<FxGlobalVariable *>(classx)->membervar = newfield;
classx->isresolved = false; // re-resolve the parent so it can also check if it can be optimized away.
auto x = classx->Resolve(ctx);
classx = nullptr;
return x;
}
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
else if (classx->ExprType == EFX_StackVariable)
{
auto parentfield = static_cast<FxStackVariable *>(classx)->membervar;
- allow defining native fields through scripts. Internally this only requires exporting the address, but not the entire field. - added new VARF_Transient flag so that the decision whether to serialize a field does not depend solely on its native status. It may actually make a lot of sense to use the auto-serializer for native fields, too, as this would eliminate a lot of maintenance code. - defined (u)int8/16 as aliases to the byte and short types (Can't we not just get rid of this naming convention already...?) - exporting the fields of Actor revealed a few name clashes between them and some global types, so Actor.Sector was renamed to CurSector and Actor.Inventory was renamed to Actor.Inv.
2016-11-22 18:20:31 +00:00
auto newfield = new PField(membervar->SymbolName, membervar->Type, membervar->Flags | parentfield->Flags, membervar->Offset + parentfield->Offset);
newfield->BitValue = membervar->BitValue;
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
static_cast<FxStackVariable *>(classx)->ReplaceField(newfield);
classx->isresolved = false; // re-resolve the parent so it can also check if it can be optimized away.
auto x = classx->Resolve(ctx);
classx = nullptr;
return x;
}
- implemented vector operations. Vectors are now fully working as local variables. - removed mulv_kr and divv_kr instructions. The first are redundant and the second are useless. Maybe remove all other vector/const operations as well? They won't get used by the code generator. - fixed disassembly of vector multiplication and division instructions.
2016-10-28 23:39:25 +00:00
else if (classx->ExprType == EFX_LocalVariable && classx->IsVector()) // vectors are a special case because they are held in registers
{
// since this is a vector, all potential things that may get here are single float or an xy-vector.
auto locvar = static_cast<FxLocalVariable *>(classx);
- 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
locvar->RegOffset = int(membervar->Offset / 8);
- implemented vector operations. Vectors are now fully working as local variables. - removed mulv_kr and divv_kr instructions. The first are redundant and the second are useless. Maybe remove all other vector/const operations as well? They won't get used by the code generator. - fixed disassembly of vector multiplication and division instructions.
2016-10-28 23:39:25 +00:00
locvar->ValueType = membervar->Type;
classx = nullptr;
delete this;
return locvar;
}
- added per-channel access for color variables. However, since they are locally stored in registers, it required a minor bit of fudging for this case. - make sure that a PFunction's implementation is always initialized before starting the code generator.
2016-11-21 11:38:39 +00:00
else if (classx->ExprType == EFX_LocalVariable && classx->ValueType == TypeColorStruct)
{
// This needs special treatment because it'd require accessing the register via address.
// Fortunately this is the only place where this kind of access is ever needed so an explicit handling is acceptable.
int bits;
switch (membervar->SymbolName.GetIndex())
{
case NAME_a: bits = 24; break;
case NAME_r: bits = 16; break;
case NAME_g: bits = 8; break;
case NAME_b: default: bits = 0; break;
}
classx->ValueType = TypeColor; // need to set it back.
FxExpression *x = classx;
if (bits > 0) x = new FxShift(TK_URShift, x, new FxConstant(bits, ScriptPosition));
x = new FxBitOp('&', x, new FxConstant(255, ScriptPosition));
classx = nullptr;
delete this;
return x->Resolve(ctx);
}
- added handling for structs. When defined inside classes or other structs the double member access will be merged, so there is no performance hit by using structs to group data.
2016-10-24 11:18:13 +00:00
else
{
- added a new variable flag that allows defining variables which can only be modified by internal script code but not by external mods. Currently this is used by the NoBlockmap and NoSector flags which need special handling for changing.
2016-11-08 10:12:56 +00:00
if (!(classx->RequestAddress(ctx, &AddressWritable)))
- added handling for structs. When defined inside classes or other structs the double member access will be merged, so there is no performance hit by using structs to group data.
2016-10-24 11:18:13 +00:00
{
ScriptPosition.Message(MSG_ERROR, "unable to dereference left side of %s", membervar->SymbolName.GetChars());
delete this;
return nullptr;
}
}
Normalize line endings
2016-03-01 15:47:10 +00:00
}
ValueType = membervar->Type;
return this;
}
- added handling for structs. When defined inside classes or other structs the double member access will be merged, so there is no performance hit by using structs to group data.
2016-10-24 11:18:13 +00:00
ExpEmit FxStructMember::Emit(VMFunctionBuilder *build)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
ExpEmit obj = classx->Emit(build);
assert(obj.RegType == REGT_POINTER);
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
if (obj.Konst)
{
// If the situation where we are dereferencing a constant
// pointer is common, then it would probably be worthwhile
// to add new opcodes for those. But as of right now, I
// don't expect it to be a particularly common case.
ExpEmit newobj(build, REGT_POINTER);
build->Emit(OP_LKP, newobj.RegNum, obj.RegNum);
obj = newobj;
}
- added property definitions to the ZScript parser. This will allow defining custom properties for the default block in custom base classes. See 'Health' for an example. - support transient object member variables for information that does not need to be put in a savegame. - fixed: special initialization of objects needs to pass the proper defaults along, otherwise the parent classes will use their own, inappropriate one.
2017-01-15 15:55:30 +00:00
if (membervar->Flags & VARF_Meta)
- scriptified Heretic's blaster. - scriptified all Effect functions of Fastprojectile's children - implemented access to class meta data. - added a VM instruction to retrieve the class metadata, to eliminate the overhead of the function call that would otherwise be needed. - made GetClass() a builtin so that it can use the new instruction Important note about this commit: Scriptifying CFlameMissile::Effect revealed a problem with the virtual function interface: In order to work, this needs to be explicitly enabled for each single native class that may be used as a base for a scripted class. Needless to say, this will end up way too much work, as there are over 100 native classes, excluding those which will be scriptified. But in order to fix the problem this partially broken state needs to be committed first.
2016-11-24 19:02:44 +00:00
{
obj.Free(build);
ExpEmit meta(build, REGT_POINTER);
build->Emit(OP_META, meta.RegNum, obj.RegNum);
obj = meta;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
if (AddressRequested)
{
if (membervar->Offset == 0)
{
return obj;
}
obj.Free(build);
ExpEmit out(build, REGT_POINTER);
build->Emit(OP_ADDA_RK, out.RegNum, obj.RegNum, build->GetConstantInt((int)membervar->Offset));
return out;
}
int offsetreg = build->GetConstantInt((int)membervar->Offset);
- implemented local vector variables. Currently only the definition plus initial assignment works. - removed all vector4 handling that had already been added, now that this type can no longer be defined.
2016-10-28 13:15:30 +00:00
ExpEmit loc(build, membervar->Type->GetRegType(), membervar->Type->GetRegCount());
Normalize line endings
2016-03-01 15:47:10 +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
if (membervar->BitValue == -1)
{
build->Emit(membervar->Type->GetLoadOp(), loc.RegNum, obj.RegNum, offsetreg);
}
else
{
ExpEmit out(build, REGT_POINTER);
build->Emit(OP_ADDA_RK, out.RegNum, obj.RegNum, offsetreg);
build->Emit(OP_LBIT, loc.RegNum, out.RegNum, 1 << membervar->BitValue);
out.Free(build);
}
Normalize line endings
2016-03-01 15:47:10 +00:00
obj.Free(build);
return loc;
}
- added handling for structs. When defined inside classes or other structs the double member access will be merged, so there is no performance hit by using structs to group data.
2016-10-24 11:18:13 +00:00
//==========================================================================
//
- fixed: The message for invalid class extensions did not pass the class name to the error function.
2016-12-10 09:22:13 +00:00
//
- added handling for structs. When defined inside classes or other structs the double member access will be merged, so there is no performance hit by using structs to group data.
2016-10-24 11:18:13 +00:00
//
//==========================================================================
FxClassMember::FxClassMember(FxExpression *x, PField* mem, const FScriptPosition &pos)
: FxStructMember(x, mem, pos)
{
ExprType = EFX_ClassMember;
}
//==========================================================================
//
//
//
//==========================================================================
Normalize line endings
2016-03-01 15:47:10 +00:00
FxArrayElement::FxArrayElement(FxExpression *base, FxExpression *_index)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
:FxExpression(EFX_ArrayElement, base->ScriptPosition)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
Array=base;
index = _index;
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
AddressRequested = false;
AddressWritable = false;
- added a TStaticArray class that allows safe access to resizable static data (like the sectors, linedefs, etc.) for the VM. - used this to replace the line list in Sector because that gets already used and implemented proper bounds checks for this type of array.
2017-01-02 20:40:52 +00:00
SizeAddr = ~0u;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
//
//
//==========================================================================
FxArrayElement::~FxArrayElement()
{
SAFE_DELETE(Array);
SAFE_DELETE(index);
}
//==========================================================================
//
//
//
//==========================================================================
- added a new variable flag that allows defining variables which can only be modified by internal script code but not by external mods. Currently this is used by the NoBlockmap and NoSector flags which need special handling for changing.
2016-11-08 10:12:56 +00:00
bool FxArrayElement::RequestAddress(FCompileContext &ctx, bool *writable)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
AddressRequested = true;
- handle all unary operators. - handle all binary operators which are already implemented in the code generator. - implemented sizeof/alignof operators in code generator. - rewrote RequestAddress so that its return value is not the writability of an address but the mere existence. Also changed it to not output errors itself because those cannot be dealt with by the calling function.
2016-10-17 18:33:35 +00:00
if (writable != nullptr) *writable = AddressWritable;
return true;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxArrayElement::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE(Array,ctx);
SAFE_RESOLVE(index,ctx);
if (index->ValueType->GetRegType() == REGT_FLOAT /* lax */)
{
// DECORATE allows floats here so cast them to int.
- the compile context now knows if it is invoked by ZScript or DECORATE, so that it can be more strict with ZScript if needed. - added a truncation warning to FxIntCast, which only occurs with ZScript, not with DECORATE. FxBoolCast is intentionally left out because it would defeat the reason for this cast type.
2016-10-15 19:35:31 +00:00
index = new FxIntCast(index, ctx.FromDecorate);
Normalize line endings
2016-03-01 15:47:10 +00:00
index = index->Resolve(ctx);
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
if (index == nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
if (!index->IsInteger())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
ScriptPosition.Message(MSG_ERROR, "Array index must be integer");
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
PArray *arraytype = dyn_cast<PArray>(Array->ValueType);
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
if (arraytype == nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- scriptified Hexen's flies. A few notes: * this accesses the lines array in sector_t which effectively is a pointer to an array of pointers - a type the parser can not represent. The compiler has no problems with it, so for now it is defined internally. * array sizes were limited to 65536 entries because the 'bound' instruction only existed as an immediate version with no provisions for larger values. For the static map arrays 65536 is not sufficient so now there are alternative instructions for these cases. * despite the above, at the moment there is no proper bounds checking for arrays that have no fixed size. To do this, a lot more work is needed. The type system as-is is not prepared for such a scenario.
2016-11-27 17:52:24 +00:00
// Check if we got a pointer to an array. Some native data structures (like the line list in sectors) use this.
PPointer *ptype = dyn_cast<PPointer>(Array->ValueType);
if (ptype == nullptr || !ptype->PointedType->IsKindOf(RUNTIME_CLASS(PArray)))
{
ScriptPosition.Message(MSG_ERROR, "'[]' can only be used with arrays.");
delete this;
return nullptr;
}
arraytype = static_cast<PArray*>(ptype->PointedType);
arrayispointer = true;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- added a TStaticArray class that allows safe access to resizable static data (like the sectors, linedefs, etc.) for the VM. - used this to replace the line list in Sector because that gets already used and implemented proper bounds checks for this type of array.
2017-01-02 20:40:52 +00:00
if (Array->IsResizableArray())
{
// if this is an array within a class or another struct we can simplify the expression by creating a new PField with a cumulative offset.
if (Array->ExprType == EFX_ClassMember || Array->ExprType == EFX_StructMember)
{
auto parentfield = static_cast<FxStructMember *>(Array)->membervar;
- skriptified the skybox actors. - fixed code generation for internal pointed arrays, they were missing a pointer dereference.
2017-01-14 17:04:49 +00:00
SizeAddr = parentfield->Offset + parentfield->Type->Align;
- added a TStaticArray class that allows safe access to resizable static data (like the sectors, linedefs, etc.) for the VM. - used this to replace the line list in Sector because that gets already used and implemented proper bounds checks for this type of array.
2017-01-02 20:40:52 +00:00
}
else if (Array->ExprType == EFX_GlobalVariable)
{
auto parentfield = static_cast<FxGlobalVariable *>(Array)->membervar;
- skriptified the skybox actors. - fixed code generation for internal pointed arrays, they were missing a pointer dereference.
2017-01-14 17:04:49 +00:00
SizeAddr = parentfield->Offset + parentfield->Type->Align;
- added a TStaticArray class that allows safe access to resizable static data (like the sectors, linedefs, etc.) for the VM. - used this to replace the line list in Sector because that gets already used and implemented proper bounds checks for this type of array.
2017-01-02 20:40:52 +00:00
}
else
{
ScriptPosition.Message(MSG_ERROR, "Invalid resizable array");
delete this;
return nullptr;
}
}
else if (index->isConstant())
Use verbose error message with DECORATE array indices
2016-08-11 10:22:37 +00:00
{
unsigned indexval = static_cast<FxConstant *>(index)->GetValue().GetInt();
- added a TStaticArray class that allows safe access to resizable static data (like the sectors, linedefs, etc.) for the VM. - used this to replace the line list in Sector because that gets already used and implemented proper bounds checks for this type of array.
2017-01-02 20:40:52 +00:00
if (indexval >= arraytype->ElementCount && !Array->IsResizableArray())
Use verbose error message with DECORATE array indices
2016-08-11 10:22:37 +00:00
{
ScriptPosition.Message(MSG_ERROR, "Array index out of bounds");
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Use verbose error message with DECORATE array indices
2016-08-11 10:22:37 +00:00
}
- optimize access to array members with constant index. Like with struct members this can be combined with the outer index/address. - fixed register allocation with array indices and stack variables.
2016-11-17 17:06:56 +00:00
- scriptified Hexen's flies. A few notes: * this accesses the lines array in sector_t which effectively is a pointer to an array of pointers - a type the parser can not represent. The compiler has no problems with it, so for now it is defined internally. * array sizes were limited to 65536 entries because the 'bound' instruction only existed as an immediate version with no provisions for larger values. For the static map arrays 65536 is not sufficient so now there are alternative instructions for these cases. * despite the above, at the moment there is no proper bounds checking for arrays that have no fixed size. To do this, a lot more work is needed. The type system as-is is not prepared for such a scenario.
2016-11-27 17:52:24 +00:00
if (!arrayispointer)
- optimize access to array members with constant index. Like with struct members this can be combined with the outer index/address. - fixed register allocation with array indices and stack variables.
2016-11-17 17:06:56 +00:00
{
- scriptified Hexen's flies. A few notes: * this accesses the lines array in sector_t which effectively is a pointer to an array of pointers - a type the parser can not represent. The compiler has no problems with it, so for now it is defined internally. * array sizes were limited to 65536 entries because the 'bound' instruction only existed as an immediate version with no provisions for larger values. For the static map arrays 65536 is not sufficient so now there are alternative instructions for these cases. * despite the above, at the moment there is no proper bounds checking for arrays that have no fixed size. To do this, a lot more work is needed. The type system as-is is not prepared for such a scenario.
2016-11-27 17:52:24 +00:00
// if this is an array within a class or another struct we can simplify the expression by creating a new PField with a cumulative offset.
if (Array->ExprType == EFX_ClassMember || Array->ExprType == EFX_StructMember)
{
auto parentfield = static_cast<FxStructMember *>(Array)->membervar;
// PFields are garbage collected so this will be automatically taken care of later.
auto newfield = new PField(NAME_None, arraytype->ElementType, parentfield->Flags, indexval * arraytype->ElementSize + parentfield->Offset);
static_cast<FxStructMember *>(Array)->membervar = newfield;
Array->isresolved = false; // re-resolve the parent so it can also check if it can be optimized away.
auto x = Array->Resolve(ctx);
Array = nullptr;
return x;
}
else if (Array->ExprType == EFX_GlobalVariable)
{
auto parentfield = static_cast<FxGlobalVariable *>(Array)->membervar;
auto newfield = new PField(NAME_None, arraytype->ElementType, parentfield->Flags, indexval * arraytype->ElementSize + parentfield->Offset);
static_cast<FxGlobalVariable *>(Array)->membervar = newfield;
Array->isresolved = false; // re-resolve the parent so it can also check if it can be optimized away.
auto x = Array->Resolve(ctx);
Array = nullptr;
return x;
}
else if (Array->ExprType == EFX_StackVariable)
{
auto parentfield = static_cast<FxStackVariable *>(Array)->membervar;
auto newfield = new PField(NAME_None, arraytype->ElementType, parentfield->Flags, indexval * arraytype->ElementSize + parentfield->Offset);
static_cast<FxStackVariable *>(Array)->ReplaceField(newfield);
Array->isresolved = false; // re-resolve the parent so it can also check if it can be optimized away.
auto x = Array->Resolve(ctx);
Array = nullptr;
return x;
}
- optimize access to array members with constant index. Like with struct members this can be combined with the outer index/address. - fixed register allocation with array indices and stack variables.
2016-11-17 17:06:56 +00:00
}
Use verbose error message with DECORATE array indices
2016-08-11 10:22:37 +00:00
}
Normalize line endings
2016-03-01 15:47:10 +00:00
ValueType = arraytype->ElementType;
- added a new variable flag that allows defining variables which can only be modified by internal script code but not by external mods. Currently this is used by the NoBlockmap and NoSector flags which need special handling for changing.
2016-11-08 10:12:56 +00:00
if (!Array->RequestAddress(ctx, &AddressWritable))
- handle all unary operators. - handle all binary operators which are already implemented in the code generator. - implemented sizeof/alignof operators in code generator. - rewrote RequestAddress so that its return value is not the writability of an address but the mere existence. Also changed it to not output errors itself because those cannot be dealt with by the calling function.
2016-10-17 18:33:35 +00:00
{
ScriptPosition.Message(MSG_ERROR, "Unable to dereference array.");
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
- handle all unary operators. - handle all binary operators which are already implemented in the code generator. - implemented sizeof/alignof operators in code generator. - rewrote RequestAddress so that its return value is not the writability of an address but the mere existence. Also changed it to not output errors itself because those cannot be dealt with by the calling function.
2016-10-17 18:33:35 +00:00
}
Normalize line endings
2016-03-01 15:47:10 +00:00
return this;
}
//==========================================================================
//
// in its current state this won't be able to do more than handle the args array.
//
//==========================================================================
ExpEmit FxArrayElement::Emit(VMFunctionBuilder *build)
{
- scriptified Hexen's flies. A few notes: * this accesses the lines array in sector_t which effectively is a pointer to an array of pointers - a type the parser can not represent. The compiler has no problems with it, so for now it is defined internally. * array sizes were limited to 65536 entries because the 'bound' instruction only existed as an immediate version with no provisions for larger values. For the static map arrays 65536 is not sufficient so now there are alternative instructions for these cases. * despite the above, at the moment there is no proper bounds checking for arrays that have no fixed size. To do this, a lot more work is needed. The type system as-is is not prepared for such a scenario.
2016-11-27 17:52:24 +00:00
PArray *arraytype;
if (arrayispointer)
{
arraytype = static_cast<PArray*>(static_cast<PPointer*>(Array->ValueType)->PointedType);
}
else
{
arraytype = static_cast<PArray*>(Array->ValueType);
}
- skriptified the skybox actors. - fixed code generation for internal pointed arrays, they were missing a pointer dereference.
2017-01-14 17:04:49 +00:00
ExpEmit arrayvar = Array->Emit(build);
ExpEmit start;
- added a TStaticArray class that allows safe access to resizable static data (like the sectors, linedefs, etc.) for the VM. - used this to replace the line list in Sector because that gets already used and implemented proper bounds checks for this type of array.
2017-01-02 20:40:52 +00:00
ExpEmit bound;
Generalize FxArrayElement to work with all numeric elements (not just 32-bit ints)
2016-04-03 21:07:51 +00:00
- added a TStaticArray class that allows safe access to resizable static data (like the sectors, linedefs, etc.) for the VM. - used this to replace the line list in Sector because that gets already used and implemented proper bounds checks for this type of array.
2017-01-02 20:40:52 +00:00
if (SizeAddr != ~0u)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- skriptified the skybox actors. - fixed code generation for internal pointed arrays, they were missing a pointer dereference.
2017-01-14 17:04:49 +00:00
arrayvar.Free(build);
start = ExpEmit(build, REGT_POINTER);
build->Emit(OP_LP, start.RegNum, arrayvar.RegNum, build->GetConstantInt(0));
- added a TStaticArray class that allows safe access to resizable static data (like the sectors, linedefs, etc.) for the VM. - used this to replace the line list in Sector because that gets already used and implemented proper bounds checks for this type of array.
2017-01-02 20:40:52 +00:00
auto f = new PField(NAME_None, TypeUInt32, 0, SizeAddr);
if (Array->ExprType == EFX_ClassMember || Array->ExprType == EFX_StructMember)
{
static_cast<FxStructMember *>(Array)->membervar = f;
static_cast<FxStructMember *>(Array)->AddressRequested = false;
}
else if (Array->ExprType == EFX_GlobalVariable)
{
static_cast<FxGlobalVariable *>(Array)->membervar = f;
static_cast<FxGlobalVariable *>(Array)->AddressRequested = false;
}
Array->ValueType = TypeUInt32;
bound = Array->Emit(build);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- skriptified the skybox actors. - fixed code generation for internal pointed arrays, they were missing a pointer dereference.
2017-01-14 17:04:49 +00:00
else start = arrayvar;
- added a TStaticArray class that allows safe access to resizable static data (like the sectors, linedefs, etc.) for the VM. - used this to replace the line list in Sector because that gets already used and implemented proper bounds checks for this type of array.
2017-01-02 20:40:52 +00:00
Normalize line endings
2016-03-01 15:47:10 +00:00
if (index->isConstant())
{
unsigned indexval = static_cast<FxConstant *>(index)->GetValue().GetInt();
- added a TStaticArray class that allows safe access to resizable static data (like the sectors, linedefs, etc.) for the VM. - used this to replace the line list in Sector because that gets already used and implemented proper bounds checks for this type of array.
2017-01-02 20:40:52 +00:00
assert(SizeAddr != ~0u || (indexval < arraytype->ElementCount && "Array index out of bounds"));
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
- skriptified the skybox actors. - fixed code generation for internal pointed arrays, they were missing a pointer dereference.
2017-01-14 17:04:49 +00:00
// For resizable arrays we even need to check the bounds if if the index is constant because they are not known at compile time.
- added a TStaticArray class that allows safe access to resizable static data (like the sectors, linedefs, etc.) for the VM. - used this to replace the line list in Sector because that gets already used and implemented proper bounds checks for this type of array.
2017-01-02 20:40:52 +00:00
if (SizeAddr != ~0u)
{
ExpEmit indexreg(build, REGT_INT);
build->EmitLoadInt(indexreg.RegNum, indexval);
build->Emit(OP_BOUND_R, indexreg.RegNum, bound.RegNum);
indexreg.Free(build);
bound.Free(build);
}
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
if (AddressRequested)
{
if (indexval != 0)
{
- added static constant arrays. At the moment they can only be defined inside functions due to lack of dedicated storage inside classes for static data. - added new VM instructions to access the constant tables with a variable index. - refactored VMFunctionBuilder's constant tables so that they are not limited to one entry per value. While this works fine for single values, it makes it impossible to store constant arrays in here.
2016-11-20 17:00:37 +00:00
indexval *= arraytype->ElementSize;
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
if (!start.Fixed)
{
build->Emit(OP_ADDA_RK, start.RegNum, start.RegNum, build->GetConstantInt(indexval));
}
else
{
// do not clobber local variables.
ExpEmit temp(build, start.RegType);
build->Emit(OP_ADDA_RK, temp.RegNum, start.RegNum, build->GetConstantInt(indexval));
start.Free(build);
start = temp;
}
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
}
- optimize access to array members with constant index. Like with struct members this can be combined with the outer index/address. - fixed register allocation with array indices and stack variables.
2016-11-17 17:06:56 +00:00
return start;
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
}
- added static constant arrays. At the moment they can only be defined inside functions due to lack of dedicated storage inside classes for static data. - added new VM instructions to access the constant tables with a variable index. - refactored VMFunctionBuilder's constant tables so that they are not limited to one entry per value. While this works fine for single values, it makes it impossible to store constant arrays in here.
2016-11-20 17:00:37 +00:00
else if (!start.Konst)
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
{
- optimize access to array members with constant index. Like with struct members this can be combined with the outer index/address. - fixed register allocation with array indices and stack variables.
2016-11-17 17:06:56 +00:00
start.Free(build);
ExpEmit dest(build, ValueType->GetRegType());
- added static constant arrays. At the moment they can only be defined inside functions due to lack of dedicated storage inside classes for static data. - added new VM instructions to access the constant tables with a variable index. - refactored VMFunctionBuilder's constant tables so that they are not limited to one entry per value. While this works fine for single values, it makes it impossible to store constant arrays in here.
2016-11-20 17:00:37 +00:00
build->Emit(arraytype->ElementType->GetLoadOp(), dest.RegNum, start.RegNum, build->GetConstantInt(indexval* arraytype->ElementSize));
return dest;
}
else
{
static int LK_Ops[] = { OP_LK, OP_LKF, OP_LKS, OP_LKP };
assert(start.RegType == ValueType->GetRegType());
ExpEmit dest(build, start.RegType);
build->Emit(LK_Ops[start.RegType], dest.RegNum, start.RegNum + indexval);
- optimize access to array members with constant index. Like with struct members this can be combined with the outer index/address. - fixed register allocation with array indices and stack variables.
2016-11-17 17:06:56 +00:00
return dest;
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
}
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
ExpEmit indexv(index->Emit(build));
- added a TStaticArray class that allows safe access to resizable static data (like the sectors, linedefs, etc.) for the VM. - used this to replace the line list in Sector because that gets already used and implemented proper bounds checks for this type of array.
2017-01-02 20:40:52 +00:00
if (SizeAddr != ~0u)
{
build->Emit(OP_BOUND_R, indexv.RegNum, bound.RegNum);
bound.Free(build);
}
else if (arraytype->ElementCount > 65535)
- scriptified Hexen's flies. A few notes: * this accesses the lines array in sector_t which effectively is a pointer to an array of pointers - a type the parser can not represent. The compiler has no problems with it, so for now it is defined internally. * array sizes were limited to 65536 entries because the 'bound' instruction only existed as an immediate version with no provisions for larger values. For the static map arrays 65536 is not sufficient so now there are alternative instructions for these cases. * despite the above, at the moment there is no proper bounds checking for arrays that have no fixed size. To do this, a lot more work is needed. The type system as-is is not prepared for such a scenario.
2016-11-27 17:52:24 +00:00
{
build->Emit(OP_BOUND_K, indexv.RegNum, build->GetConstantInt(arraytype->ElementCount));
}
else
{
build->Emit(OP_BOUND, indexv.RegNum, arraytype->ElementCount);
}
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
- added static constant arrays. At the moment they can only be defined inside functions due to lack of dedicated storage inside classes for static data. - added new VM instructions to access the constant tables with a variable index. - refactored VMFunctionBuilder's constant tables so that they are not limited to one entry per value. While this works fine for single values, it makes it impossible to store constant arrays in here.
2016-11-20 17:00:37 +00:00
if (!start.Konst)
Generalize FxArrayElement to work with all numeric elements (not just 32-bit ints)
2016-04-03 21:07:51 +00:00
{
- added static constant arrays. At the moment they can only be defined inside functions due to lack of dedicated storage inside classes for static data. - added new VM instructions to access the constant tables with a variable index. - refactored VMFunctionBuilder's constant tables so that they are not limited to one entry per value. While this works fine for single values, it makes it impossible to store constant arrays in here.
2016-11-20 17:00:37 +00:00
int shiftbits = 0;
while (1u << shiftbits < arraytype->ElementSize)
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
{
- added static constant arrays. At the moment they can only be defined inside functions due to lack of dedicated storage inside classes for static data. - added new VM instructions to access the constant tables with a variable index. - refactored VMFunctionBuilder's constant tables so that they are not limited to one entry per value. While this works fine for single values, it makes it impossible to store constant arrays in here.
2016-11-20 17:00:37 +00:00
shiftbits++;
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
}
- scriptified the Minotaur. Interesting tidbit: The damage calculation in P_MinotaurSlam had been incorrect for the Heretic version since the friendly Hexen Dark Servant was added, but nobody ever noticed in 14 years...
2016-11-26 00:14:47 +00:00
ExpEmit indexwork = indexv.Fixed && arraytype->ElementSize > 1 ? ExpEmit(build, indexv.RegType) : indexv;
- added static constant arrays. At the moment they can only be defined inside functions due to lack of dedicated storage inside classes for static data. - added new VM instructions to access the constant tables with a variable index. - refactored VMFunctionBuilder's constant tables so that they are not limited to one entry per value. While this works fine for single values, it makes it impossible to store constant arrays in here.
2016-11-20 17:00:37 +00:00
if (1u << shiftbits == arraytype->ElementSize)
{
if (shiftbits > 0)
{
build->Emit(OP_SLL_RI, indexwork.RegNum, indexv.RegNum, shiftbits);
}
}
else
{
// A shift won't do, so use a multiplication
build->Emit(OP_MUL_RK, indexwork.RegNum, indexv.RegNum, build->GetConstantInt(arraytype->ElementSize));
}
indexwork.Free(build);
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
- added static constant arrays. At the moment they can only be defined inside functions due to lack of dedicated storage inside classes for static data. - added new VM instructions to access the constant tables with a variable index. - refactored VMFunctionBuilder's constant tables so that they are not limited to one entry per value. While this works fine for single values, it makes it impossible to store constant arrays in here.
2016-11-20 17:00:37 +00:00
if (AddressRequested)
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
{
- skriptified the skybox actors. - fixed code generation for internal pointed arrays, they were missing a pointer dereference.
2017-01-14 17:04:49 +00:00
start.Free(build);
// do not clobber local variables.
ExpEmit temp(build, start.RegType);
build->Emit(OP_ADDA_RR, temp.RegNum, start.RegNum, indexwork.RegNum);
return temp;
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
}
else
{
- optimize access to array members with constant index. Like with struct members this can be combined with the outer index/address. - fixed register allocation with array indices and stack variables.
2016-11-17 17:06:56 +00:00
start.Free(build);
- added static constant arrays. At the moment they can only be defined inside functions due to lack of dedicated storage inside classes for static data. - added new VM instructions to access the constant tables with a variable index. - refactored VMFunctionBuilder's constant tables so that they are not limited to one entry per value. While this works fine for single values, it makes it impossible to store constant arrays in here.
2016-11-20 17:00:37 +00:00
ExpEmit dest(build, ValueType->GetRegType());
// added 1 to use the *_R version that takes the offset from a register
build->Emit(arraytype->ElementType->GetLoadOp() + 1, dest.RegNum, start.RegNum, indexwork.RegNum);
return dest;
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
}
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
}
else
{
- added static constant arrays. At the moment they can only be defined inside functions due to lack of dedicated storage inside classes for static data. - added new VM instructions to access the constant tables with a variable index. - refactored VMFunctionBuilder's constant tables so that they are not limited to one entry per value. While this works fine for single values, it makes it impossible to store constant arrays in here.
2016-11-20 17:00:37 +00:00
static int LKR_Ops[] = { OP_LK_R, OP_LKF_R, OP_LKS_R, OP_LKP_R };
assert(start.RegType == ValueType->GetRegType());
ExpEmit dest(build, start.RegType);
if (start.RegNum <= 255)
{
// Since large constant tables are the exception, the constant component in C is an immediate value here.
build->Emit(LKR_Ops[start.RegType], dest.RegNum, indexv.RegNum, start.RegNum);
}
else
{
build->Emit(OP_ADD_RK, indexv.RegNum, indexv.RegNum, build->GetConstantInt(start.RegNum));
build->Emit(LKR_Ops[start.RegType], dest.RegNum, indexv.RegNum, 0);
}
indexv.Free(build);
- optimize access to array members with constant index. Like with struct members this can be combined with the outer index/address. - fixed register allocation with array indices and stack variables.
2016-11-17 17:06:56 +00:00
return dest;
Added post/pre increment/decrement operators to DECORATE
2016-08-05 15:33:29 +00:00
}
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
- implemented usage restrictions for action functions.
2016-11-15 20:38:12 +00:00
//==========================================================================
//
// Checks if a function may be called from the current context.
//
//==========================================================================
static bool CheckFunctionCompatiblity(FScriptPosition &ScriptPosition, PFunction *caller, PFunction *callee)
{
if (callee->Variants[0].Flags & VARF_Method)
{
// The called function must support all usage modes of the current function. It may support more, but must not support less.
if ((callee->Variants[0].UseFlags & caller->Variants[0].UseFlags) != caller->Variants[0].UseFlags)
{
ScriptPosition.Message(MSG_ERROR, "Function %s incompatible with current context\n", callee->SymbolName.GetChars());
return false;
}
if (!(caller->Variants[0].Flags & VARF_Method))
{
ScriptPosition.Message(MSG_ERROR, "Call to non-static function %s from a static context", callee->SymbolName.GetChars());
return false;
}
else
{
auto callingself = caller->Variants[0].SelfClass;
auto calledself = callee->Variants[0].SelfClass;
- allow functions in structs. This is needed for several internal data types like players, sectors, lines, etc. - added a new type 'NativeStruct'. This will be used for types that cannot be instantiated, and is also needed to cleanly handle many internal types that only can exist as reference.
2016-11-19 11:12:29 +00:00
bool match = (callingself == calledself);
if (!match)
{
auto callingselfcls = dyn_cast<PClass>(caller->Variants[0].SelfClass);
auto calledselfcls = dyn_cast<PClass>(callee->Variants[0].SelfClass);
match = callingselfcls != nullptr && calledselfcls != nullptr && callingselfcls->IsDescendantOf(calledselfcls);
}
if (!match)
- implemented usage restrictions for action functions.
2016-11-15 20:38:12 +00:00
{
ScriptPosition.Message(MSG_ERROR, "Call to member function %s with incompatible self pointer.", callee->SymbolName.GetChars());
return false;
}
}
}
return true;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
//
//
//==========================================================================
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
FxFunctionCall::FxFunctionCall(FName methodname, FName rngname, FArgumentList &args, const FScriptPosition &pos)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_FunctionCall, pos)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
MethodName = methodname;
- fixed: The RNG was not initialized for script calls that did not explicitly specify an RNG by name.
2016-11-04 08:23:29 +00:00
RNG = &pr_exrandom;
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
ArgList = std::move(args);
- added named RNG support to FxFunctionCall. This looks simpler than duplicating all that stuff and avoids a lot code duplication.
2016-10-15 23:08:02 +00:00
if (rngname != NAME_None)
{
switch (MethodName)
{
case NAME_Random:
case NAME_FRandom:
case NAME_RandomPick:
case NAME_FRandomPick:
case NAME_Random2:
RNG = FRandom::StaticFindRNG(rngname.GetChars());
break;
default:
pos.Message(MSG_ERROR, "Cannot use named RNGs with %s", MethodName.GetChars());
break;
}
}
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
//
//
//==========================================================================
FxFunctionCall::~FxFunctionCall()
{
}
//==========================================================================
//
- added handling for all the builtins supported by DECORATE to FxFunctionCall. For the random functions this class only handles the default-RNG version. The one with an explicit RNG needs to be done separately because the parser produces different output for them.
2016-10-15 22:12:33 +00:00
// Check function that gets called
//
//==========================================================================
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
static bool CheckArgSize(FName fname, FArgumentList &args, int min, int max, FScriptPosition &sc)
- added handling for all the builtins supported by DECORATE to FxFunctionCall. For the random functions this class only handles the default-RNG version. The one with an explicit RNG needs to be done separately because the parser produces different output for them.
2016-10-15 22:12:33 +00:00
{
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
int s = args.Size();
- added handling for all the builtins supported by DECORATE to FxFunctionCall. For the random functions this class only handles the default-RNG version. The one with an explicit RNG needs to be done separately because the parser produces different output for them.
2016-10-15 22:12:33 +00:00
if (s < min)
{
sc.Message(MSG_ERROR, "Insufficient arguments in call to %s, expected %d, got %d", fname.GetChars(), min, s);
return false;
}
else if (s > max && max >= 0)
{
sc.Message(MSG_ERROR, "Too many arguments in call to %s, expected %d, got %d", fname.GetChars(), min, s);
return false;
}
return true;
}
//==========================================================================
//
//
Normalize line endings
2016-03-01 15:47:10 +00:00
//
//==========================================================================
FxExpression *FxFunctionCall::Resolve(FCompileContext& ctx)
{
- added the required code genration nodes for member function calls. This is not testable right now because finally the action function mess has come full circle. The current setup makes it impossible to call action functions from non-action functions because the needed info is local to the functions. Long avoided, this needs to be refactored now so that the different semantics for action functions are no longer needed.
2016-10-22 10:10:19 +00:00
bool error = false;
- added FindClassMemberFunction which retrieves a function symbol and performs some verification. - removed Self parameter from FxFunctionCall. Actual member function calls through an object require quite different handling so lumping these two together makes no sense. - added a workaround to deal with ACS_NamedExecuteWithResult to both the compiler and FindClassMemberFunction. The way the ZScript compiler sets this up means that it will call the builtin, not the actual action function, so the parser needs to do some explicit check to get past the same-named action function. - pass a proper self pointer to FxActionSpecial. Although it's still not being used, propagating design shortcuts through several function levels is a very, very bad idea.
2016-10-15 18:16:44 +00:00
- fixed: Do not allow empty function arguments pass. For unknown reasons the grammar accepts them as valid, so this needs to be checked when resolving them.
2016-11-25 15:35:07 +00:00
for (auto a : ArgList)
{
if (a == nullptr)
{
ScriptPosition.Message(MSG_ERROR, "Empty function argument.");
delete this;
return nullptr;
}
}
- no more Simplify for global constants as well.
2017-01-23 00:10:40 +00:00
if (ctx.Class != nullptr)
- converted a few more DECORATE files. - started with the AST converter. So far it only deals with direct function calls with simple constants as parameters. - added an error condition for the defaults block to get rid of some asserts.
2016-10-13 22:40:20 +00:00
{
- no more Simplify for global constants as well.
2017-01-23 00:10:40 +00:00
PFunction *afd = FindClassMemberFunction(ctx.Class, ctx.Class, MethodName, ScriptPosition, &error);
- no more simplify in state parameters. - resolving constants with the backend requires a few more error checks.
2017-01-22 22:53:50 +00:00
- no more Simplify for global constants as well.
2017-01-23 00:10:40 +00:00
if (afd != nullptr)
- added the required code genration nodes for member function calls. This is not testable right now because finally the action function mess has come full circle. The current setup makes it impossible to call action functions from non-action functions because the needed info is local to the functions. Long avoided, this needs to be refactored now so that the different semantics for action functions are no longer needed.
2016-10-22 10:10:19 +00:00
{
- no more Simplify for global constants as well.
2017-01-23 00:10:40 +00:00
if (ctx.Function == nullptr)
{
ScriptPosition.Message(MSG_ERROR, "Unable to call function %s from constant declaration", MethodName.GetChars());
delete this;
return nullptr;
}
if (!CheckFunctionCompatiblity(ScriptPosition, ctx.Function, afd))
{
delete this;
return nullptr;
}
auto self = (afd->Variants[0].Flags & VARF_Method) ? new FxSelf(ScriptPosition) : nullptr;
auto x = new FxVMFunctionCall(self, afd, ArgList, ScriptPosition, false);
- added the required code genration nodes for member function calls. This is not testable right now because finally the action function mess has come full circle. The current setup makes it impossible to call action functions from non-action functions because the needed info is local to the functions. Long avoided, this needs to be refactored now so that the different semantics for action functions are no longer needed.
2016-10-22 10:10:19 +00:00
delete this;
- no more Simplify for global constants as well.
2017-01-23 00:10:40 +00:00
return x->Resolve(ctx);
- added the required code genration nodes for member function calls. This is not testable right now because finally the action function mess has come full circle. The current setup makes it impossible to call action functions from non-action functions because the needed info is local to the functions. Long avoided, this needs to be refactored now so that the different semantics for action functions are no longer needed.
2016-10-22 10:10:19 +00:00
}
- converted a few more DECORATE files. - started with the AST converter. So far it only deals with direct function calls with simple constants as parameters. - added an error condition for the defaults block to get rid of some asserts.
2016-10-13 22:40:20 +00:00
}
Normalize line endings
2016-03-01 15:47:10 +00:00
for (size_t i = 0; i < countof(FxFlops); ++i)
{
if (MethodName == FxFlops[i].Name)
{
FxExpression *x = new FxFlopFunctionCall(i, ArgList, ScriptPosition);
delete this;
return x->Resolve(ctx);
}
}
int min, max, special;
if (MethodName == NAME_ACS_NamedExecuteWithResult || MethodName == NAME_CallACS)
{
special = -ACS_ExecuteWithResult;
min = 1;
max = 5;
}
else
{
special = P_FindLineSpecial(MethodName.GetChars(), &min, &max);
}
if (special != 0 && min >= 0)
{
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
int paramcount = ArgList.Size();
- no more Simplify for global constants as well.
2017-01-23 00:10:40 +00:00
if (ctx.Function == nullptr || ctx.Class == nullptr)
- no more simplify in state parameters. - resolving constants with the backend requires a few more error checks.
2017-01-22 22:53:50 +00:00
{
ScriptPosition.Message(MSG_ERROR, "Unable to call action special %s from constant declaration", MethodName.GetChars());
delete this;
return nullptr;
}
else if (paramcount < min)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
ScriptPosition.Message(MSG_ERROR, "Not enough parameters for '%s' (expected %d, got %d)",
MethodName.GetChars(), min, paramcount);
delete this;
- added FindClassMemberFunction which retrieves a function symbol and performs some verification. - removed Self parameter from FxFunctionCall. Actual member function calls through an object require quite different handling so lumping these two together makes no sense. - added a workaround to deal with ACS_NamedExecuteWithResult to both the compiler and FindClassMemberFunction. The way the ZScript compiler sets this up means that it will call the builtin, not the actual action function, so the parser needs to do some explicit check to get past the same-named action function. - pass a proper self pointer to FxActionSpecial. Although it's still not being used, propagating design shortcuts through several function levels is a very, very bad idea.
2016-10-15 18:16:44 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else if (paramcount > max)
{
ScriptPosition.Message(MSG_ERROR, "too many parameters for '%s' (expected %d, got %d)",
MethodName.GetChars(), max, paramcount);
delete this;
- added FindClassMemberFunction which retrieves a function symbol and performs some verification. - removed Self parameter from FxFunctionCall. Actual member function calls through an object require quite different handling so lumping these two together makes no sense. - added a workaround to deal with ACS_NamedExecuteWithResult to both the compiler and FindClassMemberFunction. The way the ZScript compiler sets this up means that it will call the builtin, not the actual action function, so the parser needs to do some explicit check to get past the same-named action function. - pass a proper self pointer to FxActionSpecial. Although it's still not being used, propagating design shortcuts through several function levels is a very, very bad idea.
2016-10-15 18:16:44 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- fixed: Non-Actors cannot act as activators for action specials and must pass null when acticating one.
2016-12-11 20:39:35 +00:00
FxExpression *self = (ctx.Function && (ctx.Function->Variants[0].Flags & VARF_Method) && ctx.Class->IsKindOf(RUNTIME_CLASS(PClassActor))) ? new FxSelf(ScriptPosition) : (FxExpression*)new FxConstant(ScriptPosition);
- added FindClassMemberFunction which retrieves a function symbol and performs some verification. - removed Self parameter from FxFunctionCall. Actual member function calls through an object require quite different handling so lumping these two together makes no sense. - added a workaround to deal with ACS_NamedExecuteWithResult to both the compiler and FindClassMemberFunction. The way the ZScript compiler sets this up means that it will call the builtin, not the actual action function, so the parser needs to do some explicit check to get past the same-named action function. - pass a proper self pointer to FxActionSpecial. Although it's still not being used, propagating design shortcuts through several function levels is a very, very bad idea.
2016-10-15 18:16:44 +00:00
FxExpression *x = new FxActionSpecialCall(self, special, ArgList, ScriptPosition);
Normalize line endings
2016-03-01 15:47:10 +00:00
delete this;
return x->Resolve(ctx);
}
- fixed: Class and struct name lookup was not context aware. If a later module reused an existing name for a different class or struct type, this new name would completely shadow the old one, even in the base files. Changed it so that each compilation unit (i.e. each ZScript and DECORATE lump) get their own symbol table and can only see the symbol tables that got defined in lower numbered resource files so that later definitions do not pollute the available list of symbols when running the compiler backend and code generator - which happens after everything has been parsed. Another effect of this is that a mod that reuses the name of an internal global constant will only see its own constant, again reducing the risk of potential errors in case the internal definitions add some new values. Global constants are still discouraged from being used because what this does not and can not handle is the case that a mod defines a global constant with the same name as a class variable. In such a case the class variable will always take precedence for code inside that class. Note that the internal struct String had to be renamed for this because the stricter checks did not let the type String pass on the left side of a '.' anymore. - made PEnum inherit from PInt and not from PNamedType. The old inheritance broke nearly every check for integer compatibility in the compiler, so this hopefully leads to a working enum implementation.
2017-01-23 18:09:36 +00:00
PClass *cls = FindClassType(MethodName, ctx);
- 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
if (cls != nullptr && cls->bExported)
{
if (CheckArgSize(MethodName, ArgList, 1, 1, ScriptPosition))
{
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
FxExpression *x = new FxDynamicCast(cls, ArgList[0]);
ArgList[0] = nullptr;
- 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
delete this;
return x->Resolve(ctx);
}
else
{
delete this;
return nullptr;
}
}
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
// Last but not least: Check builtins and type casts. The random functions can take a named RNG if specified.
- added handling for all the builtins supported by DECORATE to FxFunctionCall. For the random functions this class only handles the default-RNG version. The one with an explicit RNG needs to be done separately because the parser produces different output for them.
2016-10-15 22:12:33 +00:00
// Note that for all builtins the used arguments have to be nulled in the ArgList so that they won't get deleted before they get used.
FxExpression *func = nullptr;
switch (MethodName)
{
- converted half of ClericHoly. (Making a commit before starting on the more complex stuff.) - added a 'constructor' for color values.
2016-11-26 12:18:48 +00:00
case NAME_Color:
if (ArgList.Size() == 3 || ArgList.Size() == 4)
{
func = new FxColorLiteral(ArgList, ScriptPosition);
break;
}
// fall through
- fixed: Explicit casts to bool were missing.
2016-11-06 12:20:22 +00:00
case NAME_Bool:
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
case NAME_Int:
case NAME_uInt:
- let's add a 'float' cast, too, just in case. It still will cast to double, because single precision floats only can exist as memory values.
2016-11-06 12:21:47 +00:00
case NAME_Float:
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
case NAME_Double:
case NAME_Name:
case NAME_Sound:
- added a 'DefaultStateUsage' property so that this setting can be properly set up for the classes that can inject states into other actors.
2016-11-14 17:31:12 +00:00
case NAME_State:
- added two new integral types SpriteID and TextureID, both are needed to allow proper serialization as they require something different to be written out than a regular integer.
2016-11-21 12:45:33 +00:00
case NAME_SpriteID:
case NAME_TextureID:
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
if (CheckArgSize(MethodName, ArgList, 1, 1, ScriptPosition))
{
- fixed: Explicit casts to bool were missing.
2016-11-06 12:20:22 +00:00
PType *type =
MethodName == NAME_Bool ? TypeBool :
MethodName == NAME_Int ? TypeSInt32 :
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
MethodName == NAME_uInt ? TypeUInt32 :
- let's add a 'float' cast, too, just in case. It still will cast to double, because single precision floats only can exist as memory values.
2016-11-06 12:21:47 +00:00
MethodName == NAME_Float ? TypeFloat64 :
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
MethodName == NAME_Double ? TypeFloat64 :
MethodName == NAME_Name ? TypeName :
- added two new integral types SpriteID and TextureID, both are needed to allow proper serialization as they require something different to be written out than a regular integer.
2016-11-21 12:45:33 +00:00
MethodName == NAME_SpriteID ? TypeSpriteID :
MethodName == NAME_TextureID ? TypeTextureID :
- added a 'DefaultStateUsage' property so that this setting can be properly set up for the classes that can inject states into other actors.
2016-11-14 17:31:12 +00:00
MethodName == NAME_State ? TypeState :
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
MethodName == NAME_Color ? TypeColor : (PType*)TypeSound;
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
func = new FxTypeCast(ArgList[0], type, true, true);
ArgList[0] = nullptr;
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
}
break;
- scriptified Heretic's blaster. - scriptified all Effect functions of Fastprojectile's children - implemented access to class meta data. - added a VM instruction to retrieve the class metadata, to eliminate the overhead of the function call that would otherwise be needed. - made GetClass() a builtin so that it can use the new instruction Important note about this commit: Scriptifying CFlameMissile::Effect revealed a problem with the virtual function interface: In order to work, this needs to be explicitly enabled for each single native class that may be used as a base for a scripted class. Needless to say, this will end up way too much work, as there are over 100 native classes, excluding those which will be scriptified. But in order to fix the problem this partially broken state needs to be committed first.
2016-11-24 19:02:44 +00:00
case NAME_GetClass:
if (CheckArgSize(NAME_GetClass, ArgList, 0, 0, ScriptPosition))
{
func = new FxGetClass(new FxSelf(ScriptPosition));
}
break;
- scriptified the backpack. - added GetParentClass builtin to compiler.
2017-01-14 22:34:47 +00:00
case NAME_GetParentClass:
if (CheckArgSize(NAME_GetParentClass, ArgList, 0, 0, ScriptPosition))
{
func = new FxGetParentClass(new FxSelf(ScriptPosition));
}
break;
- fixed: Readonly pointers never were flagged as such. - fixed: Assignment from a readonly to a read-allowed pointer must be an error. - made GetDefaultByType a builtin so that it can do proper type assignment to the result, which for a function would be problematic in this case, even if automatic type deduction was implemented. Since this returns the class defaults which are not a real object, the result cannot be subjected to a type cast. - error out if a type cast of a readonly pointer is attempted. - fixed: FxBooleanNot could clobber a local variable because it used the source register to manipulate the result.
2016-11-27 14:50:58 +00:00
case NAME_GetDefaultByType:
if (CheckArgSize(NAME_GetDefaultByType, ArgList, 1, 1, ScriptPosition))
{
func = new FxGetDefaultByType(ArgList[0]);
ArgList[0] = nullptr;
}
break;
- added handling for all the builtins supported by DECORATE to FxFunctionCall. For the random functions this class only handles the default-RNG version. The one with an explicit RNG needs to be done separately because the parser produces different output for them.
2016-10-15 22:12:33 +00:00
case NAME_Random:
- 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
// allow calling Random without arguments to default to (0, 255)
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
if (ArgList.Size() == 0)
- 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
{
func = new FxRandom(RNG, new FxConstant(0, ScriptPosition), new FxConstant(255, ScriptPosition), ScriptPosition, ctx.FromDecorate);
}
else if (CheckArgSize(NAME_Random, ArgList, 2, 2, ScriptPosition))
- added handling for all the builtins supported by DECORATE to FxFunctionCall. For the random functions this class only handles the default-RNG version. The one with an explicit RNG needs to be done separately because the parser produces different output for them.
2016-10-15 22:12:33 +00:00
{
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
func = new FxRandom(RNG, ArgList[0], ArgList[1], ScriptPosition, ctx.FromDecorate);
ArgList[0] = ArgList[1] = nullptr;
- added handling for all the builtins supported by DECORATE to FxFunctionCall. For the random functions this class only handles the default-RNG version. The one with an explicit RNG needs to be done separately because the parser produces different output for them.
2016-10-15 22:12:33 +00:00
}
break;
case NAME_FRandom:
if (CheckArgSize(NAME_FRandom, ArgList, 2, 2, ScriptPosition))
{
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
func = new FxFRandom(RNG, ArgList[0], ArgList[1], ScriptPosition);
ArgList[0] = ArgList[1] = nullptr;
- added handling for all the builtins supported by DECORATE to FxFunctionCall. For the random functions this class only handles the default-RNG version. The one with an explicit RNG needs to be done separately because the parser produces different output for them.
2016-10-15 22:12:33 +00:00
}
break;
case NAME_RandomPick:
case NAME_FRandomPick:
if (CheckArgSize(MethodName, ArgList, 1, -1, ScriptPosition))
{
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
func = new FxRandomPick(RNG, ArgList, MethodName == NAME_FRandomPick, ScriptPosition, ctx.FromDecorate);
- added handling for all the builtins supported by DECORATE to FxFunctionCall. For the random functions this class only handles the default-RNG version. The one with an explicit RNG needs to be done separately because the parser produces different output for them.
2016-10-15 22:12:33 +00:00
}
break;
case NAME_Random2:
- implemented array-style syntax for Random calls. - implemented handling of the basic math operators so that heretic/beast.txt can be processed. This is working, aside from still needing the type casts to properly transform the strings to class pointers.
2016-10-16 08:59:12 +00:00
if (CheckArgSize(NAME_Random2, ArgList, 0, 1, ScriptPosition))
- added handling for all the builtins supported by DECORATE to FxFunctionCall. For the random functions this class only handles the default-RNG version. The one with an explicit RNG needs to be done separately because the parser produces different output for them.
2016-10-15 22:12:33 +00:00
{
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
func = new FxRandom2(RNG, ArgList.Size() == 0? nullptr : ArgList[0], ScriptPosition, ctx.FromDecorate);
if (ArgList.Size() > 0) ArgList[0] = nullptr;
- added handling for all the builtins supported by DECORATE to FxFunctionCall. For the random functions this class only handles the default-RNG version. The one with an explicit RNG needs to be done separately because the parser produces different output for them.
2016-10-15 22:12:33 +00:00
}
break;
case NAME_Min:
case NAME_Max:
if (CheckArgSize(MethodName, ArgList, 2, -1, ScriptPosition))
{
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
func = new FxMinMax(ArgList, MethodName, ScriptPosition);
- added handling for all the builtins supported by DECORATE to FxFunctionCall. For the random functions this class only handles the default-RNG version. The one with an explicit RNG needs to be done separately because the parser produces different output for them.
2016-10-15 22:12:33 +00:00
}
break;
case NAME_Clamp:
if (CheckArgSize(MethodName, ArgList, 3, 3, ScriptPosition))
{
TArray<FxExpression *> pass;
pass.Resize(2);
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
pass[0] = ArgList[0];
pass[1] = ArgList[1];
- added handling for all the builtins supported by DECORATE to FxFunctionCall. For the random functions this class only handles the default-RNG version. The one with an explicit RNG needs to be done separately because the parser produces different output for them.
2016-10-15 22:12:33 +00:00
pass[0] = new FxMinMax(pass, NAME_Max, ScriptPosition);
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
pass[1] = ArgList[2];
- fixed: Clamp was initialized with incorrect values.
2016-11-07 13:57:59 +00:00
func = new FxMinMax(pass, NAME_Min, ScriptPosition);
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
ArgList[0] = ArgList[1] = ArgList[2] = nullptr;
- added handling for all the builtins supported by DECORATE to FxFunctionCall. For the random functions this class only handles the default-RNG version. The one with an explicit RNG needs to be done separately because the parser produces different output for them.
2016-10-15 22:12:33 +00:00
}
break;
case NAME_Abs:
if (CheckArgSize(MethodName, ArgList, 1, 1, ScriptPosition))
{
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
func = new FxAbs(ArgList[0]);
ArgList[0] = nullptr;
- added handling for all the builtins supported by DECORATE to FxFunctionCall. For the random functions this class only handles the default-RNG version. The one with an explicit RNG needs to be done separately because the parser produces different output for them.
2016-10-15 22:12:33 +00:00
}
break;
case NAME_ATan2:
case NAME_VectorAngle:
if (CheckArgSize(MethodName, ArgList, 2, 2, ScriptPosition))
{
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
func = MethodName == NAME_ATan2 ? new FxATan2(ArgList[0], ArgList[1], ScriptPosition) : new FxATan2(ArgList[1], ArgList[0], ScriptPosition);
ArgList[0] = ArgList[1] = nullptr;
- added handling for all the builtins supported by DECORATE to FxFunctionCall. For the random functions this class only handles the default-RNG version. The one with an explicit RNG needs to be done separately because the parser produces different output for them.
2016-10-15 22:12:33 +00:00
}
break;
- added a 'new' intrinsic to create new objects from inside scripts. This is not tested yet and likely to not working correctly yet. Will be fixed once I get far enough to use it later.
2017-02-03 21:56:03 +00:00
case NAME_New:
if (CheckArgSize(MethodName, ArgList, 1, 1, ScriptPosition))
{
func = new FxNew(ArgList[0]);
ArgList[0] = nullptr;
}
break;
- added handling for all the builtins supported by DECORATE to FxFunctionCall. For the random functions this class only handles the default-RNG version. The one with an explicit RNG needs to be done separately because the parser produces different output for them.
2016-10-15 22:12:33 +00:00
default:
- 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
ScriptPosition.Message(MSG_ERROR, "Call to unknown function '%s'", MethodName.GetChars());
- added handling for all the builtins supported by DECORATE to FxFunctionCall. For the random functions this class only handles the default-RNG version. The one with an explicit RNG needs to be done separately because the parser produces different output for them.
2016-10-15 22:12:33 +00:00
break;
}
if (func != nullptr)
{
delete this;
return func->Resolve(ctx);
}
Normalize line endings
2016-03-01 15:47:10 +00:00
delete this;
- added FindClassMemberFunction which retrieves a function symbol and performs some verification. - removed Self parameter from FxFunctionCall. Actual member function calls through an object require quite different handling so lumping these two together makes no sense. - added a workaround to deal with ACS_NamedExecuteWithResult to both the compiler and FindClassMemberFunction. The way the ZScript compiler sets this up means that it will call the builtin, not the actual action function, so the parser needs to do some explicit check to get past the same-named action function. - pass a proper self pointer to FxActionSpecial. Although it's still not being used, propagating design shortcuts through several function levels is a very, very bad idea.
2016-10-15 18:16:44 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- added the required code genration nodes for member function calls. This is not testable right now because finally the action function mess has come full circle. The current setup makes it impossible to call action functions from non-action functions because the needed info is local to the functions. Long avoided, this needs to be refactored now so that the different semantics for action functions are no longer needed.
2016-10-22 10:10:19 +00:00
//==========================================================================
//
//
//
//==========================================================================
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
FxMemberFunctionCall::FxMemberFunctionCall(FxExpression *self, FName methodname, FArgumentList &args, const FScriptPosition &pos)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_MemberFunctionCall, pos)
- added the required code genration nodes for member function calls. This is not testable right now because finally the action function mess has come full circle. The current setup makes it impossible to call action functions from non-action functions because the needed info is local to the functions. Long avoided, this needs to be refactored now so that the different semantics for action functions are no longer needed.
2016-10-22 10:10:19 +00:00
{
Self = self;
MethodName = methodname;
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
ArgList = std::move(args);
- added the required code genration nodes for member function calls. This is not testable right now because finally the action function mess has come full circle. The current setup makes it impossible to call action functions from non-action functions because the needed info is local to the functions. Long avoided, this needs to be refactored now so that the different semantics for action functions are no longer needed.
2016-10-22 10:10:19 +00:00
}
//==========================================================================
//
//
//
//==========================================================================
FxMemberFunctionCall::~FxMemberFunctionCall()
{
SAFE_DELETE(Self);
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxMemberFunctionCall::Resolve(FCompileContext& ctx)
{
- scriptified the pistol to test if struct member functions work. - made APlayerPawn::PlayAttacking(2) virtual script functions so that mods have better control over player animations. Note that these have no native base so they skip the templated interface for managing virtual functions.
2016-11-19 12:56:29 +00:00
PStruct *cls;
- added the required code genration nodes for member function calls. This is not testable right now because finally the action function mess has come full circle. The current setup makes it impossible to call action functions from non-action functions because the needed info is local to the functions. Long avoided, this needs to be refactored now so that the different semantics for action functions are no longer needed.
2016-10-22 10:10:19 +00:00
bool staticonly = false;
- implemented super calls and proper dispatch of scripted virtual overrides for Destroy.
2016-11-11 20:52:08 +00:00
bool novirtual = 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
- scriptified the Minotaur. Interesting tidbit: The damage calculation in P_MinotaurSlam had been incorrect for the Heretic version since the friendly Hexen Dark Servant was added, but nobody ever noticed in 14 years...
2016-11-26 00:14:47 +00:00
PStruct *ccls = nullptr;
- scriptified A_Saw. - implemented multiple-return-value assignment. Due to some grammar conflicts the originally intended Lua-inspired syntax of 'a, b = Function()' could not be done, so it's '[a, b] = Function()'
2016-11-19 23:25:38 +00:00
- no more Simplify for global constants as well.
2017-01-23 00:10:40 +00:00
if (ctx.Class == nullptr)
{
// There's no way that a member function call can resolve to a constant so abort right away.
ScriptPosition.Message(MSG_ERROR, "Expression is not constant.");
delete this;
return nullptr;
}
- fixed: Do not allow empty function arguments pass. For unknown reasons the grammar accepts them as valid, so this needs to be checked when resolving them.
2016-11-25 15:35:07 +00:00
for (auto a : ArgList)
{
if (a == nullptr)
{
ScriptPosition.Message(MSG_ERROR, "Empty function argument.");
delete this;
return nullptr;
}
}
- 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
if (Self->ExprType == EFX_Identifier)
{
- fixed: Class and struct name lookup was not context aware. If a later module reused an existing name for a different class or struct type, this new name would completely shadow the old one, even in the base files. Changed it so that each compilation unit (i.e. each ZScript and DECORATE lump) get their own symbol table and can only see the symbol tables that got defined in lower numbered resource files so that later definitions do not pollute the available list of symbols when running the compiler backend and code generator - which happens after everything has been parsed. Another effect of this is that a mod that reuses the name of an internal global constant will only see its own constant, again reducing the risk of potential errors in case the internal definitions add some new values. Global constants are still discouraged from being used because what this does not and can not handle is the case that a mod defines a global constant with the same name as a class variable. In such a case the class variable will always take precedence for code inside that class. Note that the internal struct String had to be renamed for this because the stricter checks did not let the type String pass on the left side of a '.' anymore. - made PEnum inherit from PInt and not from PNamedType. The old inheritance broke nearly every check for integer compatibility in the compiler, so this hopefully leads to a working enum implementation.
2017-01-23 18:09:36 +00:00
auto id = static_cast<FxIdentifier *>(Self)->Identifier;
- 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
// If the left side is a class name for a static member function call it needs to be resolved manually
// because the resulting value type would cause problems in nearly every other place where identifiers are being used.
- fixed: Class and struct name lookup was not context aware. If a later module reused an existing name for a different class or struct type, this new name would completely shadow the old one, even in the base files. Changed it so that each compilation unit (i.e. each ZScript and DECORATE lump) get their own symbol table and can only see the symbol tables that got defined in lower numbered resource files so that later definitions do not pollute the available list of symbols when running the compiler backend and code generator - which happens after everything has been parsed. Another effect of this is that a mod that reuses the name of an internal global constant will only see its own constant, again reducing the risk of potential errors in case the internal definitions add some new values. Global constants are still discouraged from being used because what this does not and can not handle is the case that a mod defines a global constant with the same name as a class variable. In such a case the class variable will always take precedence for code inside that class. Note that the internal struct String had to be renamed for this because the stricter checks did not let the type String pass on the left side of a '.' anymore. - made PEnum inherit from PInt and not from PNamedType. The old inheritance broke nearly every check for integer compatibility in the compiler, so this hopefully leads to a working enum implementation.
2017-01-23 18:09:36 +00:00
if (id == NAME_String) ccls = TypeStringStruct;
else ccls = FindStructType(id, ctx);
- scriptified the Minotaur. Interesting tidbit: The damage calculation in P_MinotaurSlam had been incorrect for the Heretic version since the friendly Hexen Dark Servant was added, but nobody ever noticed in 14 years...
2016-11-26 00:14:47 +00:00
if (ccls != nullptr) static_cast<FxIdentifier *>(Self)->noglobal = true;
- scriptified A_Saw. - implemented multiple-return-value assignment. Due to some grammar conflicts the originally intended Lua-inspired syntax of 'a, b = Function()' could not be done, so it's '[a, b] = Function()'
2016-11-19 23:25:38 +00:00
}
SAFE_RESOLVE(Self, ctx);
if (Self->ValueType == TypeError)
{
- scriptified the pistol to test if struct member functions work. - made APlayerPawn::PlayAttacking(2) virtual script functions so that mods have better control over player animations. Note that these have no native base so they skip the templated interface for managing virtual functions.
2016-11-19 12:56:29 +00:00
if (ccls != nullptr)
- 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
{
Implemented static methods in String struct. Implemented String.Format and String.AppendFormat. Implemented native vararg methods for the future.
2017-01-21 00:07:44 +00:00
// [ZZ] substitute ccls for String internal type.
- scriptified the Minotaur. Interesting tidbit: The damage calculation in P_MinotaurSlam had been incorrect for the Heretic version since the friendly Hexen Dark Servant was added, but nobody ever noticed in 14 years...
2016-11-26 00:14:47 +00:00
if (!ccls->IsKindOf(RUNTIME_CLASS(PClass)) || static_cast<PClass *>(ccls)->bExported)
- scriptified the pistol to test if struct member functions work. - made APlayerPawn::PlayAttacking(2) virtual script functions so that mods have better control over player animations. Note that these have no native base so they skip the templated interface for managing virtual functions.
2016-11-19 12:56:29 +00:00
{
cls = ccls;
staticonly = true;
- scriptified PowerLightAmp and PowerTorch. - allow calling qualified super methods so skipping some levels is possible.
2017-01-15 23:46:15 +00:00
if (ccls->IsKindOf(RUNTIME_CLASS(PClass)))
{
- no more simplify in state parameters. - resolving constants with the backend requires a few more error checks.
2017-01-22 22:53:50 +00:00
if (ctx.Function == nullptr)
{
ScriptPosition.Message(MSG_ERROR, "Unable to call %s from constant declaration", MethodName.GetChars());
delete this;
return nullptr;
}
- scriptified PowerLightAmp and PowerTorch. - allow calling qualified super methods so skipping some levels is possible.
2017-01-15 23:46:15 +00:00
auto clstype = dyn_cast<PClass>(ctx.Function->Variants[0].SelfClass);
if (clstype != nullptr)
{
novirtual = clstype->IsDescendantOf(static_cast<PClass*>(ccls));
if (novirtual)
{
bool error;
PFunction *afd = FindClassMemberFunction(ccls, ctx.Class, MethodName, ScriptPosition, &error);
if ((afd->Variants[0].Flags & VARF_Method) && (afd->Variants[0].Flags & VARF_Virtual))
{
staticonly = false;
novirtual = true;
delete Self;
Self = new FxSelf(ScriptPosition);
Self->ValueType = NewPointer(cls);
}
}
}
}
if (!novirtual) goto isresolved;
- scriptified the pistol to test if struct member functions work. - made APlayerPawn::PlayAttacking(2) virtual script functions so that mods have better control over player animations. Note that these have no native base so they skip the templated interface for managing virtual functions.
2016-11-19 12:56:29 +00:00
}
}
- 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
}
- implemented super calls and proper dispatch of scripted virtual overrides for Destroy.
2016-11-11 20:52:08 +00:00
if (Self->ExprType == EFX_Super)
{
- no more simplify in state parameters. - resolving constants with the backend requires a few more error checks.
2017-01-22 22:53:50 +00:00
if (ctx.Function == nullptr)
{
ScriptPosition.Message(MSG_ERROR, "Unable to call %s from constant declaration", MethodName.GetChars());
delete this;
return nullptr;
}
- allow functions in structs. This is needed for several internal data types like players, sectors, lines, etc. - added a new type 'NativeStruct'. This will be used for types that cannot be instantiated, and is also needed to cleanly handle many internal types that only can exist as reference.
2016-11-19 11:12:29 +00:00
auto clstype = dyn_cast<PClass>(ctx.Function->Variants[0].SelfClass);
if (clstype != nullptr)
{
// give the node the proper value type now that we know it's properly used.
cls = clstype->ParentClass;
Self->ValueType = NewPointer(cls);
Self->ExprType = EFX_Self;
novirtual = true; // super calls are always non-virtual
}
else
{
ScriptPosition.Message(MSG_ERROR, "Super requires a class type");
}
- implemented super calls and proper dispatch of scripted virtual overrides for Destroy.
2016-11-11 20:52:08 +00:00
}
- scriptified the Flechette. Not fully tested yet. - fixed issues with the refactoring of the recent commits. This one starts again. - added builtins for TextureID. Note about builtins: Currently they are just hacked into the compiler backend. They really should be made part of the respective types to keep matters clean and allow more widespread use of builtins to create more efficient code.
2016-11-27 11:52:54 +00:00
// Note: These builtins would better be relegated to the actual type objects, instead of polluting this file, but that's a task for later.
// Texture builtins.
- added a TStaticArray class that allows safe access to resizable static data (like the sectors, linedefs, etc.) for the VM. - used this to replace the line list in Sector because that gets already used and implemented proper bounds checks for this type of array.
2017-01-02 20:40:52 +00:00
else if (Self->ValueType == TypeTextureID)
- scriptified the Flechette. Not fully tested yet. - fixed issues with the refactoring of the recent commits. This one starts again. - added builtins for TextureID. Note about builtins: Currently they are just hacked into the compiler backend. They really should be made part of the respective types to keep matters clean and allow more widespread use of builtins to create more efficient code.
2016-11-27 11:52:54 +00:00
{
if (MethodName == NAME_IsValid || MethodName == NAME_IsNull || MethodName == NAME_Exists || MethodName == NAME_SetInvalid || MethodName == NAME_SetNull)
{
if (ArgList.Size() > 0)
{
ScriptPosition.Message(MSG_ERROR, "too many parameters in call to %s", MethodName.GetChars());
delete this;
return nullptr;
}
// No need to create a dedicated node here, all builtins map directly to trivial operations.
Self->ValueType = TypeSInt32; // all builtins treat the texture index as integer.
FxExpression *x;
switch (MethodName)
{
case NAME_IsValid:
x = new FxCompareRel('>', Self, new FxConstant(0, ScriptPosition));
break;
case NAME_IsNull:
x = new FxCompareEq(TK_Eq, Self, new FxConstant(0, ScriptPosition));
break;
case NAME_Exists:
x = new FxCompareRel(TK_Geq, Self, new FxConstant(0, ScriptPosition));
break;
case NAME_SetInvalid:
x = new FxAssign(Self, new FxConstant(-1, ScriptPosition));
break;
case NAME_SetNull:
x = new FxAssign(Self, new FxConstant(0, ScriptPosition));
break;
}
Self = nullptr;
SAFE_RESOLVE(x, ctx);
if (MethodName == NAME_SetInvalid || MethodName == NAME_SetNull) x->ValueType = TypeVoid; // override the default type of the assignment operator.
delete this;
return x;
}
}
- added a TStaticArray class that allows safe access to resizable static data (like the sectors, linedefs, etc.) for the VM. - used this to replace the line list in Sector because that gets already used and implemented proper bounds checks for this type of array.
2017-01-02 20:40:52 +00:00
else if (Self->IsVector())
- added vector builtins Length() and Unit(). This should complete the vector type except for use as function parameter.
2016-10-29 08:43:22 +00:00
{
// handle builtins: Vectors got 2: Length and Unit.
if (MethodName == NAME_Length || MethodName == NAME_Unit)
{
- scriptified Heretic's blaster. - scriptified all Effect functions of Fastprojectile's children - implemented access to class meta data. - added a VM instruction to retrieve the class metadata, to eliminate the overhead of the function call that would otherwise be needed. - made GetClass() a builtin so that it can use the new instruction Important note about this commit: Scriptifying CFlameMissile::Effect revealed a problem with the virtual function interface: In order to work, this needs to be explicitly enabled for each single native class that may be used as a base for a scripted class. Needless to say, this will end up way too much work, as there are over 100 native classes, excluding those which will be scriptified. But in order to fix the problem this partially broken state needs to be committed first.
2016-11-24 19:02:44 +00:00
if (ArgList.Size() > 0)
{
ScriptPosition.Message(MSG_ERROR, "too many parameters in call to %s", MethodName.GetChars());
delete this;
return nullptr;
}
- added vector builtins Length() and Unit(). This should complete the vector type except for use as function parameter.
2016-10-29 08:43:22 +00:00
auto x = new FxVectorBuiltin(Self, MethodName);
Self = nullptr;
delete this;
return x->Resolve(ctx);
}
}
- added a TStaticArray class that allows safe access to resizable static data (like the sectors, linedefs, etc.) for the VM. - used this to replace the line list in Sector because that gets already used and implemented proper bounds checks for this type of array.
2017-01-02 20:40:52 +00:00
else if (Self->ValueType == TypeString)
- scriptified Strife's coins. - added a String class to allow attaching methods to the builtin string type. This works by checking if the left side of the member accessor is a string and just replacing the tyoe in this one place, all the rest is automatic.
2016-11-28 17:15:18 +00:00
{
- scriptified the health items.
2017-01-15 00:02:38 +00:00
if (MethodName == NAME_Length) // This is an intrinsic because a dedicated opcode exists for it.
{
auto x = new FxStrLen(Self);
Self = nullptr;
delete this;
return x->Resolve(ctx);
}
- scriptified Strife's coins. - added a String class to allow attaching methods to the builtin string type. This works by checking if the left side of the member accessor is a string and just replacing the tyoe in this one place, all the rest is automatic.
2016-11-28 17:15:18 +00:00
// same for String methods. It also uses a hidden struct type to define them.
Self->ValueType = TypeStringStruct;
}
- added a TStaticArray class that allows safe access to resizable static data (like the sectors, linedefs, etc.) for the VM. - used this to replace the line list in Sector because that gets already used and implemented proper bounds checks for this type of array.
2017-01-02 20:40:52 +00:00
else if (Self->IsArray())
{
if (MethodName == NAME_Size)
{
if (ArgList.Size() > 0)
{
ScriptPosition.Message(MSG_ERROR, "too many parameters in call to %s", MethodName.GetChars());
delete this;
return nullptr;
}
if (!Self->IsResizableArray())
{
auto atype = Self->ValueType;
if (Self->ValueType->IsKindOf(RUNTIME_CLASS(PPointer))) atype = static_cast<PPointer*>(ValueType)->PointedType;
auto size = static_cast<PArray*>(atype)->ElementCount;
auto x = new FxConstant(size, ScriptPosition);
delete this;
return x;
}
else
{
// Resizable arrays can only be defined in C code and they can only exist in pointer form to reduce their impact on the code generator.
if (Self->ExprType == EFX_StructMember || Self->ExprType == EFX_ClassMember)
{
auto member = static_cast<FxStructMember*>(Self);
auto newfield = new PField(NAME_None, TypeUInt32, VARF_ReadOnly, member->membervar->Offset + member->membervar->Type->Align); // the size is stored right behind the pointer.
member->membervar = newfield;
Self = nullptr;
delete this;
member->ValueType = TypeUInt32;
return member;
}
else if (Self->ExprType == EFX_GlobalVariable)
{
auto member = static_cast<FxGlobalVariable*>(Self);
auto newfield = new PField(NAME_None, TypeUInt32, VARF_ReadOnly, member->membervar->Offset + member->membervar->Type->Align); // the size is stored right behind the pointer.
member->membervar = newfield;
Self = nullptr;
delete this;
member->ValueType = TypeUInt32;
return member;
}
else
{
// This should never happen because resizable arrays cannot be defined in scripts.
ScriptPosition.Message(MSG_ERROR, "Cannot retrieve size of array");
delete this;
return nullptr;
}
}
}
}
- scriptified Strife's coins. - added a String class to allow attaching methods to the builtin string type. This works by checking if the left side of the member accessor is a string and just replacing the tyoe in this one place, all the rest is automatic.
2016-11-28 17:15:18 +00:00
- scriptified the backpack. - added GetParentClass builtin to compiler.
2017-01-14 22:34:47 +00:00
if (MethodName == NAME_GetParentClass &&
(Self->IsObject() || Self->ValueType->IsKindOf(RUNTIME_CLASS(PClassPointer))))
{
if (ArgList.Size() > 0)
{
ScriptPosition.Message(MSG_ERROR, "too many parameters in call to %s", MethodName.GetChars());
delete this;
return nullptr;
}
auto x = new FxGetParentClass(Self);
return x->Resolve(ctx);
}
- 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
if (Self->ValueType->IsKindOf(RUNTIME_CLASS(PPointer)))
- added the required code genration nodes for member function calls. This is not testable right now because finally the action function mess has come full circle. The current setup makes it impossible to call action functions from non-action functions because the needed info is local to the functions. Long avoided, this needs to be refactored now so that the different semantics for action functions are no longer needed.
2016-10-22 10:10:19 +00:00
{
auto ptype = static_cast<PPointer *>(Self->ValueType)->PointedType;
- scriptified the pistol to test if struct member functions work. - made APlayerPawn::PlayAttacking(2) virtual script functions so that mods have better control over player animations. Note that these have no native base so they skip the templated interface for managing virtual functions.
2016-11-19 12:56:29 +00:00
if (ptype->IsKindOf(RUNTIME_CLASS(PStruct)))
- added the required code genration nodes for member function calls. This is not testable right now because finally the action function mess has come full circle. The current setup makes it impossible to call action functions from non-action functions because the needed info is local to the functions. Long avoided, this needs to be refactored now so that the different semantics for action functions are no longer needed.
2016-10-22 10:10:19 +00:00
{
- scriptified Heretic's blaster. - scriptified all Effect functions of Fastprojectile's children - implemented access to class meta data. - added a VM instruction to retrieve the class metadata, to eliminate the overhead of the function call that would otherwise be needed. - made GetClass() a builtin so that it can use the new instruction Important note about this commit: Scriptifying CFlameMissile::Effect revealed a problem with the virtual function interface: In order to work, this needs to be explicitly enabled for each single native class that may be used as a base for a scripted class. Needless to say, this will end up way too much work, as there are over 100 native classes, excluding those which will be scriptified. But in order to fix the problem this partially broken state needs to be committed first.
2016-11-24 19:02:44 +00:00
if (ptype->IsKindOf(RUNTIME_CLASS(PClass)) && MethodName == NAME_GetClass)
{
if (ArgList.Size() > 0)
{
ScriptPosition.Message(MSG_ERROR, "too many parameters in call to %s", MethodName.GetChars());
delete this;
return nullptr;
}
auto x = new FxGetClass(Self);
return x->Resolve(ctx);
}
- scriptified the backpack. - added GetParentClass builtin to compiler.
2017-01-14 22:34:47 +00:00
- scriptified the pistol to test if struct member functions work. - made APlayerPawn::PlayAttacking(2) virtual script functions so that mods have better control over player animations. Note that these have no native base so they skip the templated interface for managing virtual functions.
2016-11-19 12:56:29 +00:00
cls = static_cast<PStruct *>(ptype);
- added the required code genration nodes for member function calls. This is not testable right now because finally the action function mess has come full circle. The current setup makes it impossible to call action functions from non-action functions because the needed info is local to the functions. Long avoided, this needs to be refactored now so that the different semantics for action functions are no longer needed.
2016-10-22 10:10:19 +00:00
}
else
{
ScriptPosition.Message(MSG_ERROR, "Left hand side of %s must point to a class object\n", MethodName.GetChars());
delete this;
return nullptr;
}
}
- scriptified the remaining Doom weapon code. - implemented method calls from struct instances. - optimized disassembly of VM call instructions to print the function's name at the end where it is more visible and does not need to be truncated. Also use the printable name for script functions here.
2016-11-20 11:27:26 +00:00
else if (Self->ValueType->IsKindOf(RUNTIME_CLASS(PStruct)))
{
bool writable;
if (Self->RequestAddress(ctx, &writable) && writable)
{
cls = static_cast<PStruct*>(Self->ValueType);
Self->ValueType = NewPointer(Self->ValueType);
}
else
{
// Cannot be made writable so we cannot use its methods.
ScriptPosition.Message(MSG_ERROR, "Invalid expression on left hand side of %s\n", MethodName.GetChars());
delete this;
return nullptr;
}
}
- added the required code genration nodes for member function calls. This is not testable right now because finally the action function mess has come full circle. The current setup makes it impossible to call action functions from non-action functions because the needed info is local to the functions. Long avoided, this needs to be refactored now so that the different semantics for action functions are no longer needed.
2016-10-22 10:10:19 +00:00
else
{
ScriptPosition.Message(MSG_ERROR, "Invalid expression on left hand side of %s\n", MethodName.GetChars());
delete this;
return nullptr;
}
- scriptified the pistol to test if struct member functions work. - made APlayerPawn::PlayAttacking(2) virtual script functions so that mods have better control over player animations. Note that these have no native base so they skip the templated interface for managing virtual functions.
2016-11-19 12:56:29 +00:00
// Todo: handle member calls from instantiated structs.
- 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
isresolved:
- added the required code genration nodes for member function calls. This is not testable right now because finally the action function mess has come full circle. The current setup makes it impossible to call action functions from non-action functions because the needed info is local to the functions. Long avoided, this needs to be refactored now so that the different semantics for action functions are no longer needed.
2016-10-22 10:10:19 +00:00
bool error = false;
- fixed: All functions that are callable from weapon states and not members of Actor need to be declared 'action'. With the stricter type checks of the self pointer that were now implemented these all produced errors.
2016-11-13 13:20:30 +00:00
PFunction *afd = FindClassMemberFunction(cls, ctx.Class, MethodName, ScriptPosition, &error);
- added the required code genration nodes for member function calls. This is not testable right now because finally the action function mess has come full circle. The current setup makes it impossible to call action functions from non-action functions because the needed info is local to the functions. Long avoided, this needs to be refactored now so that the different semantics for action functions are no longer needed.
2016-10-22 10:10:19 +00:00
if (error)
{
delete this;
return nullptr;
}
if (afd == nullptr)
{
ScriptPosition.Message(MSG_ERROR, "Unknown function %s\n", MethodName.GetChars());
delete this;
return nullptr;
}
- implemented usage restrictions for action functions.
2016-11-15 20:38:12 +00:00
- 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
if (staticonly && (afd->Variants[0].Flags & VARF_Method))
- added the required code genration nodes for member function calls. This is not testable right now because finally the action function mess has come full circle. The current setup makes it impossible to call action functions from non-action functions because the needed info is local to the functions. Long avoided, this needs to be refactored now so that the different semantics for action functions are no longer needed.
2016-10-22 10:10:19 +00:00
{
- scriptified PowerLightAmp and PowerTorch. - allow calling qualified super methods so skipping some levels is possible.
2017-01-15 23:46:15 +00:00
if (!novirtual || !(afd->Variants[0].Flags & VARF_Virtual))
- 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
{
- scriptified PowerLightAmp and PowerTorch. - allow calling qualified super methods so skipping some levels is possible.
2017-01-15 23:46:15 +00:00
auto clstype = dyn_cast<PClass>(ctx.Class);
auto ccls = dyn_cast<PClass>(cls);
if (clstype == nullptr || ccls == nullptr || !clstype->IsDescendantOf(ccls))
{
ScriptPosition.Message(MSG_ERROR, "Cannot call non-static function %s::%s from here\n", cls->TypeName.GetChars(), MethodName.GetChars());
delete this;
return nullptr;
}
else
{
// Todo: If this is a qualified call to a parent class function, let it through (but this needs to disable virtual calls later.)
ScriptPosition.Message(MSG_ERROR, "Qualified member call to parent class %s::%s is not yet implemented\n", cls->TypeName.GetChars(), MethodName.GetChars());
delete this;
return nullptr;
}
- 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
}
- added the required code genration nodes for member function calls. This is not testable right now because finally the action function mess has come full circle. The current setup makes it impossible to call action functions from non-action functions because the needed info is local to the functions. Long avoided, this needs to be refactored now so that the different semantics for action functions are no longer needed.
2016-10-22 10:10:19 +00:00
}
- implemented usage restrictions for action functions.
2016-11-15 20:38:12 +00:00
if (afd->Variants[0].Flags & VARF_Method)
{
- no more simplify in state parameters. - resolving constants with the backend requires a few more error checks.
2017-01-22 22:53:50 +00:00
if (ctx.Function == nullptr)
{
ScriptPosition.Message(MSG_ERROR, "Unable to call %s from constant declaration", MethodName.GetChars());
delete this;
return nullptr;
}
- implemented usage restrictions for action functions.
2016-11-15 20:38:12 +00:00
if (Self->ExprType == EFX_Self)
{
if (!CheckFunctionCompatiblity(ScriptPosition, ctx.Function, afd))
{
delete this;
return nullptr;
}
}
else
{
// Functions with no Actor usage may not be called through a pointer because they will lose their context.
if (!(afd->Variants[0].UseFlags & SUF_ACTOR))
{
ScriptPosition.Message(MSG_ERROR, "Function %s cannot be used with a non-self object\n", afd->SymbolName.GetChars());
delete this;
return nullptr;
}
}
}
- added the required code genration nodes for member function calls. This is not testable right now because finally the action function mess has come full circle. The current setup makes it impossible to call action functions from non-action functions because the needed info is local to the functions. Long avoided, this needs to be refactored now so that the different semantics for action functions are no longer needed.
2016-10-22 10:10:19 +00:00
// do not pass the self pointer to static functions.
- 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
auto self = (afd->Variants[0].Flags & VARF_Method) ? Self : nullptr;
- implemented super calls and proper dispatch of scripted virtual overrides for Destroy.
2016-11-11 20:52:08 +00:00
auto x = new FxVMFunctionCall(self, afd, ArgList, ScriptPosition, staticonly|novirtual);
- fixed a conversion warning with the pointer-type AActor fields. - added master and tracer to the list of exported variables. - fixed: 'none' as class type must map to the real null pointer so that it won't get rejected by the stricter type checks. - added handling for member function calls to zcc_compile.cpp. - fixed: FxMemberFunctionCall may not delete the self expression if it gets passed on to the actual function call.
2016-10-22 17:43:53 +00:00
if (Self == self) Self = nullptr;
- added the required code genration nodes for member function calls. This is not testable right now because finally the action function mess has come full circle. The current setup makes it impossible to call action functions from non-action functions because the needed info is local to the functions. Long avoided, this needs to be refactored now so that the different semantics for action functions are no longer needed.
2016-10-22 10:10:19 +00:00
delete this;
return x->Resolve(ctx);
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// FxActionSpecialCall
//
// If special is negative, then the first argument will be treated as a
// name for ACS_NamedExecuteWithResult.
//
//==========================================================================
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
FxActionSpecialCall::FxActionSpecialCall(FxExpression *self, int special, FArgumentList &args, const FScriptPosition &pos)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_ActionSpecialCall, pos)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
Self = self;
Special = special;
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
ArgList = std::move(args);
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
EmitTail = false;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
//
//
//==========================================================================
FxActionSpecialCall::~FxActionSpecialCall()
{
SAFE_DELETE(Self);
}
//==========================================================================
//
//
//
//==========================================================================
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
PPrototype *FxActionSpecialCall::ReturnProto()
{
EmitTail = true;
return FxExpression::ReturnProto();
}
//==========================================================================
//
//
//
//==========================================================================
Normalize line endings
2016-03-01 15:47:10 +00:00
FxExpression *FxActionSpecialCall::Resolve(FCompileContext& ctx)
{
CHECKRESOLVED();
bool failed = false;
- added FindClassMemberFunction which retrieves a function symbol and performs some verification. - removed Self parameter from FxFunctionCall. Actual member function calls through an object require quite different handling so lumping these two together makes no sense. - added a workaround to deal with ACS_NamedExecuteWithResult to both the compiler and FindClassMemberFunction. The way the ZScript compiler sets this up means that it will call the builtin, not the actual action function, so the parser needs to do some explicit check to get past the same-named action function. - pass a proper self pointer to FxActionSpecial. Although it's still not being used, propagating design shortcuts through several function levels is a very, very bad idea.
2016-10-15 18:16:44 +00:00
SAFE_RESOLVE_OPT(Self, ctx);
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
for (unsigned i = 0; i < ArgList.Size(); i++)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
ArgList[i] = ArgList[i]->Resolve(ctx);
if (ArgList[i] == nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
failed = true;
}
else if (Special < 0 && i == 0)
{
if (ArgList[i]->ValueType == TypeString)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
ArgList[i] = new FxNameCast(ArgList[i]);
ArgList[i] = ArgList[i]->Resolve(ctx);
if (ArgList[i] == nullptr)
- fixed: The first argument of string-based ACS specials was missing a string to name cast.
2016-11-08 21:36:44 +00:00
{
Normalize line endings
2016-03-01 15:47:10 +00:00
failed = true;
}
}
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
else if (ArgList[i]->ValueType != TypeName)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
ScriptPosition.Message(MSG_ERROR, "Name expected for parameter %d", i);
failed = true;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
else if (!ArgList[i]->IsInteger())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
if (ArgList[i]->ValueType->GetRegType() == REGT_FLOAT /* lax */)
{
ArgList[i] = new FxIntCast(ArgList[i], ctx.FromDecorate);
}
else
{
ScriptPosition.Message(MSG_ERROR, "Integer expected for parameter %d", i);
failed = true;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
if (failed)
{
delete this;
return nullptr;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
ValueType = TypeSInt32;
return this;
}
//==========================================================================
//
//
//
//==========================================================================
- allow the VM to run on one global stack per thread. It is utterly pointless to require every function that wants to make a VM call to allocate a new stack first. The allocation overhead doubles the time to set up the call. With one stack, previously allocated memory can be reused. The only important thing is, if this ever gets used in a multithreaded environment to have the stack being declared as thread_local, although for ZDoom this is of no consequence. - eliminated all cases where native code was calling other native code through the VM interface. After scriptifying the game code, only 5 places were left which were quickly eliminated. This was mostly to ensure that the native VM function parameters do not need to be propagated further than absolutely necessary.
2016-11-30 16:15:01 +00:00
int BuiltinCallLineSpecial(VMValue *param, TArray<VMValue> &defaultparam, int numparam, VMReturn *ret, int numret)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- fixed: CallStateChain must never allow a jumping function to set the chain's overall result to successful.
2016-03-04 14:11:20 +00:00
assert(numparam > 2 && numparam < 8);
Normalize line endings
2016-03-01 15:47:10 +00:00
assert(param[0].Type == REGT_INT);
assert(param[1].Type == REGT_POINTER);
int v[5] = { 0 };
for (int i = 2; i < numparam; ++i)
{
v[i - 2] = param[i].i;
}
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
ACTION_RETURN_INT(P_ExecuteSpecial(param[0].i, nullptr, reinterpret_cast<AActor*>(param[1].a), false, v[0], v[1], v[2], v[3], v[4]));
Normalize line endings
2016-03-01 15:47:10 +00:00
}
ExpEmit FxActionSpecialCall::Emit(VMFunctionBuilder *build)
{
unsigned i = 0;
build->Emit(OP_PARAMI, abs(Special)); // pass special number
- pass a proper self pointer to BuiltinCallActionSpecial instead of making bogus assumptions about a function's parameters.
2016-12-11 20:32:19 +00:00
ExpEmit selfemit(Self->Emit(build));
build->Emit(OP_PARAM, 0, selfemit.Konst ? REGT_POINTER | REGT_KONST : REGT_POINTER, selfemit.RegNum); // pass special number
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
for (; i < ArgList.Size(); ++i)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
FxExpression *argex = ArgList[i];
if (Special < 0 && i == 0)
{
assert(argex->ValueType == TypeName);
assert(argex->isConstant());
build->EmitParamInt(-static_cast<FxConstant *>(argex)->GetValue().GetName());
}
else
Normalize line endings
2016-03-01 15:47:10 +00:00
{
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
assert(argex->ValueType->GetRegType() == REGT_INT);
if (argex->isConstant())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
build->EmitParamInt(static_cast<FxConstant *>(argex)->GetValue().GetInt());
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
ExpEmit arg(argex->Emit(build));
build->Emit(OP_PARAM, 0, arg.RegType, arg.RegNum);
arg.Free(build);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
}
- implemented the 'is' operator (i.e. class type check.)
2016-10-29 23:05:56 +00:00
// Call the BuiltinCallLineSpecial function to perform the desired special.
Normalize line endings
2016-03-01 15:47:10 +00:00
VMFunction *callfunc;
- implemented the 'is' operator (i.e. class type check.)
2016-10-29 23:05:56 +00:00
PSymbol *sym = FindBuiltinFunction(NAME_BuiltinCallLineSpecial, BuiltinCallLineSpecial);
Normalize line endings
2016-03-01 15:47:10 +00:00
assert(sym->IsKindOf(RUNTIME_CLASS(PSymbolVMFunction)));
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
assert(((PSymbolVMFunction *)sym)->Function != nullptr);
Normalize line endings
2016-03-01 15:47:10 +00:00
callfunc = ((PSymbolVMFunction *)sym)->Function;
- allow defining native fields through scripts. Internally this only requires exporting the address, but not the entire field. - added new VARF_Transient flag so that the decision whether to serialize a field does not depend solely on its native status. It may actually make a lot of sense to use the auto-serializer for native fields, too, as this would eliminate a lot of maintenance code. - defined (u)int8/16 as aliases to the byte and short types (Can't we not just get rid of this naming convention already...?) - exporting the fields of Actor revealed a few name clashes between them and some global types, so Actor.Sector was renamed to CurSector and Actor.Inventory was renamed to Actor.Inv.
2016-11-22 18:20:31 +00:00
ArgList.DeleteAndClear();
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
ArgList.ShrinkToFit();
Normalize line endings
2016-03-01 15:47:10 +00:00
- added the ability to attach a constructor or destructor to an internally defined struct. There are a few which require explicit native construction or destruction that need to be exported to the VM, e.g. FCheckPosition. The VM cannot handle this directly, it needs two special functions to be attached to handle such elements.
2017-01-11 22:46:03 +00:00
if (build->FramePointer.Fixed) EmitTail = false; // do not tail call if the stack is in use
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
if (EmitTail)
{
build->Emit(OP_TAIL_K, build->GetConstantAddress(callfunc, ATAG_OBJECT), 2 + i, 0);
ExpEmit call;
call.Final = true;
return call;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
ExpEmit dest(build, REGT_INT);
build->Emit(OP_CALL_K, build->GetConstantAddress(callfunc, ATAG_OBJECT), 2 + i, 1);
build->Emit(OP_RESULT, 0, REGT_INT, dest.RegNum);
return dest;
}
//==========================================================================
//
// FxVMFunctionCall
//
//==========================================================================
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
FxVMFunctionCall::FxVMFunctionCall(FxExpression *self, PFunction *func, FArgumentList &args, const FScriptPosition &pos, bool novirtual)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_VMFunctionCall, pos)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- added the required code genration nodes for member function calls. This is not testable right now because finally the action function mess has come full circle. The current setup makes it impossible to call action functions from non-action functions because the needed info is local to the functions. Long avoided, this needs to be refactored now so that the different semantics for action functions are no longer needed.
2016-10-22 10:10:19 +00:00
Self = self;
Normalize line endings
2016-03-01 15:47:10 +00:00
Function = func;
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
ArgList = std::move(args);
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
EmitTail = false;
- added the required code genration nodes for member function calls. This is not testable right now because finally the action function mess has come full circle. The current setup makes it impossible to call action functions from non-action functions because the needed info is local to the functions. Long avoided, this needs to be refactored now so that the different semantics for action functions are no longer needed.
2016-10-22 10:10:19 +00:00
NoVirtual = novirtual;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
//
//
//==========================================================================
FxVMFunctionCall::~FxVMFunctionCall()
{
}
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
//==========================================================================
//
//
//
//==========================================================================
PPrototype *FxVMFunctionCall::ReturnProto()
{
EmitTail = true;
- more preparations to compile functions: * Allow PFunction to work without a VMFunction being attached. * The Variant for a function must store the prototype itself instead of relying on the VMFunction it points to. Otherwise it would not be possible to reference a prototype during compilation of the function because it does not exist yet. * Give the variant a list of the function's argument's names, because these are also needed to compile the function. * create an anonymous function symbol when the function gets registered to the builder. At this point we have all the needed information to set it up correctly, but later this is no longer the case. This is the most convenient info to have here because it contains everything that's needed to compile the function in the proper context, so it has to be present when starting compilation. * added some preparations to implement special handling for weapons and custom inventory items, which can run action functions in another actor's context. This part is not active yet but the basics are present in SetImplicitArgs.
2016-10-15 12:36:08 +00:00
return Function->Variants[0].Proto;
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
}
//==========================================================================
//
//
//
//==========================================================================
VMFunction *FxVMFunctionCall::GetDirectFunction()
{
- allow calling non-action functions directly from a state. Ironically this only requires a very minor change in the calling code and an added member for the VMFunction to tell that code how many parameters to pass. This change will allow to turn the vast majority of action functions into regular members, the only ones that still need to be an action function are the few that actually use the pointers.
2016-10-22 14:35:48 +00:00
// If this return statement calls a non-virtual function with no arguments,
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
// then it can be a "direct" function. That is, the DECORATE
// definition can call that function directly without wrapping
// it inside VM code.
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
if (ArgList.Size() == 0 && !(Function->Variants[0].Flags & VARF_Virtual))
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
{
- fixed: FxVMFunctionCall::GetDirectFunction did not check if the function could be called with no arguments.
2016-11-19 11:22:58 +00:00
unsigned imp = Function->GetImplicitArgs();
- scriptified the pistol to test if struct member functions work. - made APlayerPawn::PlayAttacking(2) virtual script functions so that mods have better control over player animations. Note that these have no native base so they skip the templated interface for managing virtual functions.
2016-11-19 12:56:29 +00:00
if (Function->Variants[0].ArgFlags.Size() > imp && !(Function->Variants[0].ArgFlags[imp] & VARF_Optional)) return nullptr;
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
return Function->Variants[0].Implementation;
}
return nullptr;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// FxVMFunctionCall :: Resolve
//
//==========================================================================
FxExpression *FxVMFunctionCall::Resolve(FCompileContext& ctx)
{
CHECKRESOLVED();
- added the required code genration nodes for member function calls. This is not testable right now because finally the action function mess has come full circle. The current setup makes it impossible to call action functions from non-action functions because the needed info is local to the functions. Long avoided, this needs to be refactored now so that the different semantics for action functions are no longer needed.
2016-10-22 10:10:19 +00:00
SAFE_RESOLVE_OPT(Self, ctx);
Normalize line endings
2016-03-01 15:47:10 +00:00
bool failed = false;
- 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
auto proto = Function->Variants[0].Proto;
- implemented pass-by-reference arguments - so far only for memory based variables. - changed Dehacked weapon function lookup to check the symbol table instead of directly referencing the VM functions. Once scriptified these pointers will no longer be available. - removed all special ATAGs from the VM. While well intentioned any pointer tagged with them is basically unusable because it'd trigger asserts all over the place. - scriptified A_Punch for testing pass-by-reference parameters and stack variables.
2016-11-19 00:23:56 +00:00
auto &argtypes = proto->ArgumentTypes;
- implemented named arguments. - fixed flag CVAR access. As it turned out, OP_LBIT is a bit messy to set up properly when accessing integers that may or may not be big endian, so it now uses a shift and bit masking to do its work. - used the SpawnPlayerMissile call in A_FireBFG to test named arguments.
2016-11-21 00:32:01 +00:00
auto &argnames = Function->Variants[0].ArgNames;
- implemented pass-by-reference arguments - so far only for memory based variables. - changed Dehacked weapon function lookup to check the symbol table instead of directly referencing the VM functions. Once scriptified these pointers will no longer be available. - removed all special ATAGs from the VM. While well intentioned any pointer tagged with them is basically unusable because it'd trigger asserts all over the place. - scriptified A_Punch for testing pass-by-reference parameters and stack variables.
2016-11-19 00:23:56 +00:00
auto &argflags = Function->Variants[0].ArgFlags;
- implemented named arguments. - fixed flag CVAR access. As it turned out, OP_LBIT is a bit messy to set up properly when accessing integers that may or may not be big endian, so it now uses a shift and bit masking to do its work. - used the SpawnPlayerMissile call in A_FireBFG to test named arguments.
2016-11-21 00:32:01 +00:00
auto &defaults = Function->Variants[0].Implementation->DefaultArgs;
- Added some fudging so that A_PlayerSkinCheck creates proper code until I can rewrite the FunctionCall expression to match what the script compiler needs. The current version of this class is too much geared toward DECORATE.
2016-10-14 19:15:46 +00:00
- allow calling non-action functions directly from a state. Ironically this only requires a very minor change in the calling code and an added member for the VMFunction to tell that code how many parameters to pass. This change will allow to turn the vast majority of action functions into regular members, the only ones that still need to be an action function are the few that actually use the pointers.
2016-10-22 14:35:48 +00:00
int implicit = Function->GetImplicitArgs();
Normalize line endings
2016-03-01 15:47:10 +00:00
- added the required code genration nodes for member function calls. This is not testable right now because finally the action function mess has come full circle. The current setup makes it impossible to call action functions from non-action functions because the needed info is local to the functions. Long avoided, this needs to be refactored now so that the different semantics for action functions are no longer needed.
2016-10-22 10:10:19 +00:00
// This should never happen.
- 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
if (Self == nullptr && (Function->Variants[0].Flags & VARF_Method))
- added the required code genration nodes for member function calls. This is not testable right now because finally the action function mess has come full circle. The current setup makes it impossible to call action functions from non-action functions because the needed info is local to the functions. Long avoided, this needs to be refactored now so that the different semantics for action functions are no longer needed.
2016-10-22 10:10:19 +00:00
{
ScriptPosition.Message(MSG_ERROR, "Call to non-static function without a self pointer");
delete this;
return nullptr;
}
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
if (ArgList.Size() > 0)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
-fixed type handling for varargs (i.e. A_Jump.)
2016-10-26 12:15:11 +00:00
bool foundvarargs = false;
PType * type = nullptr;
- fixed: For varargs, not only the type but also the flag of the last specified argument need to be stored for later parameters.
2016-11-20 08:47:46 +00:00
int flag = 0;
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
if (argtypes.Last() != nullptr && ArgList.Size() + implicit > argtypes.Size())
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
{
ScriptPosition.Message(MSG_ERROR, "Too many arguments in call to %s", Function->SymbolName.GetChars());
delete this;
return nullptr;
}
- implemented passing vectors as parameters. So far working for native functions. - removed the bogus optional value from the first A_Jump argument. A quick test with an older ZDoom revealed that this was never working - and implementing it would make things a lot more complicated, especially error checking in the code generator. - fixed: The check for insufficient parameters to a function call was missing.
2016-10-29 11:10:27 +00:00
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
for (unsigned i = 0; i < ArgList.Size(); i++)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
-fixed type handling for varargs (i.e. A_Jump.)
2016-10-26 12:15:11 +00:00
// Varargs must all have the same type as the last typed argument. A_Jump is the only function using it.
Implemented static methods in String struct. Implemented String.Format and String.AppendFormat. Implemented native vararg methods for the future.
2017-01-21 00:07:44 +00:00
// [ZZ] Varargs MAY have arbitrary types if the method is marked vararg.
-fixed type handling for varargs (i.e. A_Jump.)
2016-10-26 12:15:11 +00:00
if (!foundvarargs)
{
if (argtypes[i + implicit] == nullptr) foundvarargs = true;
- fixed: For varargs, not only the type but also the flag of the last specified argument need to be stored for later parameters.
2016-11-20 08:47:46 +00:00
else
{
type = argtypes[i + implicit];
flag = argflags[i + implicit];
}
-fixed type handling for varargs (i.e. A_Jump.)
2016-10-26 12:15:11 +00:00
}
assert(type != nullptr);
- implemented named arguments. - fixed flag CVAR access. As it turned out, OP_LBIT is a bit messy to set up properly when accessing integers that may or may not be big endian, so it now uses a shift and bit masking to do its work. - used the SpawnPlayerMissile call in A_FireBFG to test named arguments.
2016-11-21 00:32:01 +00:00
if (ArgList[i]->ExprType == EFX_NamedNode)
{
if (!(flag & VARF_Optional))
{
ScriptPosition.Message(MSG_ERROR, "Cannot use a named argument here - not all required arguments have been passed.");
delete this;
return nullptr;
}
if (foundvarargs)
{
ScriptPosition.Message(MSG_ERROR, "Cannot use a named argument in the varargs part of the parameter list.");
delete this;
return nullptr;
}
unsigned j;
bool done = false;
FName name = static_cast<FxNamedNode *>(ArgList[i])->name;
for (j = 0; j < argnames.Size() - implicit; j++)
{
if (argnames[j + implicit] == name)
{
if (j < i)
{
ScriptPosition.Message(MSG_ERROR, "Named argument %s comes before current position in argument list.", name.GetChars());
delete this;
return nullptr;
}
// copy the original argument into the list
auto old = static_cast<FxNamedNode *>(ArgList[i]);
ArgList[i] = old->value;
old->value = nullptr;
delete old;
// now fill the gap with constants created from the default list so that we got a full list of arguments.
int insert = j - i;
for (int k = 0; k < insert; k++)
{
auto ntype = argtypes[i + k + implicit];
// If this is a reference argument, the pointer type must be undone because the code below expects the pointed type as value type.
if (argflags[i + k + implicit] & VARF_Ref)
{
assert(ntype->IsKindOf(RUNTIME_CLASS(PPointer)));
ntype = TypeNullPtr; // the default of a reference type can only be a null pointer
}
auto x = new FxConstant(ntype, defaults[i + k + implicit], ScriptPosition);
ArgList.Insert(i + k, x);
}
done = true;
break;
}
}
if (!done)
{
ScriptPosition.Message(MSG_ERROR, "Named argument %s not found.", name.GetChars());
delete this;
return nullptr;
}
// re-get the proper info for the inserted node.
type = argtypes[i + implicit];
flag = argflags[i + implicit];
}
- fix uninitialized variable.
2017-01-21 10:46:23 +00:00
FxExpression *x = nullptr;
Implemented static methods in String struct. Implemented String.Format and String.AppendFormat. Implemented native vararg methods for the future.
2017-01-21 00:07:44 +00:00
if (foundvarargs && (Function->Variants[0].Flags & VARF_VarArg))
{
// only cast implicit-string types for vararg, leave everything else as-is
// this was outright copypasted from FxFormat
Fixed: compile-time error in vararg function call would result in a crash.
2017-01-27 23:12:42 +00:00
x = ArgList[i]->Resolve(ctx);
if (x)
Implemented static methods in String struct. Implemented String.Format and String.AppendFormat. Implemented native vararg methods for the future.
2017-01-21 00:07:44 +00:00
{
Fixed: compile-time error in vararg function call would result in a crash.
2017-01-27 23:12:42 +00:00
if (x->ValueType == TypeName ||
x->ValueType == TypeSound)
{
x = new FxStringCast(ArgList[i]);
x = x->Resolve(ctx);
}
Implemented static methods in String struct. Implemented String.Format and String.AppendFormat. Implemented native vararg methods for the future.
2017-01-21 00:07:44 +00:00
}
}
else if (!(flag & (VARF_Ref|VARF_Out)))
- implemented pass-by-reference arguments - so far only for memory based variables. - changed Dehacked weapon function lookup to check the symbol table instead of directly referencing the VM functions. Once scriptified these pointers will no longer be available. - removed all special ATAGs from the VM. While well intentioned any pointer tagged with them is basically unusable because it'd trigger asserts all over the place. - scriptified A_Punch for testing pass-by-reference parameters and stack variables.
2016-11-19 00:23:56 +00:00
{
x = new FxTypeCast(ArgList[i], type, false);
x = x->Resolve(ctx);
}
else
{
bool writable;
ArgList[i] = ArgList[i]->Resolve(ctx); // nust be resolved before the address is requested.
- scriptified Heretic's Skull Rod. - Took the opportunity and fixed the logic for the Skull Rod's rain spawner. The old code which was part of the 3D floor submission was unable to work with portals at all. The new approach no longer tries to hide the dead projectile in the ceiling, it leaves it where it is and changes a few flags, so that its z-position can be used as reference to get the actual ceiling. This works for line portals, but for sector portals still requires some changes to sector_t::NextHighestCeilingAt to work, but at least this can be made to work unlike the old code. - added names for the player-related translations to A_SetTranslation. - fixed: Failure to resolve a function argument was checked for, too late. - made the parameter for A_SetTranslation a name instead of a string, because it is more efficient. We do not need full strings here.
2016-11-25 15:05:03 +00:00
if (ArgList[i] != nullptr && ArgList[i]->ValueType != TypeNullPtr)
- implemented pass-by-reference arguments - so far only for memory based variables. - changed Dehacked weapon function lookup to check the symbol table instead of directly referencing the VM functions. Once scriptified these pointers will no longer be available. - removed all special ATAGs from the VM. While well intentioned any pointer tagged with them is basically unusable because it'd trigger asserts all over the place. - scriptified A_Punch for testing pass-by-reference parameters and stack variables.
2016-11-19 00:23:56 +00:00
{
- scriptified the remaining Doom weapon code. - implemented method calls from struct instances. - optimized disassembly of VM call instructions to print the function's name at the end where it is more visible and does not need to be truncated. Also use the printable name for script functions here.
2016-11-20 11:27:26 +00:00
ArgList[i]->RequestAddress(ctx, &writable);
- scriptified a_strifeitems.cpp and a_debris.cpp. - Changed the glass shards so that they do not have to override FloorBounceMissile. It was the only place where this was virtually overridden and provided little usefulness. - made 'out' variables work. - fixed virtual call handling for HandlePickup.
2016-11-29 11:17:05 +00:00
if (flag & VARF_Ref) ArgList[i]->ValueType = NewPointer(ArgList[i]->ValueType);
- scriptified the remaining Doom weapon code. - implemented method calls from struct instances. - optimized disassembly of VM call instructions to print the function's name at the end where it is more visible and does not need to be truncated. Also use the printable name for script functions here.
2016-11-20 11:27:26 +00:00
// For a reference argument the types must match 100%.
if (type != ArgList[i]->ValueType)
{
Fixed format strings warnings reported by GCC/Clang See https://forum.zdoom.org/viewtopic.php?t=54541 and https://forum.zdoom.org/viewtopic.php?t=54709
2016-12-24 12:33:50 +00:00
ScriptPosition.Message(MSG_ERROR, "Type mismatch in reference argument %s", Function->SymbolName.GetChars());
- scriptified the remaining Doom weapon code. - implemented method calls from struct instances. - optimized disassembly of VM call instructions to print the function's name at the end where it is more visible and does not need to be truncated. Also use the printable name for script functions here.
2016-11-20 11:27:26 +00:00
x = nullptr;
}
else
{
x = ArgList[i];
}
- implemented pass-by-reference arguments - so far only for memory based variables. - changed Dehacked weapon function lookup to check the symbol table instead of directly referencing the VM functions. Once scriptified these pointers will no longer be available. - removed all special ATAGs from the VM. While well intentioned any pointer tagged with them is basically unusable because it'd trigger asserts all over the place. - scriptified A_Punch for testing pass-by-reference parameters and stack variables.
2016-11-19 00:23:56 +00:00
}
- scriptified the remaining Doom weapon code. - implemented method calls from struct instances. - optimized disassembly of VM call instructions to print the function's name at the end where it is more visible and does not need to be truncated. Also use the printable name for script functions here.
2016-11-20 11:27:26 +00:00
else x = ArgList[i];
- implemented pass-by-reference arguments - so far only for memory based variables. - changed Dehacked weapon function lookup to check the symbol table instead of directly referencing the VM functions. Once scriptified these pointers will no longer be available. - removed all special ATAGs from the VM. While well intentioned any pointer tagged with them is basically unusable because it'd trigger asserts all over the place. - scriptified A_Punch for testing pass-by-reference parameters and stack variables.
2016-11-19 00:23:56 +00:00
}
- 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
failed |= (x == nullptr);
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
ArgList[i] = x;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
int numargs = ArgList.Size() + implicit;
- implemented passing vectors as parameters. So far working for native functions. - removed the bogus optional value from the first A_Jump argument. A quick test with an older ZDoom revealed that this was never working - and implementing it would make things a lot more complicated, especially error checking in the code generator. - fixed: The check for insufficient parameters to a function call was missing.
2016-10-29 11:10:27 +00:00
if ((unsigned)numargs < argtypes.Size() && argtypes[numargs] != nullptr)
{
auto flags = Function->Variants[0].ArgFlags[numargs];
if (!(flags & VARF_Optional))
{
ScriptPosition.Message(MSG_ERROR, "Insufficient arguments in call to %s", Function->SymbolName.GetChars());
delete this;
return nullptr;
}
}
- scriptified Heretic's wizard.
2016-11-11 22:32:13 +00:00
}
else
{
if ((unsigned)implicit < argtypes.Size() && argtypes[implicit] != nullptr)
{
auto flags = Function->Variants[0].ArgFlags[implicit];
if (!(flags & VARF_Optional))
{
ScriptPosition.Message(MSG_ERROR, "Insufficient arguments in call to %s", Function->SymbolName.GetChars());
delete this;
return nullptr;
}
}
Normalize line endings
2016-03-01 15:47:10 +00:00
}
if (failed)
{
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- Added some fudging so that A_PlayerSkinCheck creates proper code until I can rewrite the FunctionCall expression to match what the script compiler needs. The current version of this class is too much geared toward DECORATE.
2016-10-14 19:15:46 +00:00
TArray<PType *> &rets = proto->ReturnTypes;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (rets.Size() > 0)
{
ValueType = rets[0];
}
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
else
{
ValueType = TypeVoid;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
return this;
}
//==========================================================================
//
- added the required code genration nodes for member function calls. This is not testable right now because finally the action function mess has come full circle. The current setup makes it impossible to call action functions from non-action functions because the needed info is local to the functions. Long avoided, this needs to be refactored now so that the different semantics for action functions are no longer needed.
2016-10-22 10:10:19 +00:00
//
Normalize line endings
2016-03-01 15:47:10 +00:00
//
//==========================================================================
ExpEmit FxVMFunctionCall::Emit(VMFunctionBuilder *build)
{
- 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
assert(build->Registers[REGT_POINTER].GetMostUsed() >= build->NumImplicits);
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
int count = 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
- added the ability to attach a constructor or destructor to an internally defined struct. There are a few which require explicit native construction or destruction that need to be exported to the VM, e.g. FCheckPosition. The VM cannot handle this directly, it needs two special functions to be attached to handle such elements.
2017-01-11 22:46:03 +00:00
if (build->FramePointer.Fixed) EmitTail = false; // do not tail call if the stack is in use
Normalize line endings
2016-03-01 15:47:10 +00:00
if (count == 1)
{
ExpEmit reg;
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
if (CheckEmitCast(build, EmitTail, reg))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- allow defining native fields through scripts. Internally this only requires exporting the address, but not the entire field. - added new VARF_Transient flag so that the decision whether to serialize a field does not depend solely on its native status. It may actually make a lot of sense to use the auto-serializer for native fields, too, as this would eliminate a lot of maintenance code. - defined (u)int8/16 as aliases to the byte and short types (Can't we not just get rid of this naming convention already...?) - exporting the fields of Actor revealed a few name clashes between them and some global types, so Actor.Sector was renamed to CurSector and Actor.Inventory was renamed to Actor.Inv.
2016-11-22 18:20:31 +00:00
ArgList.DeleteAndClear();
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
ArgList.ShrinkToFit();
Normalize line endings
2016-03-01 15:47:10 +00:00
return reg;
}
}
- implemented the state compiler. So far all it can handle is parameter-less functions. To do the rest, some cleanup is needed first, to untangle the DECORATE parser from the actual code generation so that the low end stuff can actually be reused here instead of having to be redone.
2016-10-12 15:50:23 +00:00
- implemented handling for virtual function. Syntax-wise I chose to make it as strict as possible to reduce the chance of errors: Virtual base functions must be declared with the 'virtual' keyword, and overrides in child classes with the 'override' keyword. This way any mismatch in parameters that otherwise would cause silent failure will outright produce a compile error.
2016-11-11 19:05:07 +00:00
VMFunction *vmfunc = Function->Variants[0].Implementation;
- Fixed more GCC/Clang warnings.
2016-11-26 11:45:17 +00:00
bool staticcall = (vmfunc->Final || vmfunc->VirtualIndex == ~0u || NoVirtual);
- implemented handling for virtual function. Syntax-wise I chose to make it as strict as possible to reduce the chance of errors: Virtual base functions must be declared with the 'virtual' keyword, and overrides in child classes with the 'override' keyword. This way any mismatch in parameters that otherwise would cause silent failure will outright produce a compile error.
2016-11-11 19:05:07 +00:00
- implemented passing vectors as parameters. So far working for native functions. - removed the bogus optional value from the first A_Jump argument. A quick test with an older ZDoom revealed that this was never working - and implementing it would make things a lot more complicated, especially error checking in the code generator. - fixed: The check for insufficient parameters to a function call was missing.
2016-10-29 11:10:27 +00:00
count = 0;
- turned everything I could into non-action functions. - fixed emission of the self pointer in FxVMFunctionCall. I did not realize that the self expression only sets up a register for the value, not pushing it onto the stack.
2016-10-22 15:49:08 +00:00
// Emit code to pass implied parameters
- implemented handling for virtual function. Syntax-wise I chose to make it as strict as possible to reduce the chance of errors: Virtual base functions must be declared with the 'virtual' keyword, and overrides in child classes with the 'override' keyword. This way any mismatch in parameters that otherwise would cause silent failure will outright produce a compile error.
2016-11-11 19:05:07 +00:00
ExpEmit selfemit;
- turned everything I could into non-action functions. - fixed emission of the self pointer in FxVMFunctionCall. I did not realize that the self expression only sets up a register for the value, not pushing it onto the stack.
2016-10-22 15:49:08 +00:00
if (Function->Variants[0].Flags & VARF_Method)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- turned everything I could into non-action functions. - fixed emission of the self pointer in FxVMFunctionCall. I did not realize that the self expression only sets up a register for the value, not pushing it onto the stack.
2016-10-22 15:49:08 +00:00
assert(Self != nullptr);
- implemented handling for virtual function. Syntax-wise I chose to make it as strict as possible to reduce the chance of errors: Virtual base functions must be declared with the 'virtual' keyword, and overrides in child classes with the 'override' keyword. This way any mismatch in parameters that otherwise would cause silent failure will outright produce a compile error.
2016-11-11 19:05:07 +00:00
selfemit = Self->Emit(build);
- scriptified Strife's coins. - added a String class to allow attaching methods to the builtin string type. This works by checking if the left side of the member accessor is a string and just replacing the tyoe in this one place, all the rest is automatic.
2016-11-28 17:15:18 +00:00
assert((selfemit.RegType == REGT_POINTER) || (selfemit.Fixed && selfemit.Target));
if (selfemit.Fixed && selfemit.Target)
{
// Address of a local variable.
build->Emit(OP_PARAM, 0, selfemit.RegType | REGT_ADDROF, selfemit.RegNum);
}
else
{
build->Emit(OP_PARAM, 0, selfemit.RegType, selfemit.RegNum);
}
- turned everything I could into non-action functions. - fixed emission of the self pointer in FxVMFunctionCall. I did not realize that the self expression only sets up a register for the value, not pushing it onto the stack.
2016-10-22 15:49:08 +00:00
count += 1;
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
if (Function->Variants[0].Flags & VARF_Action)
FxVMFunctionCall must pass null pointers when calling an action function from a non-action function
2016-10-02 03:29:57 +00:00
{
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
static_assert(NAP == 3, "This code needs to be updated if NAP changes");
- 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
if (build->NumImplicits == NAP && selfemit.RegNum == 0) // only pass this function's stateowner and stateinfo if the subfunction is run in self's context.
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
{
build->Emit(OP_PARAM, 0, REGT_POINTER, 1);
build->Emit(OP_PARAM, 0, REGT_POINTER, 2);
}
else
{
// pass self as stateowner, otherwise all attempts of the subfunction to retrieve a state from a name would fail.
build->Emit(OP_PARAM, 0, selfemit.RegType, selfemit.RegNum);
build->Emit(OP_PARAM, 0, REGT_POINTER | REGT_KONST, build->GetConstantAddress(nullptr, ATAG_GENERIC));
}
count += 2;
FxVMFunctionCall must pass null pointers when calling an action function from a non-action function
2016-10-02 03:29:57 +00:00
}
- implemented handling for virtual function. Syntax-wise I chose to make it as strict as possible to reduce the chance of errors: Virtual base functions must be declared with the 'virtual' keyword, and overrides in child classes with the 'override' keyword. This way any mismatch in parameters that otherwise would cause silent failure will outright produce a compile error.
2016-11-11 19:05:07 +00:00
if (staticcall) selfemit.Free(build);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- implemented handling for virtual function. Syntax-wise I chose to make it as strict as possible to reduce the chance of errors: Virtual base functions must be declared with the 'virtual' keyword, and overrides in child classes with the 'override' keyword. This way any mismatch in parameters that otherwise would cause silent failure will outright produce a compile error.
2016-11-11 19:05:07 +00:00
else staticcall = true;
Normalize line endings
2016-03-01 15:47:10 +00:00
// Emit code to pass explicit parameters
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
for (unsigned i = 0; i < ArgList.Size(); ++i)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
count += EmitParameter(build, ArgList[i], ScriptPosition);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- allow defining native fields through scripts. Internally this only requires exporting the address, but not the entire field. - added new VARF_Transient flag so that the decision whether to serialize a field does not depend solely on its native status. It may actually make a lot of sense to use the auto-serializer for native fields, too, as this would eliminate a lot of maintenance code. - defined (u)int8/16 as aliases to the byte and short types (Can't we not just get rid of this naming convention already...?) - exporting the fields of Actor revealed a few name clashes between them and some global types, so Actor.Sector was renamed to CurSector and Actor.Inventory was renamed to Actor.Inv.
2016-11-22 18:20:31 +00:00
ArgList.DeleteAndClear();
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
ArgList.ShrinkToFit();
Normalize line endings
2016-03-01 15:47:10 +00:00
// Get a constant register for this function
- implemented handling for virtual function. Syntax-wise I chose to make it as strict as possible to reduce the chance of errors: Virtual base functions must be declared with the 'virtual' keyword, and overrides in child classes with the 'override' keyword. This way any mismatch in parameters that otherwise would cause silent failure will outright produce a compile error.
2016-11-11 19:05:07 +00:00
if (staticcall)
{
int funcaddr = build->GetConstantAddress(vmfunc, ATAG_OBJECT);
// Emit the call
if (EmitTail)
{ // Tail call
build->Emit(OP_TAIL_K, funcaddr, count, 0);
ExpEmit call;
call.Final = true;
return call;
}
else if (vmfunc->Proto->ReturnTypes.Size() > 0)
{ // Call, expecting one result
- scriptified A_Saw. - implemented multiple-return-value assignment. Due to some grammar conflicts the originally intended Lua-inspired syntax of 'a, b = Function()' could not be done, so it's '[a, b] = Function()'
2016-11-19 23:25:38 +00:00
build->Emit(OP_CALL_K, funcaddr, count, MAX(1, AssignCount));
goto handlereturns;
- implemented handling for virtual function. Syntax-wise I chose to make it as strict as possible to reduce the chance of errors: Virtual base functions must be declared with the 'virtual' keyword, and overrides in child classes with the 'override' keyword. This way any mismatch in parameters that otherwise would cause silent failure will outright produce a compile error.
2016-11-11 19:05:07 +00:00
}
else
{ // Call, expecting no results
build->Emit(OP_CALL_K, funcaddr, count, 0);
return ExpEmit();
}
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
- implemented handling for virtual function. Syntax-wise I chose to make it as strict as possible to reduce the chance of errors: Virtual base functions must be declared with the 'virtual' keyword, and overrides in child classes with the 'override' keyword. This way any mismatch in parameters that otherwise would cause silent failure will outright produce a compile error.
2016-11-11 19:05:07 +00:00
{
selfemit.Free(build);
ExpEmit funcreg(build, REGT_POINTER);
build->Emit(OP_VTBL, funcreg.RegNum, selfemit.RegNum, vmfunc->VirtualIndex);
if (EmitTail)
{ // Tail call
build->Emit(OP_TAIL, funcreg.RegNum, count, 0);
ExpEmit call;
call.Final = true;
return call;
}
else if (vmfunc->Proto->ReturnTypes.Size() > 0)
{ // Call, expecting one result
- scriptified A_Saw. - implemented multiple-return-value assignment. Due to some grammar conflicts the originally intended Lua-inspired syntax of 'a, b = Function()' could not be done, so it's '[a, b] = Function()'
2016-11-19 23:25:38 +00:00
build->Emit(OP_CALL, funcreg.RegNum, count, MAX(1, AssignCount));
goto handlereturns;
- implemented handling for virtual function. Syntax-wise I chose to make it as strict as possible to reduce the chance of errors: Virtual base functions must be declared with the 'virtual' keyword, and overrides in child classes with the 'override' keyword. This way any mismatch in parameters that otherwise would cause silent failure will outright produce a compile error.
2016-11-11 19:05:07 +00:00
}
else
{ // Call, expecting no results
build->Emit(OP_CALL, funcreg.RegNum, count, 0);
return ExpEmit();
}
- scriptified A_Saw. - implemented multiple-return-value assignment. Due to some grammar conflicts the originally intended Lua-inspired syntax of 'a, b = Function()' could not be done, so it's '[a, b] = Function()'
2016-11-19 23:25:38 +00:00
}
handlereturns:
if (AssignCount == 0)
{
// Regular call, will not write to ReturnRegs
ExpEmit reg(build, vmfunc->Proto->ReturnTypes[0]->GetRegType(), vmfunc->Proto->ReturnTypes[0]->GetRegCount());
build->Emit(OP_RESULT, 0, EncodeRegType(reg), reg.RegNum);
return reg;
}
else
{
// Multi-Assignment call, this must fill in the ReturnRegs array so that the multi-assignment operator can dispatch the return values.
assert((unsigned)AssignCount <= vmfunc->Proto->ReturnTypes.Size());
for (int i = 0; i < AssignCount; i++)
{
ExpEmit reg(build, vmfunc->Proto->ReturnTypes[i]->GetRegType(), vmfunc->Proto->ReturnTypes[i]->GetRegCount());
build->Emit(OP_RESULT, 0, EncodeRegType(reg), reg.RegNum);
ReturnRegs.Push(reg);
}
return ExpEmit();
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
//==========================================================================
//
// If calling one of the casting kludge functions, don't bother calling the
// function; just use the parameter directly. Returns true if this was a
// kludge function, false otherwise.
//
//==========================================================================
bool FxVMFunctionCall::CheckEmitCast(VMFunctionBuilder *build, bool returnit, ExpEmit &reg)
{
FName funcname = Function->SymbolName;
if (funcname == NAME___decorate_internal_int__ ||
funcname == NAME___decorate_internal_bool__ ||
Add float casts to DECORATE for the sake of completeness
2016-03-01 17:36:15 +00:00
funcname == NAME___decorate_internal_float__)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
FxExpression *arg = ArgList[0];
Normalize line endings
2016-03-01 15:47:10 +00:00
if (returnit)
{
if (arg->isConstant() &&
(funcname == NAME___decorate_internal_int__ ||
funcname == NAME___decorate_internal_bool__))
{ // Use immediate version for integers in range
build->EmitRetInt(0, true, static_cast<FxConstant *>(arg)->GetValue().Int);
}
else
{
ExpEmit where = arg->Emit(build);
Make sure to use the REGT_MULTIREG flags for opcodes that need it
2016-10-30 05:17:37 +00:00
build->Emit(OP_RET, RET_FINAL, EncodeRegType(where), where.RegNum);
Normalize line endings
2016-03-01 15:47:10 +00:00
where.Free(build);
}
reg = ExpEmit();
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
reg.Final = true;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
reg = arg->Emit(build);
}
return true;
}
return false;
}
//==========================================================================
//
//
//
//==========================================================================
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
FxFlopFunctionCall::FxFlopFunctionCall(size_t index, FArgumentList &args, const FScriptPosition &pos)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_FlopFunctionCall, pos)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
assert(index < countof(FxFlops) && "FLOP index out of range");
Index = (int)index;
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
ArgList = std::move(args);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
//
//
//==========================================================================
FxFlopFunctionCall::~FxFlopFunctionCall()
{
}
FxExpression *FxFlopFunctionCall::Resolve(FCompileContext& ctx)
{
CHECKRESOLVED();
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
if (ArgList.Size() != 1)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
ScriptPosition.Message(MSG_ERROR, "%s only has one parameter", FName(FxFlops[Index].Name).GetChars());
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
ArgList[0] = ArgList[0]->Resolve(ctx);
if (ArgList[0] == nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
if (!ArgList[0]->IsNumeric())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
ScriptPosition.Message(MSG_ERROR, "numeric value expected for parameter");
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
if (ArgList[0]->isConstant())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
double v = static_cast<FxConstant *>(ArgList[0])->GetValue().GetFloat();
Normalize line endings
2016-03-01 15:47:10 +00:00
v = FxFlops[Index].Evaluate(v);
FxExpression *x = new FxConstant(v, ScriptPosition);
delete this;
return x;
}
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
if (ArgList[0]->ValueType->GetRegType() == REGT_INT)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
ArgList[0] = new FxFloatCast(ArgList[0]);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
ValueType = TypeFloat64;
return this;
}
//==========================================================================
//
//
//==========================================================================
ExpEmit FxFlopFunctionCall::Emit(VMFunctionBuilder *build)
{
- scriptified Hexen's Dragon. - fixed several places in the code generator that did not consider locked registers for local variables: array indices, abs and floating point builtin functions. - added some debug aids to the bounds opcode. Just triggering an exception here which loses all relevant info is perfectly useless in a debug situation.
2016-11-16 18:18:21 +00:00
assert(ValueType == ArgList[0]->ValueType);
ExpEmit from = ArgList[0]->Emit(build);
ExpEmit to;
assert(from.Konst == 0);
assert(ValueType->GetRegCount() == 1);
// Do it in-place, unless a local variable
if (from.Fixed)
{
to = ExpEmit(build, from.RegType);
from.Free(build);
}
else
{
to = from;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
- scriptified Hexen's Dragon. - fixed several places in the code generator that did not consider locked registers for local variables: array indices, abs and floating point builtin functions. - added some debug aids to the bounds opcode. Just triggering an exception here which loses all relevant info is perfectly useless in a debug situation.
2016-11-16 18:18:21 +00:00
build->Emit(OP_FLOP, to.RegNum, from.RegNum, FxFlops[Index].Flop);
- allow defining native fields through scripts. Internally this only requires exporting the address, but not the entire field. - added new VARF_Transient flag so that the decision whether to serialize a field does not depend solely on its native status. It may actually make a lot of sense to use the auto-serializer for native fields, too, as this would eliminate a lot of maintenance code. - defined (u)int8/16 as aliases to the byte and short types (Can't we not just get rid of this naming convention already...?) - exporting the fields of Actor revealed a few name clashes between them and some global types, so Actor.Sector was renamed to CurSector and Actor.Inventory was renamed to Actor.Inv.
2016-11-22 18:20:31 +00:00
ArgList.DeleteAndClear();
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
ArgList.ShrinkToFit();
- scriptified Hexen's Dragon. - fixed several places in the code generator that did not consider locked registers for local variables: array indices, abs and floating point builtin functions. - added some debug aids to the bounds opcode. Just triggering an exception here which loses all relevant info is perfectly useless in a debug situation.
2016-11-16 18:18:21 +00:00
return to;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- added vector builtins Length() and Unit(). This should complete the vector type except for use as function parameter.
2016-10-29 08:43:22 +00:00
//==========================================================================
//
//
//==========================================================================
FxVectorBuiltin::FxVectorBuiltin(FxExpression *self, FName name)
:FxExpression(EFX_VectorBuiltin, self->ScriptPosition)
{
Self = self;
Function = name;
}
FxVectorBuiltin::~FxVectorBuiltin()
{
SAFE_DELETE(Self);
}
FxExpression *FxVectorBuiltin::Resolve(FCompileContext &ctx)
{
SAFE_RESOLVE(Self, ctx);
assert(Self->IsVector()); // should never be created for anything else.
ValueType = Function == NAME_Length ? TypeFloat64 : Self->ValueType;
return this;
}
ExpEmit FxVectorBuiltin::Emit(VMFunctionBuilder *build)
{
ExpEmit to(build, ValueType->GetRegType(), ValueType->GetRegCount());
ExpEmit op = Self->Emit(build);
if (Function == NAME_Length)
{
build->Emit(Self->ValueType == TypeVector2 ? OP_LENV2 : OP_LENV3, to.RegNum, op.RegNum);
}
else
{
ExpEmit len(build, REGT_FLOAT);
build->Emit(Self->ValueType == TypeVector2 ? OP_LENV2 : OP_LENV3, len.RegNum, op.RegNum);
build->Emit(Self->ValueType == TypeVector2 ? OP_DIVVF2_RR : OP_DIVVF3_RR, to.RegNum, op.RegNum, len.RegNum);
len.Free(build);
}
op.Free(build);
return to;
}
- scriptified Heretic's blaster. - scriptified all Effect functions of Fastprojectile's children - implemented access to class meta data. - added a VM instruction to retrieve the class metadata, to eliminate the overhead of the function call that would otherwise be needed. - made GetClass() a builtin so that it can use the new instruction Important note about this commit: Scriptifying CFlameMissile::Effect revealed a problem with the virtual function interface: In order to work, this needs to be explicitly enabled for each single native class that may be used as a base for a scripted class. Needless to say, this will end up way too much work, as there are over 100 native classes, excluding those which will be scriptified. But in order to fix the problem this partially broken state needs to be committed first.
2016-11-24 19:02:44 +00:00
//==========================================================================
//
//
//==========================================================================
- scriptified the health items.
2017-01-15 00:02:38 +00:00
FxStrLen::FxStrLen(FxExpression *self)
:FxExpression(EFX_StrLen, self->ScriptPosition)
{
Self = self;
}
FxStrLen::~FxStrLen()
{
SAFE_DELETE(Self);
}
FxExpression *FxStrLen::Resolve(FCompileContext &ctx)
{
SAFE_RESOLVE(Self, ctx);
assert(Self->ValueType == TypeString);
ValueType = TypeUInt32;
return this;
}
ExpEmit FxStrLen::Emit(VMFunctionBuilder *build)
{
ExpEmit to(build, REGT_INT);
ExpEmit op = Self->Emit(build);
build->Emit(OP_LENS, to.RegNum, op.RegNum);
op.Free(build);
return to;
}
//==========================================================================
//
//
//==========================================================================
- scriptified Heretic's blaster. - scriptified all Effect functions of Fastprojectile's children - implemented access to class meta data. - added a VM instruction to retrieve the class metadata, to eliminate the overhead of the function call that would otherwise be needed. - made GetClass() a builtin so that it can use the new instruction Important note about this commit: Scriptifying CFlameMissile::Effect revealed a problem with the virtual function interface: In order to work, this needs to be explicitly enabled for each single native class that may be used as a base for a scripted class. Needless to say, this will end up way too much work, as there are over 100 native classes, excluding those which will be scriptified. But in order to fix the problem this partially broken state needs to be committed first.
2016-11-24 19:02:44 +00:00
FxGetClass::FxGetClass(FxExpression *self)
:FxExpression(EFX_GetClass, self->ScriptPosition)
{
Self = self;
}
FxGetClass::~FxGetClass()
{
SAFE_DELETE(Self);
}
FxExpression *FxGetClass::Resolve(FCompileContext &ctx)
{
SAFE_RESOLVE(Self, ctx);
if (!Self->IsObject())
{
ScriptPosition.Message(MSG_ERROR, "GetClass() requires an object");
delete this;
return nullptr;
}
ValueType = NewClassPointer(static_cast<PClass*>(static_cast<PPointer*>(Self->ValueType)->PointedType));
return this;
}
ExpEmit FxGetClass::Emit(VMFunctionBuilder *build)
{
ExpEmit op = Self->Emit(build);
op.Free(build);
ExpEmit to(build, REGT_POINTER);
build->Emit(OP_META, to.RegNum, op.RegNum);
return to;
}
- converted half of ClericHoly. (Making a commit before starting on the more complex stuff.) - added a 'constructor' for color values.
2016-11-26 12:18:48 +00:00
//==========================================================================
//
//
//==========================================================================
- scriptified the backpack. - added GetParentClass builtin to compiler.
2017-01-14 22:34:47 +00:00
FxGetParentClass::FxGetParentClass(FxExpression *self)
- scriptified the health items.
2017-01-15 00:02:38 +00:00
:FxExpression(EFX_GetParentClass, self->ScriptPosition)
- scriptified the backpack. - added GetParentClass builtin to compiler.
2017-01-14 22:34:47 +00:00
{
Self = self;
}
FxGetParentClass::~FxGetParentClass()
{
SAFE_DELETE(Self);
}
FxExpression *FxGetParentClass::Resolve(FCompileContext &ctx)
{
SAFE_RESOLVE(Self, ctx);
if (!Self->ValueType->IsKindOf(RUNTIME_CLASS(PClassPointer)) && !Self->IsObject())
{
ScriptPosition.Message(MSG_ERROR, "GetClass() requires an object");
delete this;
return nullptr;
}
ValueType = NewClassPointer(RUNTIME_CLASS(DObject)); //
return this;
}
ExpEmit FxGetParentClass::Emit(VMFunctionBuilder *build)
{
ExpEmit op = Self->Emit(build);
op.Free(build);
if (Self->IsObject())
{
ExpEmit to(build, REGT_POINTER);
build->Emit(OP_META, to.RegNum, op.RegNum);
op = to;
op.Free(build);
}
ExpEmit to(build, REGT_POINTER);
build->Emit(OP_LO, to.RegNum, op.RegNum, build->GetConstantInt(myoffsetof(PClass, ParentClass)));
return to;
}
//==========================================================================
//
//
//==========================================================================
- fixed: Readonly pointers never were flagged as such. - fixed: Assignment from a readonly to a read-allowed pointer must be an error. - made GetDefaultByType a builtin so that it can do proper type assignment to the result, which for a function would be problematic in this case, even if automatic type deduction was implemented. Since this returns the class defaults which are not a real object, the result cannot be subjected to a type cast. - error out if a type cast of a readonly pointer is attempted. - fixed: FxBooleanNot could clobber a local variable because it used the source register to manipulate the result.
2016-11-27 14:50:58 +00:00
FxGetDefaultByType::FxGetDefaultByType(FxExpression *self)
:FxExpression(EFX_GetDefaultByType, self->ScriptPosition)
{
Self = self;
}
FxGetDefaultByType::~FxGetDefaultByType()
{
SAFE_DELETE(Self);
}
FxExpression *FxGetDefaultByType::Resolve(FCompileContext &ctx)
{
SAFE_RESOLVE(Self, ctx);
PClass *cls = nullptr;
if (Self->ValueType == TypeString || Self->ValueType == TypeName)
{
if (Self->isConstant())
{
cls = PClass::FindActor(static_cast<FxConstant *>(Self)->GetValue().GetName());
if (cls == nullptr)
{
ScriptPosition.Message(MSG_ERROR, "GetDefaultByType() requires an actor class type, but got %s", static_cast<FxConstant *>(Self)->GetValue().GetString().GetChars());
delete this;
return nullptr;
}
Self = new FxConstant(cls, NewClassPointer(cls), ScriptPosition);
}
else
{
// this is the ugly case. We do not know what we have and cannot do proper type casting.
// For now error out and let this case require explicit handling on the user side.
Fixed format strings warnings reported by GCC/Clang See https://forum.zdoom.org/viewtopic.php?t=54541 and https://forum.zdoom.org/viewtopic.php?t=54709
2016-12-24 12:33:50 +00:00
ScriptPosition.Message(MSG_ERROR, "GetDefaultByType() requires an actor class type, but got %s", static_cast<FxConstant *>(Self)->GetValue().GetString().GetChars());
- fixed: Readonly pointers never were flagged as such. - fixed: Assignment from a readonly to a read-allowed pointer must be an error. - made GetDefaultByType a builtin so that it can do proper type assignment to the result, which for a function would be problematic in this case, even if automatic type deduction was implemented. Since this returns the class defaults which are not a real object, the result cannot be subjected to a type cast. - error out if a type cast of a readonly pointer is attempted. - fixed: FxBooleanNot could clobber a local variable because it used the source register to manipulate the result.
2016-11-27 14:50:58 +00:00
delete this;
return nullptr;
}
}
else
{
auto cp = dyn_cast<PClassPointer>(Self->ValueType);
if (cp == nullptr || !cp->ClassRestriction->IsDescendantOf(RUNTIME_CLASS(AActor)))
{
ScriptPosition.Message(MSG_ERROR, "GetDefaultByType() requires an actor class type");
delete this;
return nullptr;
}
cls = cp->ClassRestriction;
}
ValueType = NewPointer(cls, true);
return this;
}
ExpEmit FxGetDefaultByType::Emit(VMFunctionBuilder *build)
{
ExpEmit op = Self->Emit(build);
op.Free(build);
ExpEmit to(build, REGT_POINTER);
if (op.Konst)
{
build->Emit(OP_LKP, to.RegNum, op.RegNum);
op = to;
}
build->Emit(OP_LO, to.RegNum, op.RegNum, build->GetConstantInt(myoffsetof(PClass, Defaults)));
return to;
}
//==========================================================================
//
//
//==========================================================================
- converted half of ClericHoly. (Making a commit before starting on the more complex stuff.) - added a 'constructor' for color values.
2016-11-26 12:18:48 +00:00
FxColorLiteral::FxColorLiteral(FArgumentList &args, FScriptPosition &sc)
:FxExpression(EFX_ColorLiteral, sc)
{
ArgList = std::move(args);
}
FxExpression *FxColorLiteral::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
unsigned constelements = 0;
assert(ArgList.Size() == 3 || ArgList.Size() == 4);
if (ArgList.Size() == 3) ArgList.Insert(0, nullptr);
for (int i = 0; i < 4; i++)
{
if (ArgList[i] != nullptr)
{
SAFE_RESOLVE(ArgList[i], ctx);
if (!ArgList[i]->IsInteger())
{
ScriptPosition.Message(MSG_ERROR, "Integer expected for color component");
delete this;
return nullptr;
}
if (ArgList[i]->isConstant())
{
constval += clamp(static_cast<FxConstant *>(ArgList[i])->GetValue().GetInt(), 0, 255) << (24 - i * 8);
delete ArgList[i];
ArgList[i] = nullptr;
constelements++;
}
}
else constelements++;
}
if (constelements == 4)
{
auto x = new FxConstant(constval, ScriptPosition);
x->ValueType = TypeColor;
delete this;
return x;
}
ValueType = TypeColor;
return this;
}
ExpEmit FxColorLiteral::Emit(VMFunctionBuilder *build)
{
ExpEmit out(build, REGT_INT);
build->Emit(OP_LK, out.RegNum, build->GetConstantInt(constval));
for (int i = 0; i < 4; i++)
{
if (ArgList[i] != nullptr)
{
assert(!ArgList[i]->isConstant());
ExpEmit in = ArgList[i]->Emit(build);
in.Free(build);
ExpEmit work(build, REGT_INT);
build->Emit(OP_MAX_RK, work.RegNum, in.RegNum, build->GetConstantInt(0));
build->Emit(OP_MIN_RK, work.RegNum, work.RegNum, build->GetConstantInt(255));
if (i != 3) build->Emit(OP_SLL_RI, work.RegNum, work.RegNum, 24 - (i * 8));
build->Emit(OP_OR_RR, out.RegNum, out.RegNum, work.RegNum);
}
}
return out;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
- split up FxCompoundStatement into the old FxSequence and a new subclass. FxSequence is just a sequence of expressions, while FxCompoundStatement is the one that actually implements handling of local variables. The split was done so that ZCCCompiler::ConvertNode can return multiple statements as one object and for that FxCompoundStatement is not suitable. - added conversion of local variable declarations. This is still untested
2016-10-19 23:09:35 +00:00
// FxSequence :: Resolve
Normalize line endings
2016-03-01 15:47:10 +00:00
//
//==========================================================================
- split up FxCompoundStatement into the old FxSequence and a new subclass. FxSequence is just a sequence of expressions, while FxCompoundStatement is the one that actually implements handling of local variables. The split was done so that ZCCCompiler::ConvertNode can return multiple statements as one object and for that FxCompoundStatement is not suitable. - added conversion of local variable declarations. This is still untested
2016-10-19 23:09:35 +00:00
FxExpression *FxSequence::Resolve(FCompileContext &ctx)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
CHECKRESOLVED();
- scriptified A_SpawnFly. - added support for global variables to the code generator - not the compiler, though. For the handful of entries this is needed for it may just as well be done manually. So far FLevelLocals level is the only one being exported. - fixed: The VM disassembler truncated 64 bit pointers to 15 digits because the output buffer was too small. - resolve entire FxSequences instead of aborting on the first failed entry. This allows to output all errors at once.
2016-11-03 12:38:40 +00:00
bool fail = false;
Normalize line endings
2016-03-01 15:47:10 +00:00
for (unsigned i = 0; i < Expressions.Size(); ++i)
{
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
if (nullptr == (Expressions[i] = Expressions[i]->Resolve(ctx)))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- 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
fail = true;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- Scriptified Heretic's knight.
2016-11-11 21:14:29 +00:00
else if (Expressions[i]->ValueType == TypeError)
- implemented super calls and proper dispatch of scripted virtual overrides for Destroy.
2016-11-11 20:52:08 +00:00
{
ScriptPosition.Message(MSG_ERROR, "Invalid statement");
fail = true;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- 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
if (fail)
{
delete this;
return nullptr;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
return this;
}
- fixed: Tacking on a return statement should only be done if the function has branches that actually reach the end. Otherwise it may interfere with return type deduction. - used the return check to optimize out unneeded jumps at the end of an if statement's first block.
2016-11-05 17:05:57 +00:00
//==========================================================================
//
// FxSequence :: CheckReturn
//
//==========================================================================
bool FxSequence::CheckReturn()
{
// a sequence always returns when its last element returns.
return Expressions.Size() > 0 && Expressions.Last()->CheckReturn();
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
- split up FxCompoundStatement into the old FxSequence and a new subclass. FxSequence is just a sequence of expressions, while FxCompoundStatement is the one that actually implements handling of local variables. The split was done so that ZCCCompiler::ConvertNode can return multiple statements as one object and for that FxCompoundStatement is not suitable. - added conversion of local variable declarations. This is still untested
2016-10-19 23:09:35 +00:00
// FxSequence :: Emit
Normalize line endings
2016-03-01 15:47:10 +00:00
//
//==========================================================================
- split up FxCompoundStatement into the old FxSequence and a new subclass. FxSequence is just a sequence of expressions, while FxCompoundStatement is the one that actually implements handling of local variables. The split was done so that ZCCCompiler::ConvertNode can return multiple statements as one object and for that FxCompoundStatement is not suitable. - added conversion of local variable declarations. This is still untested
2016-10-19 23:09:35 +00:00
ExpEmit FxSequence::Emit(VMFunctionBuilder *build)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
for (unsigned i = 0; i < Expressions.Size(); ++i)
{
- record all line numbers during function generation. This is useful for error reporting and eventually debugging. - throw a useful exception when a VM abort occurs, the simple enum was incapable of reporting anything more than the barest minimum, which at least for array index out of bounds errors was insufficient. The current exception mechanism is still insufficient. It really has to report a proper crash location and print a stack trace to the maximum extent possible. Instead it just prints a message and happily goes on. This is not a good solution.
2016-12-02 16:36:29 +00:00
Expressions[i]->EmitStatement(build);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
return ExpEmit();
}
//==========================================================================
//
- split up FxCompoundStatement into the old FxSequence and a new subclass. FxSequence is just a sequence of expressions, while FxCompoundStatement is the one that actually implements handling of local variables. The split was done so that ZCCCompiler::ConvertNode can return multiple statements as one object and for that FxCompoundStatement is not suitable. - added conversion of local variable declarations. This is still untested
2016-10-19 23:09:35 +00:00
// FxSequence :: GetDirectFunction
Normalize line endings
2016-03-01 15:47:10 +00:00
//
//==========================================================================
- split up FxCompoundStatement into the old FxSequence and a new subclass. FxSequence is just a sequence of expressions, while FxCompoundStatement is the one that actually implements handling of local variables. The split was done so that ZCCCompiler::ConvertNode can return multiple statements as one object and for that FxCompoundStatement is not suitable. - added conversion of local variable declarations. This is still untested
2016-10-19 23:09:35 +00:00
VMFunction *FxSequence::GetDirectFunction()
Normalize line endings
2016-03-01 15:47:10 +00:00
{
if (Expressions.Size() == 1)
{
return Expressions[0]->GetDirectFunction();
}
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- split up FxCompoundStatement into the old FxSequence and a new subclass. FxSequence is just a sequence of expressions, while FxCompoundStatement is the one that actually implements handling of local variables. The split was done so that ZCCCompiler::ConvertNode can return multiple statements as one object and for that FxCompoundStatement is not suitable. - added conversion of local variable declarations. This is still untested
2016-10-19 23:09:35 +00:00
//==========================================================================
//
// FxCompoundStatement :: Resolve
//
//==========================================================================
FxExpression *FxCompoundStatement::Resolve(FCompileContext &ctx)
{
auto outer = ctx.Block;
Outer = ctx.Block;
ctx.Block = this;
auto x = FxSequence::Resolve(ctx);
ctx.Block = outer;
- tested and fixed the regular assignment statement for both local and member variables. The generated object code can definitely use an optimization pass but that's something left for later when more things are working. Right now it creates one opcode more than necessary for all member accesses (instead of using the offset in the store command it calculates an actual address of the variable in another address register) and can create one too many for non-constant expressions being assigned to local variables (a move between two registers because the emitted expression on the right hand side does not know that it can emit to the actual variable's register.)
2016-10-21 08:09:01 +00:00
return x;
- split up FxCompoundStatement into the old FxSequence and a new subclass. FxSequence is just a sequence of expressions, while FxCompoundStatement is the one that actually implements handling of local variables. The split was done so that ZCCCompiler::ConvertNode can return multiple statements as one object and for that FxCompoundStatement is not suitable. - added conversion of local variable declarations. This is still untested
2016-10-19 23:09:35 +00:00
}
//==========================================================================
//
// FxCompoundStatement :: Emit
//
//==========================================================================
ExpEmit FxCompoundStatement::Emit(VMFunctionBuilder *build)
{
auto e = FxSequence::Emit(build);
// Release all local variables in this block.
for (auto l : LocalVars)
{
l->Release(build);
}
return e;
}
- added processing of compound statements to the compiler. This means that anonymous functions without control statements are generating code now. - added local variable declarations to the code generator. This is not tested yet, that will come with the next commit.
2016-10-19 17:05:48 +00:00
//==========================================================================
//
// FxCompoundStatement :: FindLocalVariable
//
// Looks for a variable name in any of the containing compound statements
- 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
// This does a simple linear search on each block's variables.
// The lists here normally don't get large enough to justify something more complex.
- added processing of compound statements to the compiler. This means that anonymous functions without control statements are generating code now. - added local variable declarations to the code generator. This is not tested yet, that will come with the next commit.
2016-10-19 17:05:48 +00:00
//
//==========================================================================
- 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
FxLocalVariableDeclaration *FxCompoundStatement::FindLocalVariable(FName name, FCompileContext &ctx)
- added processing of compound statements to the compiler. This means that anonymous functions without control statements are generating code now. - added local variable declarations to the code generator. This is not tested yet, that will come with the next commit.
2016-10-19 17:05:48 +00:00
{
auto block = this;
while (block != nullptr)
{
for (auto l : block->LocalVars)
{
if (l->Name == name)
{
return l;
}
}
block = block->Outer;
}
- 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
// finally check the context for function arguments
for (auto arg : ctx.FunctionArgs)
{
if (arg->Name == name)
{
return arg;
}
}
- added processing of compound statements to the compiler. This means that anonymous functions without control statements are generating code now. - added local variable declarations to the code generator. This is not tested yet, that will come with the next commit.
2016-10-19 17:05:48 +00:00
return nullptr;
}
//==========================================================================
//
// FxCompoundStatement :: CheckLocalVariable
//
// Checks if the current block already contains a local variable
// of the given name.
//
//==========================================================================
bool FxCompoundStatement::CheckLocalVariable(FName name)
{
for (auto l : LocalVars)
{
if (l->Name == name)
{
return true;
}
}
return false;
}
- added switch/case processing. Right now it is just a sequence of test/jmp instructions. It may make sense to add a special opcode that can perform the comparisons natively but that's an option for later. - added a TESTN instruction. This is like TEST but negates the operand. This was added to avoid flooding the constant table with too many case labels. With TEST and TESTN combined, all numbers between -65535 and 65535 can be kept entirely inside the instruction. Numbers outside this range still use a BEQ instruction.
2016-10-23 10:00:25 +00:00
//==========================================================================
//
// FxSwitchStatement
//
//==========================================================================
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
FxSwitchStatement::FxSwitchStatement(FxExpression *cond, FArgumentList &content, const FScriptPosition &pos)
- added switch/case processing. Right now it is just a sequence of test/jmp instructions. It may make sense to add a special opcode that can perform the comparisons natively but that's an option for later. - added a TESTN instruction. This is like TEST but negates the operand. This was added to avoid flooding the constant table with too many case labels. With TEST and TESTN combined, all numbers between -65535 and 65535 can be kept entirely inside the instruction. Numbers outside this range still use a BEQ instruction.
2016-10-23 10:00:25 +00:00
: FxExpression(EFX_SwitchStatement, pos)
{
- scriptified ArtiHealingRadius. - allow switch/case with names. - fixed break jump target handling for switch/case. This only worked when the break was in the outermost compound statement, those in inner ones were missed.
2016-11-26 23:18:07 +00:00
Condition = cond;
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
Content = std::move(content);
- added switch/case processing. Right now it is just a sequence of test/jmp instructions. It may make sense to add a special opcode that can perform the comparisons natively but that's an option for later. - added a TESTN instruction. This is like TEST but negates the operand. This was added to avoid flooding the constant table with too many case labels. With TEST and TESTN combined, all numbers between -65535 and 65535 can be kept entirely inside the instruction. Numbers outside this range still use a BEQ instruction.
2016-10-23 10:00:25 +00:00
}
FxSwitchStatement::~FxSwitchStatement()
{
SAFE_DELETE(Condition);
}
FxExpression *FxSwitchStatement::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE(Condition, ctx);
- scriptified ArtiHealingRadius. - allow switch/case with names. - fixed break jump target handling for switch/case. This only worked when the break was in the outermost compound statement, those in inner ones were missed.
2016-11-26 23:18:07 +00:00
if (Condition->ValueType != TypeName)
{
Condition = new FxIntCast(Condition, false);
SAFE_RESOLVE(Condition, ctx);
}
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
if (Content.Size() == 0)
- added switch/case processing. Right now it is just a sequence of test/jmp instructions. It may make sense to add a special opcode that can perform the comparisons natively but that's an option for later. - added a TESTN instruction. This is like TEST but negates the operand. This was added to avoid flooding the constant table with too many case labels. With TEST and TESTN combined, all numbers between -65535 and 65535 can be kept entirely inside the instruction. Numbers outside this range still use a BEQ instruction.
2016-10-23 10:00:25 +00:00
{
ScriptPosition.Message(MSG_WARNING, "Empty switch statement");
if (Condition->isConstant())
{
return new FxNop(ScriptPosition);
}
else
{
// The condition may have a side effect so it should be processed (possible to-do: Analyze all nodes in there and delete if not.)
auto x = Condition;
Condition = nullptr;
delete this;
- scriptified the functions in a_possessed.cpp and added the needed exports and constants. - fixed: Script functions did not receive the function name when being created. - relaxed the asserts for PARAM_STATE, because the VM knows nothing about ATAG_STATE. Any state variable's content (e.g. Actor.SeeState) will receive ATAG_GENERIC, rather than ATAG_STATE. - added a 'NeedResult' flag so that certain operations can create shorter code if the result of the expression is not needed. So far only used for postdecrement/increment statements on local variables (which is the most frequent case where this matters.) - fixed postincrement and decrement for local variables. Due to the result preservation semantics it created faulty code.
2016-10-26 09:30:30 +00:00
x->NeedResult = false;
return x;
- added switch/case processing. Right now it is just a sequence of test/jmp instructions. It may make sense to add a special opcode that can perform the comparisons natively but that's an option for later. - added a TESTN instruction. This is like TEST but negates the operand. This was added to avoid flooding the constant table with too many case labels. With TEST and TESTN combined, all numbers between -65535 and 65535 can be kept entirely inside the instruction. Numbers outside this range still use a BEQ instruction.
2016-10-23 10:00:25 +00:00
}
}
- scriptified ArtiHealingRadius. - allow switch/case with names. - fixed break jump target handling for switch/case. This only worked when the break was in the outermost compound statement, those in inner ones were missed.
2016-11-26 23:18:07 +00:00
auto outerctrl = ctx.ControlStmt;
ctx.ControlStmt = this;
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
for (auto &line : Content)
- added switch/case processing. Right now it is just a sequence of test/jmp instructions. It may make sense to add a special opcode that can perform the comparisons natively but that's an option for later. - added a TESTN instruction. This is like TEST but negates the operand. This was added to avoid flooding the constant table with too many case labels. With TEST and TESTN combined, all numbers between -65535 and 65535 can be kept entirely inside the instruction. Numbers outside this range still use a BEQ instruction.
2016-10-23 10:00:25 +00:00
{
- scriptified ArtiHealingRadius. - allow switch/case with names. - fixed break jump target handling for switch/case. This only worked when the break was in the outermost compound statement, those in inner ones were missed.
2016-11-26 23:18:07 +00:00
SAFE_RESOLVE(line, ctx);
line->NeedResult = false;
- added switch/case processing. Right now it is just a sequence of test/jmp instructions. It may make sense to add a special opcode that can perform the comparisons natively but that's an option for later. - added a TESTN instruction. This is like TEST but negates the operand. This was added to avoid flooding the constant table with too many case labels. With TEST and TESTN combined, all numbers between -65535 and 65535 can be kept entirely inside the instruction. Numbers outside this range still use a BEQ instruction.
2016-10-23 10:00:25 +00:00
}
- scriptified ArtiHealingRadius. - allow switch/case with names. - fixed break jump target handling for switch/case. This only worked when the break was in the outermost compound statement, those in inner ones were missed.
2016-11-26 23:18:07 +00:00
ctx.ControlStmt = outerctrl;
- added switch/case processing. Right now it is just a sequence of test/jmp instructions. It may make sense to add a special opcode that can perform the comparisons natively but that's an option for later. - added a TESTN instruction. This is like TEST but negates the operand. This was added to avoid flooding the constant table with too many case labels. With TEST and TESTN combined, all numbers between -65535 and 65535 can be kept entirely inside the instruction. Numbers outside this range still use a BEQ instruction.
2016-10-23 10:00:25 +00:00
if (Condition->isConstant())
{
ScriptPosition.Message(MSG_WARNING, "Case expression is constant");
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
auto &content = Content;
- made some variables signed that should not be unsigned.
2016-10-25 15:07:19 +00:00
int defaultindex = -1;
int defaultbreak = -1;
int caseindex = -1;
int casebreak = -1;
- added switch/case processing. Right now it is just a sequence of test/jmp instructions. It may make sense to add a special opcode that can perform the comparisons natively but that's an option for later. - added a TESTN instruction. This is like TEST but negates the operand. This was added to avoid flooding the constant table with too many case labels. With TEST and TESTN combined, all numbers between -65535 and 65535 can be kept entirely inside the instruction. Numbers outside this range still use a BEQ instruction.
2016-10-23 10:00:25 +00:00
// look for a case label with a matching value
for (unsigned i = 0; i < content.Size(); i++)
{
if (content[i] != nullptr)
{
if (content[i]->ExprType == EFX_CaseStatement)
{
auto casestmt = static_cast<FxCaseStatement *>(content[i]);
if (casestmt->Condition == nullptr) defaultindex = i;
else if (casestmt->CaseValue == static_cast<FxConstant *>(Condition)->GetValue().GetInt()) caseindex = i;
- scriptified ArtiHealingRadius. - allow switch/case with names. - fixed break jump target handling for switch/case. This only worked when the break was in the outermost compound statement, those in inner ones were missed.
2016-11-26 23:18:07 +00:00
if (casestmt->Condition && casestmt->Condition->ValueType != Condition->ValueType)
{
casestmt->Condition->ScriptPosition.Message(MSG_ERROR, "Type mismatch in case statement");
delete this;
return nullptr;
}
- added switch/case processing. Right now it is just a sequence of test/jmp instructions. It may make sense to add a special opcode that can perform the comparisons natively but that's an option for later. - added a TESTN instruction. This is like TEST but negates the operand. This was added to avoid flooding the constant table with too many case labels. With TEST and TESTN combined, all numbers between -65535 and 65535 can be kept entirely inside the instruction. Numbers outside this range still use a BEQ instruction.
2016-10-23 10:00:25 +00:00
}
if (content[i]->ExprType == EFX_JumpStatement && static_cast<FxJumpStatement *>(content[i])->Token == TK_Break)
{
if (defaultindex >= 0 && defaultbreak < 0) defaultbreak = i;
if (caseindex >= 0 && casebreak < 0)
{
casebreak = i;
break; // when we find this we do not need to look any further.
}
}
}
}
if (caseindex < 0)
{
caseindex = defaultindex;
casebreak = defaultbreak;
}
if (caseindex > 0 && casebreak - caseindex > 1)
{
auto seq = new FxSequence(ScriptPosition);
- made some variables signed that should not be unsigned.
2016-10-25 15:07:19 +00:00
for (int i = caseindex + 1; i < casebreak; i++)
- added switch/case processing. Right now it is just a sequence of test/jmp instructions. It may make sense to add a special opcode that can perform the comparisons natively but that's an option for later. - added a TESTN instruction. This is like TEST but negates the operand. This was added to avoid flooding the constant table with too many case labels. With TEST and TESTN combined, all numbers between -65535 and 65535 can be kept entirely inside the instruction. Numbers outside this range still use a BEQ instruction.
2016-10-23 10:00:25 +00:00
{
if (content[i] != nullptr && content[i]->ExprType != EFX_CaseStatement)
{
seq->Add(content[i]);
content[i] = nullptr;
}
}
delete this;
return seq->Resolve(ctx);
}
delete this;
return new FxNop(ScriptPosition);
}
int mincase = INT_MAX;
int maxcase = INT_MIN;
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
for (auto line : Content)
- added switch/case processing. Right now it is just a sequence of test/jmp instructions. It may make sense to add a special opcode that can perform the comparisons natively but that's an option for later. - added a TESTN instruction. This is like TEST but negates the operand. This was added to avoid flooding the constant table with too many case labels. With TEST and TESTN combined, all numbers between -65535 and 65535 can be kept entirely inside the instruction. Numbers outside this range still use a BEQ instruction.
2016-10-23 10:00:25 +00:00
{
if (line->ExprType == EFX_CaseStatement)
{
auto casestmt = static_cast<FxCaseStatement *>(line);
if (casestmt->Condition != nullptr)
{
CaseAddr ca = { casestmt->CaseValue, 0 };
CaseAddresses.Push(ca);
if (ca.casevalue < mincase) mincase = ca.casevalue;
if (ca.casevalue > maxcase) maxcase = ca.casevalue;
}
}
}
return this;
}
ExpEmit FxSwitchStatement::Emit(VMFunctionBuilder *build)
{
assert(Condition != nullptr);
ExpEmit emit = Condition->Emit(build);
assert(emit.RegType == REGT_INT);
// todo:
// - sort jump table by value.
// - optimize the switch dispatcher to run in native code instead of executing each single branch instruction on its own.
// e.g.: build->Emit(OP_SWITCH, emit.RegNum, build->GetConstantInt(CaseAddresses.Size());
for (auto &ca : CaseAddresses)
{
if (ca.casevalue >= 0 && ca.casevalue <= 0xffff)
{
build->Emit(OP_TEST, emit.RegNum, (VM_SHALF)ca.casevalue);
}
else if (ca.casevalue < 0 && ca.casevalue >= -0xffff)
{
build->Emit(OP_TESTN, emit.RegNum, (VM_SHALF)-ca.casevalue);
}
else
{
build->Emit(OP_EQ_K, 1, emit.RegNum, build->GetConstantInt(ca.casevalue));
}
ca.jumpaddress = build->Emit(OP_JMP, 0);
}
size_t DefaultAddress = build->Emit(OP_JMP, 0);
- fixed: Switch statement without a default jumped to the first first case label instead. - removed placeholder code from scripted Marine.
2016-11-21 21:20:25 +00:00
bool defaultset = false;
- added switch/case processing. Right now it is just a sequence of test/jmp instructions. It may make sense to add a special opcode that can perform the comparisons natively but that's an option for later. - added a TESTN instruction. This is like TEST but negates the operand. This was added to avoid flooding the constant table with too many case labels. With TEST and TESTN combined, all numbers between -65535 and 65535 can be kept entirely inside the instruction. Numbers outside this range still use a BEQ instruction.
2016-10-23 10:00:25 +00:00
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
for (auto line : Content)
- added switch/case processing. Right now it is just a sequence of test/jmp instructions. It may make sense to add a special opcode that can perform the comparisons natively but that's an option for later. - added a TESTN instruction. This is like TEST but negates the operand. This was added to avoid flooding the constant table with too many case labels. With TEST and TESTN combined, all numbers between -65535 and 65535 can be kept entirely inside the instruction. Numbers outside this range still use a BEQ instruction.
2016-10-23 10:00:25 +00:00
{
switch (line->ExprType)
{
case EFX_CaseStatement:
if (static_cast<FxCaseStatement *>(line)->Condition != nullptr)
{
for (auto &ca : CaseAddresses)
{
if (ca.casevalue == static_cast<FxCaseStatement *>(line)->CaseValue)
{
build->BackpatchToHere(ca.jumpaddress);
break;
}
}
}
else
{
build->BackpatchToHere(DefaultAddress);
- fixed: Switch statement without a default jumped to the first first case label instead. - removed placeholder code from scripted Marine.
2016-11-21 21:20:25 +00:00
defaultset = true;
- added switch/case processing. Right now it is just a sequence of test/jmp instructions. It may make sense to add a special opcode that can perform the comparisons natively but that's an option for later. - added a TESTN instruction. This is like TEST but negates the operand. This was added to avoid flooding the constant table with too many case labels. With TEST and TESTN combined, all numbers between -65535 and 65535 can be kept entirely inside the instruction. Numbers outside this range still use a BEQ instruction.
2016-10-23 10:00:25 +00:00
}
break;
default:
- record all line numbers during function generation. This is useful for error reporting and eventually debugging. - throw a useful exception when a VM abort occurs, the simple enum was incapable of reporting anything more than the barest minimum, which at least for array index out of bounds errors was insufficient. The current exception mechanism is still insufficient. It really has to report a proper crash location and print a stack trace to the maximum extent possible. Instead it just prints a message and happily goes on. This is not a good solution.
2016-12-02 16:36:29 +00:00
line->EmitStatement(build);
- added switch/case processing. Right now it is just a sequence of test/jmp instructions. It may make sense to add a special opcode that can perform the comparisons natively but that's an option for later. - added a TESTN instruction. This is like TEST but negates the operand. This was added to avoid flooding the constant table with too many case labels. With TEST and TESTN combined, all numbers between -65535 and 65535 can be kept entirely inside the instruction. Numbers outside this range still use a BEQ instruction.
2016-10-23 10:00:25 +00:00
break;
}
}
- scriptified ArtiHealingRadius. - allow switch/case with names. - fixed break jump target handling for switch/case. This only worked when the break was in the outermost compound statement, those in inner ones were missed.
2016-11-26 23:18:07 +00:00
for (auto addr : Breaks)
- added switch/case processing. Right now it is just a sequence of test/jmp instructions. It may make sense to add a special opcode that can perform the comparisons natively but that's an option for later. - added a TESTN instruction. This is like TEST but negates the operand. This was added to avoid flooding the constant table with too many case labels. With TEST and TESTN combined, all numbers between -65535 and 65535 can be kept entirely inside the instruction. Numbers outside this range still use a BEQ instruction.
2016-10-23 10:00:25 +00:00
{
- scriptified ArtiHealingRadius. - allow switch/case with names. - fixed break jump target handling for switch/case. This only worked when the break was in the outermost compound statement, those in inner ones were missed.
2016-11-26 23:18:07 +00:00
build->BackpatchToHere(addr->Address);
- added switch/case processing. Right now it is just a sequence of test/jmp instructions. It may make sense to add a special opcode that can perform the comparisons natively but that's an option for later. - added a TESTN instruction. This is like TEST but negates the operand. This was added to avoid flooding the constant table with too many case labels. With TEST and TESTN combined, all numbers between -65535 and 65535 can be kept entirely inside the instruction. Numbers outside this range still use a BEQ instruction.
2016-10-23 10:00:25 +00:00
}
- fixed: Switch statement without a default jumped to the first first case label instead. - removed placeholder code from scripted Marine.
2016-11-21 21:20:25 +00:00
if (!defaultset) build->BackpatchToHere(DefaultAddress);
- allow defining native fields through scripts. Internally this only requires exporting the address, but not the entire field. - added new VARF_Transient flag so that the decision whether to serialize a field does not depend solely on its native status. It may actually make a lot of sense to use the auto-serializer for native fields, too, as this would eliminate a lot of maintenance code. - defined (u)int8/16 as aliases to the byte and short types (Can't we not just get rid of this naming convention already...?) - exporting the fields of Actor revealed a few name clashes between them and some global types, so Actor.Sector was renamed to CurSector and Actor.Inventory was renamed to Actor.Inv.
2016-11-22 18:20:31 +00:00
Content.DeleteAndClear();
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
Content.ShrinkToFit();
- added switch/case processing. Right now it is just a sequence of test/jmp instructions. It may make sense to add a special opcode that can perform the comparisons natively but that's an option for later. - added a TESTN instruction. This is like TEST but negates the operand. This was added to avoid flooding the constant table with too many case labels. With TEST and TESTN combined, all numbers between -65535 and 65535 can be kept entirely inside the instruction. Numbers outside this range still use a BEQ instruction.
2016-10-23 10:00:25 +00:00
return ExpEmit();
}
- fixed: Tacking on a return statement should only be done if the function has branches that actually reach the end. Otherwise it may interfere with return type deduction. - used the return check to optimize out unneeded jumps at the end of an if statement's first block.
2016-11-05 17:05:57 +00:00
//==========================================================================
//
// FxSequence :: CheckReturn
//
//==========================================================================
bool FxSwitchStatement::CheckReturn()
{
- fixed: The CheckReturn check for FxSwitchStatement was not strict enough. It may only return true if there is no default case because without that any non-matching value will go past the statement.
2017-01-05 10:39:29 +00:00
bool founddefault = false;
//A switch statement returns when it contains a no breaks, a default case, and ends with a return
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
for (auto line : Content)
- fixed: Tacking on a return statement should only be done if the function has branches that actually reach the end. Otherwise it may interfere with return type deduction. - used the return check to optimize out unneeded jumps at the end of an if statement's first block.
2016-11-05 17:05:57 +00:00
{
if (line->ExprType == EFX_JumpStatement)
{
return false; // Break means that the end of the statement will be reached, Continue cannot happen in the last statement of the last block.
}
- fixed: The CheckReturn check for FxSwitchStatement was not strict enough. It may only return true if there is no default case because without that any non-matching value will go past the statement.
2017-01-05 10:39:29 +00:00
else if (line->ExprType == EFX_CaseStatement)
{
if (static_cast<FxCaseStatement*>(line)->Condition == nullptr) founddefault = true;
}
- fixed: Tacking on a return statement should only be done if the function has branches that actually reach the end. Otherwise it may interfere with return type deduction. - used the return check to optimize out unneeded jumps at the end of an if statement's first block.
2016-11-05 17:05:57 +00:00
}
- fixed: The CheckReturn check for FxSwitchStatement was not strict enough. It may only return true if there is no default case because without that any non-matching value will go past the statement.
2017-01-05 10:39:29 +00:00
return founddefault && Content.Size() > 0 && Content.Last()->CheckReturn();
- fixed: Tacking on a return statement should only be done if the function has branches that actually reach the end. Otherwise it may interfere with return type deduction. - used the return check to optimize out unneeded jumps at the end of an if statement's first block.
2016-11-05 17:05:57 +00:00
}
- added switch/case processing. Right now it is just a sequence of test/jmp instructions. It may make sense to add a special opcode that can perform the comparisons natively but that's an option for later. - added a TESTN instruction. This is like TEST but negates the operand. This was added to avoid flooding the constant table with too many case labels. With TEST and TESTN combined, all numbers between -65535 and 65535 can be kept entirely inside the instruction. Numbers outside this range still use a BEQ instruction.
2016-10-23 10:00:25 +00:00
//==========================================================================
//
// FxCaseStatement
//
//==========================================================================
FxCaseStatement::FxCaseStatement(FxExpression *cond, const FScriptPosition &pos)
: FxExpression(EFX_CaseStatement, pos)
{
- scriptified ArtiHealingRadius. - allow switch/case with names. - fixed break jump target handling for switch/case. This only worked when the break was in the outermost compound statement, those in inner ones were missed.
2016-11-26 23:18:07 +00:00
Condition = cond;
- added switch/case processing. Right now it is just a sequence of test/jmp instructions. It may make sense to add a special opcode that can perform the comparisons natively but that's an option for later. - added a TESTN instruction. This is like TEST but negates the operand. This was added to avoid flooding the constant table with too many case labels. With TEST and TESTN combined, all numbers between -65535 and 65535 can be kept entirely inside the instruction. Numbers outside this range still use a BEQ instruction.
2016-10-23 10:00:25 +00:00
}
FxCaseStatement::~FxCaseStatement()
{
SAFE_DELETE(Condition);
}
FxExpression *FxCaseStatement::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE_OPT(Condition, ctx);
if (Condition != nullptr)
{
if (!Condition->isConstant())
{
ScriptPosition.Message(MSG_ERROR, "Case label must be a constant value");
delete this;
return nullptr;
}
- scriptified ArtiHealingRadius. - allow switch/case with names. - fixed break jump target handling for switch/case. This only worked when the break was in the outermost compound statement, those in inner ones were missed.
2016-11-26 23:18:07 +00:00
// Case labels can be ints or names.
if (Condition->ValueType != TypeName)
{
Condition = new FxIntCast(Condition, false);
SAFE_RESOLVE(Condition, ctx);
CaseValue = static_cast<FxConstant *>(Condition)->GetValue().GetInt();
}
else
{
CaseValue = static_cast<FxConstant *>(Condition)->GetValue().GetName();
}
- added switch/case processing. Right now it is just a sequence of test/jmp instructions. It may make sense to add a special opcode that can perform the comparisons natively but that's an option for later. - added a TESTN instruction. This is like TEST but negates the operand. This was added to avoid flooding the constant table with too many case labels. With TEST and TESTN combined, all numbers between -65535 and 65535 can be kept entirely inside the instruction. Numbers outside this range still use a BEQ instruction.
2016-10-23 10:00:25 +00:00
}
return this;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// FxIfStatement
//
//==========================================================================
FxIfStatement::FxIfStatement(FxExpression *cond, FxExpression *true_part,
FxExpression *false_part, const FScriptPosition &pos)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_IfStatement, pos)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
Condition = cond;
WhenTrue = true_part;
WhenFalse = false_part;
- scriptified the functions in a_possessed.cpp and added the needed exports and constants. - fixed: Script functions did not receive the function name when being created. - relaxed the asserts for PARAM_STATE, because the VM knows nothing about ATAG_STATE. Any state variable's content (e.g. Actor.SeeState) will receive ATAG_GENERIC, rather than ATAG_STATE. - added a 'NeedResult' flag so that certain operations can create shorter code if the result of the expression is not needed. So far only used for postdecrement/increment statements on local variables (which is the most frequent case where this matters.) - fixed postincrement and decrement for local variables. Due to the result preservation semantics it created faulty code.
2016-10-26 09:30:30 +00:00
if (WhenTrue != nullptr) WhenTrue->NeedResult = false;
if (WhenFalse != nullptr) WhenFalse->NeedResult = false;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
assert(cond != nullptr);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
FxIfStatement::~FxIfStatement()
{
SAFE_DELETE(Condition);
SAFE_DELETE(WhenTrue);
SAFE_DELETE(WhenFalse);
}
FxExpression *FxIfStatement::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
if (WhenTrue == nullptr && WhenFalse == nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{ // We don't do anything either way, so disappear
delete this;
- fixed: Completely empty if statements left the code generator in a broken state.
2016-11-19 17:02:07 +00:00
ScriptPosition.Message(MSG_WARNING, "empty if statement");
return new FxNop(ScriptPosition);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
SAFE_RESOLVE(Condition, ctx);
if (Condition->ValueType != TypeBool)
{
- added an optimization to FxBoolCast that it doesn't force the source value to a 0/1 integer if not explicitly needed. When doing comparisons we do not care about actual values, we only want to know if it is 0 or not. - added the above for the 'if' condition. It works for integers, floats and pointers and will save 3 instructions if the condition is a non-boolean that can be implicitly casted to bool.
2016-10-23 13:30:58 +00:00
Condition = new FxBoolCast(Condition, false);
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
SAFE_RESOLVE(Condition, ctx);
}
if (WhenTrue != nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
WhenTrue = WhenTrue->Resolve(ctx);
ABORT(WhenTrue);
}
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
if (WhenFalse != nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
WhenFalse = WhenFalse->Resolve(ctx);
ABORT(WhenFalse);
}
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
Normalize line endings
2016-03-01 15:47:10 +00:00
ValueType = TypeVoid;
if (Condition->isConstant())
{
ExpVal condval = static_cast<FxConstant *>(Condition)->GetValue();
bool result = condval.GetBool();
FxExpression *e = result ? WhenTrue : WhenFalse;
delete (result ? WhenFalse : WhenTrue);
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
WhenTrue = WhenFalse = nullptr;
if (e == nullptr) e = new FxNop(ScriptPosition); // create a dummy if this statement gets completely removed by optimizing out the constant parts.
Normalize line endings
2016-03-01 15:47:10 +00:00
delete this;
return e;
}
Properly use the boolean type in expressions This fixes things like 'if (GetCVar(x))' not working
2016-07-04 00:19:52 +00:00
Normalize line endings
2016-03-01 15:47:10 +00:00
return this;
}
ExpEmit FxIfStatement::Emit(VMFunctionBuilder *build)
{
ExpEmit v;
- branch optimization.
2016-12-01 23:51:29 +00:00
size_t jumpspot = ~0u;
Normalize line endings
2016-03-01 15:47:10 +00:00
- branch optimization.
2016-12-01 23:51:29 +00:00
TArray<size_t> yes, no;
- fixed code generation for if statements with empty 'true' part. For those the jump statement backpatching was not done correctly.
2016-12-18 13:09:16 +00:00
Condition->EmitCompare(build, WhenTrue == nullptr, yes, no);
Normalize line endings
2016-03-01 15:47:10 +00:00
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
if (WhenTrue != nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- branch optimization.
2016-12-01 23:51:29 +00:00
build->BackpatchListToHere(yes);
- record all line numbers during function generation. This is useful for error reporting and eventually debugging. - throw a useful exception when a VM abort occurs, the simple enum was incapable of reporting anything more than the barest minimum, which at least for array index out of bounds errors was insufficient. The current exception mechanism is still insufficient. It really has to report a proper crash location and print a stack trace to the maximum extent possible. Instead it just prints a message and happily goes on. This is not a good solution.
2016-12-02 16:36:29 +00:00
WhenTrue->EmitStatement(build);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- branch optimization.
2016-12-01 23:51:29 +00:00
if (WhenFalse != nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- fixed code generation for if statements with empty 'true' part. For those the jump statement backpatching was not done correctly.
2016-12-18 13:09:16 +00:00
if (WhenTrue != nullptr)
{
if (!WhenTrue->CheckReturn()) jumpspot = build->Emit(OP_JMP, 0); // no need to emit a jump if the block returns.
build->BackpatchListToHere(no);
}
- record all line numbers during function generation. This is useful for error reporting and eventually debugging. - throw a useful exception when a VM abort occurs, the simple enum was incapable of reporting anything more than the barest minimum, which at least for array index out of bounds errors was insufficient. The current exception mechanism is still insufficient. It really has to report a proper crash location and print a stack trace to the maximum extent possible. Instead it just prints a message and happily goes on. This is not a good solution.
2016-12-02 16:36:29 +00:00
WhenFalse->EmitStatement(build);
- branch optimization.
2016-12-01 23:51:29 +00:00
if (jumpspot != ~0u) build->BackpatchToHere(jumpspot);
- fixed code generation for if statements with empty 'true' part. For those the jump statement backpatching was not done correctly.
2016-12-18 13:09:16 +00:00
if (WhenTrue == nullptr) build->BackpatchListToHere(no);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- branch optimization.
2016-12-01 23:51:29 +00:00
else
- added an optimization to FxBoolCast that it doesn't force the source value to a 0/1 integer if not explicitly needed. When doing comparisons we do not care about actual values, we only want to know if it is 0 or not. - added the above for the 'if' condition. It works for integers, floats and pointers and will save 3 instructions if the condition is a non-boolean that can be implicitly casted to bool.
2016-10-23 13:30:58 +00:00
{
- branch optimization.
2016-12-01 23:51:29 +00:00
build->BackpatchListToHere(no);
- added an optimization to FxBoolCast that it doesn't force the source value to a 0/1 integer if not explicitly needed. When doing comparisons we do not care about actual values, we only want to know if it is 0 or not. - added the above for the 'if' condition. It works for integers, floats and pointers and will save 3 instructions if the condition is a non-boolean that can be implicitly casted to bool.
2016-10-23 13:30:58 +00:00
}
Normalize line endings
2016-03-01 15:47:10 +00:00
return ExpEmit();
}
- fixed: Tacking on a return statement should only be done if the function has branches that actually reach the end. Otherwise it may interfere with return type deduction. - used the return check to optimize out unneeded jumps at the end of an if statement's first block.
2016-11-05 17:05:57 +00:00
//==========================================================================
//
// FxIfStatement :: CheckReturn
//
//==========================================================================
bool FxIfStatement::CheckReturn()
{
- fixed: An 'if' statement with only one branch may never considered to be always returning.
2016-11-06 13:14:54 +00:00
//An if statement returns if both branches return. Both branches must be present.
return WhenTrue != nullptr && WhenTrue->CheckReturn() &&
WhenFalse != nullptr && WhenFalse->CheckReturn();
- fixed: Tacking on a return statement should only be done if the function has branches that actually reach the end. Otherwise it may interfere with return type deduction. - used the return check to optimize out unneeded jumps at the end of an if statement's first block.
2016-11-05 17:05:57 +00:00
}
- cleaned up the loop statement nodes in the code generator, which put some handling in FCompileContext and some of their data into the base FxExpression class instead of having an intermediate base class for all loops which is responsible for the relevant data. All this is now encapsulated in a new FxLoopStatement class which serves as base for the actual loop statements.
2016-10-15 08:34:26 +00:00
//==========================================================================
//
- fixed handling of loop statements. All break and continue statements were collected in one list, and each loop statement taking hold of that entire list, including the breaks and continues from previous outer loops. Changed it so that loop statements contain the jump addresses themselves and set a pointer in FCompileContext, so that the jump point can be set directly in the loop statement - and an error printed if there is none in the resolving stage, not the emitting one. Consolidated the identical backpatching code of the three loop statement nodes into a subfunction.
2016-10-19 12:36:54 +00:00
// FxLoopStatement :: Resolve
//
// saves the loop pointer in the context and sets this object as the current loop
// so that continues and breaks always resolve to the innermost loop.
- cleaned up the loop statement nodes in the code generator, which put some handling in FCompileContext and some of their data into the base FxExpression class instead of having an intermediate base class for all loops which is responsible for the relevant data. All this is now encapsulated in a new FxLoopStatement class which serves as base for the actual loop statements.
2016-10-15 08:34:26 +00:00
//
//==========================================================================
- fixed handling of loop statements. All break and continue statements were collected in one list, and each loop statement taking hold of that entire list, including the breaks and continues from previous outer loops. Changed it so that loop statements contain the jump addresses themselves and set a pointer in FCompileContext, so that the jump point can be set directly in the loop statement - and an error printed if there is none in the resolving stage, not the emitting one. Consolidated the identical backpatching code of the three loop statement nodes into a subfunction.
2016-10-19 12:36:54 +00:00
FxExpression *FxLoopStatement::Resolve(FCompileContext &ctx)
- cleaned up the loop statement nodes in the code generator, which put some handling in FCompileContext and some of their data into the base FxExpression class instead of having an intermediate base class for all loops which is responsible for the relevant data. All this is now encapsulated in a new FxLoopStatement class which serves as base for the actual loop statements.
2016-10-15 08:34:26 +00:00
{
- scriptified ArtiHealingRadius. - allow switch/case with names. - fixed break jump target handling for switch/case. This only worked when the break was in the outermost compound statement, those in inner ones were missed.
2016-11-26 23:18:07 +00:00
auto outerctrl = ctx.ControlStmt;
- fixed handling of loop statements. All break and continue statements were collected in one list, and each loop statement taking hold of that entire list, including the breaks and continues from previous outer loops. Changed it so that loop statements contain the jump addresses themselves and set a pointer in FCompileContext, so that the jump point can be set directly in the loop statement - and an error printed if there is none in the resolving stage, not the emitting one. Consolidated the identical backpatching code of the three loop statement nodes into a subfunction.
2016-10-19 12:36:54 +00:00
auto outer = ctx.Loop;
- scriptified ArtiHealingRadius. - allow switch/case with names. - fixed break jump target handling for switch/case. This only worked when the break was in the outermost compound statement, those in inner ones were missed.
2016-11-26 23:18:07 +00:00
ctx.ControlStmt = this;
- fixed handling of loop statements. All break and continue statements were collected in one list, and each loop statement taking hold of that entire list, including the breaks and continues from previous outer loops. Changed it so that loop statements contain the jump addresses themselves and set a pointer in FCompileContext, so that the jump point can be set directly in the loop statement - and an error printed if there is none in the resolving stage, not the emitting one. Consolidated the identical backpatching code of the three loop statement nodes into a subfunction.
2016-10-19 12:36:54 +00:00
ctx.Loop = this;
auto x = DoResolve(ctx);
ctx.Loop = outer;
- scriptified ArtiHealingRadius. - allow switch/case with names. - fixed break jump target handling for switch/case. This only worked when the break was in the outermost compound statement, those in inner ones were missed.
2016-11-26 23:18:07 +00:00
ctx.ControlStmt = outerctrl;
- fixed handling of loop statements. All break and continue statements were collected in one list, and each loop statement taking hold of that entire list, including the breaks and continues from previous outer loops. Changed it so that loop statements contain the jump addresses themselves and set a pointer in FCompileContext, so that the jump point can be set directly in the loop statement - and an error printed if there is none in the resolving stage, not the emitting one. Consolidated the identical backpatching code of the three loop statement nodes into a subfunction.
2016-10-19 12:36:54 +00:00
return x;
}
void FxLoopStatement::Backpatch(VMFunctionBuilder *build, size_t loopstart, size_t loopend)
{
// Give a proper address to any break/continue statement within this loop.
for (unsigned int i = 0; i < Jumps.Size(); i++)
- cleaned up the loop statement nodes in the code generator, which put some handling in FCompileContext and some of their data into the base FxExpression class instead of having an intermediate base class for all loops which is responsible for the relevant data. All this is now encapsulated in a new FxLoopStatement class which serves as base for the actual loop statements.
2016-10-15 08:34:26 +00:00
{
- fixed handling of loop statements. All break and continue statements were collected in one list, and each loop statement taking hold of that entire list, including the breaks and continues from previous outer loops. Changed it so that loop statements contain the jump addresses themselves and set a pointer in FCompileContext, so that the jump point can be set directly in the loop statement - and an error printed if there is none in the resolving stage, not the emitting one. Consolidated the identical backpatching code of the three loop statement nodes into a subfunction.
2016-10-19 12:36:54 +00:00
if (Jumps[i]->Token == TK_Break)
- cleaned up the loop statement nodes in the code generator, which put some handling in FCompileContext and some of their data into the base FxExpression class instead of having an intermediate base class for all loops which is responsible for the relevant data. All this is now encapsulated in a new FxLoopStatement class which serves as base for the actual loop statements.
2016-10-15 08:34:26 +00:00
{
- fixed handling of loop statements. All break and continue statements were collected in one list, and each loop statement taking hold of that entire list, including the breaks and continues from previous outer loops. Changed it so that loop statements contain the jump addresses themselves and set a pointer in FCompileContext, so that the jump point can be set directly in the loop statement - and an error printed if there is none in the resolving stage, not the emitting one. Consolidated the identical backpatching code of the three loop statement nodes into a subfunction.
2016-10-19 12:36:54 +00:00
build->Backpatch(Jumps[i]->Address, loopend);
}
else
{ // Continue statement.
build->Backpatch(Jumps[i]->Address, loopstart);
- cleaned up the loop statement nodes in the code generator, which put some handling in FCompileContext and some of their data into the base FxExpression class instead of having an intermediate base class for all loops which is responsible for the relevant data. All this is now encapsulated in a new FxLoopStatement class which serves as base for the actual loop statements.
2016-10-15 08:34:26 +00:00
}
}
}
Added while loops to DECORATE
2016-07-25 04:38:02 +00:00
//==========================================================================
//
// FxWhileLoop
//
//==========================================================================
FxWhileLoop::FxWhileLoop(FxExpression *condition, FxExpression *code, const FScriptPosition &pos)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxLoopStatement(EFX_WhileLoop, pos), Condition(condition), Code(code)
Added while loops to DECORATE
2016-07-25 04:38:02 +00:00
{
ValueType = TypeVoid;
}
FxWhileLoop::~FxWhileLoop()
{
SAFE_DELETE(Condition);
SAFE_DELETE(Code);
}
- fixed handling of loop statements. All break and continue statements were collected in one list, and each loop statement taking hold of that entire list, including the breaks and continues from previous outer loops. Changed it so that loop statements contain the jump addresses themselves and set a pointer in FCompileContext, so that the jump point can be set directly in the loop statement - and an error printed if there is none in the resolving stage, not the emitting one. Consolidated the identical backpatching code of the three loop statement nodes into a subfunction.
2016-10-19 12:36:54 +00:00
FxExpression *FxWhileLoop::DoResolve(FCompileContext &ctx)
Added while loops to DECORATE
2016-07-25 04:38:02 +00:00
{
CHECKRESOLVED();
SAFE_RESOLVE(Condition, ctx);
SAFE_RESOLVE_OPT(Code, ctx);
if (Condition->ValueType != TypeBool)
{
Condition = new FxBoolCast(Condition);
SAFE_RESOLVE(Condition, ctx);
}
if (Condition->isConstant())
{
if (static_cast<FxConstant *>(Condition)->GetValue().GetBool() == false)
{ // Nothing happens
FxExpression *nop = new FxNop(ScriptPosition);
delete this;
return nop;
}
else if (Code == nullptr)
{ // "while (true) { }"
// Someone could be using this for testing.
ScriptPosition.Message(MSG_WARNING, "Infinite empty loop");
}
}
return this;
}
ExpEmit FxWhileLoop::Emit(VMFunctionBuilder *build)
{
assert(Condition->ValueType == TypeBool);
size_t loopstart, loopend;
- branch optimization.
2016-12-01 23:51:29 +00:00
TArray<size_t> yes, no;
Added while loops to DECORATE
2016-07-25 04:38:02 +00:00
// Evaluate the condition and execute/break out of the loop.
loopstart = build->GetAddress();
if (!Condition->isConstant())
{
- branch optimization.
2016-12-01 23:51:29 +00:00
Condition->EmitCompare(build, false, yes, no);
Added while loops to DECORATE
2016-07-25 04:38:02 +00:00
}
else assert(static_cast<FxConstant *>(Condition)->GetValue().GetBool() == true);
- branch optimization.
2016-12-01 23:51:29 +00:00
build->BackpatchListToHere(yes);
Added while loops to DECORATE
2016-07-25 04:38:02 +00:00
// Execute the loop's content.
if (Code != nullptr)
{
- record all line numbers during function generation. This is useful for error reporting and eventually debugging. - throw a useful exception when a VM abort occurs, the simple enum was incapable of reporting anything more than the barest minimum, which at least for array index out of bounds errors was insufficient. The current exception mechanism is still insufficient. It really has to report a proper crash location and print a stack trace to the maximum extent possible. Instead it just prints a message and happily goes on. This is not a good solution.
2016-12-02 16:36:29 +00:00
Code->EmitStatement(build);
Added while loops to DECORATE
2016-07-25 04:38:02 +00:00
}
// Loop back.
build->Backpatch(build->Emit(OP_JMP, 0), loopstart);
- branch optimization.
2016-12-01 23:51:29 +00:00
build->BackpatchListToHere(no);
Added while loops to DECORATE
2016-07-25 04:38:02 +00:00
loopend = build->GetAddress();
- fixed handling of loop statements. All break and continue statements were collected in one list, and each loop statement taking hold of that entire list, including the breaks and continues from previous outer loops. Changed it so that loop statements contain the jump addresses themselves and set a pointer in FCompileContext, so that the jump point can be set directly in the loop statement - and an error printed if there is none in the resolving stage, not the emitting one. Consolidated the identical backpatching code of the three loop statement nodes into a subfunction.
2016-10-19 12:36:54 +00:00
Backpatch(build, loopstart, loopend);
Added do-while loops to DECORATE
2016-07-27 15:14:54 +00:00
return ExpEmit();
}
//==========================================================================
//
// FxDoWhileLoop
//
//==========================================================================
FxDoWhileLoop::FxDoWhileLoop(FxExpression *condition, FxExpression *code, const FScriptPosition &pos)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxLoopStatement(EFX_DoWhileLoop, pos), Condition(condition), Code(code)
Added do-while loops to DECORATE
2016-07-27 15:14:54 +00:00
{
ValueType = TypeVoid;
}
FxDoWhileLoop::~FxDoWhileLoop()
{
SAFE_DELETE(Condition);
SAFE_DELETE(Code);
}
- fixed handling of loop statements. All break and continue statements were collected in one list, and each loop statement taking hold of that entire list, including the breaks and continues from previous outer loops. Changed it so that loop statements contain the jump addresses themselves and set a pointer in FCompileContext, so that the jump point can be set directly in the loop statement - and an error printed if there is none in the resolving stage, not the emitting one. Consolidated the identical backpatching code of the three loop statement nodes into a subfunction.
2016-10-19 12:36:54 +00:00
FxExpression *FxDoWhileLoop::DoResolve(FCompileContext &ctx)
Added do-while loops to DECORATE
2016-07-27 15:14:54 +00:00
{
CHECKRESOLVED();
SAFE_RESOLVE(Condition, ctx);
SAFE_RESOLVE_OPT(Code, ctx);
if (Condition->ValueType != TypeBool)
{
Condition = new FxBoolCast(Condition);
SAFE_RESOLVE(Condition, ctx);
}
if (Condition->isConstant())
{
if (static_cast<FxConstant *>(Condition)->GetValue().GetBool() == false)
{ // The code executes once, if any.
- fixed handling of loop statements. All break and continue statements were collected in one list, and each loop statement taking hold of that entire list, including the breaks and continues from previous outer loops. Changed it so that loop statements contain the jump addresses themselves and set a pointer in FCompileContext, so that the jump point can be set directly in the loop statement - and an error printed if there is none in the resolving stage, not the emitting one. Consolidated the identical backpatching code of the three loop statement nodes into a subfunction.
2016-10-19 12:36:54 +00:00
if (Jumps.Size() == 0)
Added do-while loops to DECORATE
2016-07-27 15:14:54 +00:00
{ // We would still have to handle the jumps however.
FxExpression *e = Code;
if (e == nullptr) e = new FxNop(ScriptPosition);
Code = nullptr;
delete this;
return e;
}
}
else if (Code == nullptr)
{ // "do { } while (true);"
// Someone could be using this for testing.
ScriptPosition.Message(MSG_WARNING, "Infinite empty loop");
}
}
return this;
}
ExpEmit FxDoWhileLoop::Emit(VMFunctionBuilder *build)
{
assert(Condition->ValueType == TypeBool);
size_t loopstart, loopend;
size_t codestart;
// Execute the loop's content.
codestart = build->GetAddress();
if (Code != nullptr)
{
- record all line numbers during function generation. This is useful for error reporting and eventually debugging. - throw a useful exception when a VM abort occurs, the simple enum was incapable of reporting anything more than the barest minimum, which at least for array index out of bounds errors was insufficient. The current exception mechanism is still insufficient. It really has to report a proper crash location and print a stack trace to the maximum extent possible. Instead it just prints a message and happily goes on. This is not a good solution.
2016-12-02 16:36:29 +00:00
Code->EmitStatement(build);
Added do-while loops to DECORATE
2016-07-27 15:14:54 +00:00
}
// Evaluate the condition and execute/break out of the loop.
loopstart = build->GetAddress();
if (!Condition->isConstant())
{
- branch optimization.
2016-12-01 23:51:29 +00:00
TArray<size_t> yes, no;
Condition->EmitCompare(build, true, yes, no);
build->BackpatchList(no, codestart);
build->BackpatchListToHere(yes);
Added do-while loops to DECORATE
2016-07-27 15:14:54 +00:00
}
else if (static_cast<FxConstant *>(Condition)->GetValue().GetBool() == true)
{ // Always looping
build->Backpatch(build->Emit(OP_JMP, 0), codestart);
}
loopend = build->GetAddress();
- fixed handling of loop statements. All break and continue statements were collected in one list, and each loop statement taking hold of that entire list, including the breaks and continues from previous outer loops. Changed it so that loop statements contain the jump addresses themselves and set a pointer in FCompileContext, so that the jump point can be set directly in the loop statement - and an error printed if there is none in the resolving stage, not the emitting one. Consolidated the identical backpatching code of the three loop statement nodes into a subfunction.
2016-10-19 12:36:54 +00:00
Backpatch(build, loopstart, loopend);
Added for loops to DECORATE
2016-07-28 15:36:05 +00:00
return ExpEmit();
}
//==========================================================================
//
// FxForLoop
//
//==========================================================================
FxForLoop::FxForLoop(FxExpression *init, FxExpression *condition, FxExpression *iteration, FxExpression *code, const FScriptPosition &pos)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxLoopStatement(EFX_ForLoop, pos), Init(init), Condition(condition), Iteration(iteration), Code(code)
Added for loops to DECORATE
2016-07-28 15:36:05 +00:00
{
ValueType = TypeVoid;
- scriptified the functions in a_possessed.cpp and added the needed exports and constants. - fixed: Script functions did not receive the function name when being created. - relaxed the asserts for PARAM_STATE, because the VM knows nothing about ATAG_STATE. Any state variable's content (e.g. Actor.SeeState) will receive ATAG_GENERIC, rather than ATAG_STATE. - added a 'NeedResult' flag so that certain operations can create shorter code if the result of the expression is not needed. So far only used for postdecrement/increment statements on local variables (which is the most frequent case where this matters.) - fixed postincrement and decrement for local variables. Due to the result preservation semantics it created faulty code.
2016-10-26 09:30:30 +00:00
if (Iteration != nullptr) Iteration->NeedResult = false;
if (Code != nullptr) Code->NeedResult = false;
Added for loops to DECORATE
2016-07-28 15:36:05 +00:00
}
FxForLoop::~FxForLoop()
{
SAFE_DELETE(Init);
SAFE_DELETE(Condition);
SAFE_DELETE(Iteration);
SAFE_DELETE(Code);
}
- fixed handling of loop statements. All break and continue statements were collected in one list, and each loop statement taking hold of that entire list, including the breaks and continues from previous outer loops. Changed it so that loop statements contain the jump addresses themselves and set a pointer in FCompileContext, so that the jump point can be set directly in the loop statement - and an error printed if there is none in the resolving stage, not the emitting one. Consolidated the identical backpatching code of the three loop statement nodes into a subfunction.
2016-10-19 12:36:54 +00:00
FxExpression *FxForLoop::DoResolve(FCompileContext &ctx)
Added for loops to DECORATE
2016-07-28 15:36:05 +00:00
{
CHECKRESOLVED();
SAFE_RESOLVE_OPT(Init, ctx);
SAFE_RESOLVE_OPT(Condition, ctx);
SAFE_RESOLVE_OPT(Iteration, ctx);
SAFE_RESOLVE_OPT(Code, ctx);
if (Condition != nullptr)
{
if (Condition->ValueType != TypeBool)
{
Condition = new FxBoolCast(Condition);
SAFE_RESOLVE(Condition, ctx);
}
if (Condition->isConstant())
{
if (static_cast<FxConstant *>(Condition)->GetValue().GetBool() == false)
{ // Nothing happens
FxExpression *nop = new FxNop(ScriptPosition);
delete this;
return nop;
}
else
{ // "for (..; true; ..)"
delete Condition;
Condition = nullptr;
}
}
}
if (Condition == nullptr && Code == nullptr)
{ // "for (..; ; ..) { }"
// Someone could be using this for testing.
ScriptPosition.Message(MSG_WARNING, "Infinite empty loop");
}
return this;
}
ExpEmit FxForLoop::Emit(VMFunctionBuilder *build)
{
assert((Condition && Condition->ValueType == TypeBool && !Condition->isConstant()) || Condition == nullptr);
size_t loopstart, loopend;
size_t codestart;
- branch optimization for for loops.
2016-12-01 23:56:54 +00:00
TArray<size_t> yes, no;
Added for loops to DECORATE
2016-07-28 15:36:05 +00:00
- fixed handling of loop statements. All break and continue statements were collected in one list, and each loop statement taking hold of that entire list, including the breaks and continues from previous outer loops. Changed it so that loop statements contain the jump addresses themselves and set a pointer in FCompileContext, so that the jump point can be set directly in the loop statement - and an error printed if there is none in the resolving stage, not the emitting one. Consolidated the identical backpatching code of the three loop statement nodes into a subfunction.
2016-10-19 12:36:54 +00:00
// Init statement (only used by DECORATE. ZScript is pulling it before the loop statement and enclosing the entire loop in a compound statement so that Init can have local variables.)
Added for loops to DECORATE
2016-07-28 15:36:05 +00:00
if (Init != nullptr)
{
ExpEmit init = Init->Emit(build);
init.Free(build);
}
// Evaluate the condition and execute/break out of the loop.
codestart = build->GetAddress();
if (Condition != nullptr)
{
- branch optimization for for loops.
2016-12-01 23:56:54 +00:00
Condition->EmitCompare(build, false, yes, no);
Added for loops to DECORATE
2016-07-28 15:36:05 +00:00
}
- branch optimization for for loops.
2016-12-01 23:56:54 +00:00
build->BackpatchListToHere(yes);
Added for loops to DECORATE
2016-07-28 15:36:05 +00:00
// Execute the loop's content.
if (Code != nullptr)
{
- record all line numbers during function generation. This is useful for error reporting and eventually debugging. - throw a useful exception when a VM abort occurs, the simple enum was incapable of reporting anything more than the barest minimum, which at least for array index out of bounds errors was insufficient. The current exception mechanism is still insufficient. It really has to report a proper crash location and print a stack trace to the maximum extent possible. Instead it just prints a message and happily goes on. This is not a good solution.
2016-12-02 16:36:29 +00:00
Code->EmitStatement(build);
Added for loops to DECORATE
2016-07-28 15:36:05 +00:00
}
// Iteration statement.
loopstart = build->GetAddress();
if (Iteration != nullptr)
{
ExpEmit iter = Iteration->Emit(build);
iter.Free(build);
}
build->Backpatch(build->Emit(OP_JMP, 0), codestart);
// End of loop.
loopend = build->GetAddress();
- branch optimization for for loops.
2016-12-01 23:56:54 +00:00
build->BackpatchListToHere(no);
Added for loops to DECORATE
2016-07-28 15:36:05 +00:00
- fixed handling of loop statements. All break and continue statements were collected in one list, and each loop statement taking hold of that entire list, including the breaks and continues from previous outer loops. Changed it so that loop statements contain the jump addresses themselves and set a pointer in FCompileContext, so that the jump point can be set directly in the loop statement - and an error printed if there is none in the resolving stage, not the emitting one. Consolidated the identical backpatching code of the three loop statement nodes into a subfunction.
2016-10-19 12:36:54 +00:00
Backpatch(build, loopstart, loopend);
Added while loops to DECORATE
2016-07-25 04:38:02 +00:00
return ExpEmit();
}
DECORATE can now handle jump statements break and continue were added but are not yet useable anywhere This was made general enough so that loops and switch statements that accept breaks/continues can be done without much difficulty as well as goto statements with explicit labels if those are ever wanted
2016-07-26 21:57:26 +00:00
//==========================================================================
//
// FxJumpStatement
//
//==========================================================================
FxJumpStatement::FxJumpStatement(int token, const FScriptPosition &pos)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_JumpStatement, pos), Token(token)
DECORATE can now handle jump statements break and continue were added but are not yet useable anywhere This was made general enough so that loops and switch statements that accept breaks/continues can be done without much difficulty as well as goto statements with explicit labels if those are ever wanted
2016-07-26 21:57:26 +00:00
{
ValueType = TypeVoid;
}
FxExpression *FxJumpStatement::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
- scriptified ArtiHealingRadius. - allow switch/case with names. - fixed break jump target handling for switch/case. This only worked when the break was in the outermost compound statement, those in inner ones were missed.
2016-11-26 23:18:07 +00:00
if (ctx.ControlStmt != nullptr)
- fixed handling of loop statements. All break and continue statements were collected in one list, and each loop statement taking hold of that entire list, including the breaks and continues from previous outer loops. Changed it so that loop statements contain the jump addresses themselves and set a pointer in FCompileContext, so that the jump point can be set directly in the loop statement - and an error printed if there is none in the resolving stage, not the emitting one. Consolidated the identical backpatching code of the three loop statement nodes into a subfunction.
2016-10-19 12:36:54 +00:00
{
- scriptified ArtiHealingRadius. - allow switch/case with names. - fixed break jump target handling for switch/case. This only worked when the break was in the outermost compound statement, those in inner ones were missed.
2016-11-26 23:18:07 +00:00
if (ctx.ControlStmt == ctx.Loop || Token == TK_Continue)
{
ctx.Loop->Jumps.Push(this);
}
else
{
// break in switch.
static_cast<FxSwitchStatement*>(ctx.ControlStmt)->Breaks.Push(this);
}
- fixed handling of loop statements. All break and continue statements were collected in one list, and each loop statement taking hold of that entire list, including the breaks and continues from previous outer loops. Changed it so that loop statements contain the jump addresses themselves and set a pointer in FCompileContext, so that the jump point can be set directly in the loop statement - and an error printed if there is none in the resolving stage, not the emitting one. Consolidated the identical backpatching code of the three loop statement nodes into a subfunction.
2016-10-19 12:36:54 +00:00
return this;
}
else
{
ScriptPosition.Message(MSG_ERROR, "'%s' outside of a loop", Token == TK_Break ? "break" : "continue");
delete this;
return nullptr;
}
DECORATE can now handle jump statements break and continue were added but are not yet useable anywhere This was made general enough so that loops and switch statements that accept breaks/continues can be done without much difficulty as well as goto statements with explicit labels if those are ever wanted
2016-07-26 21:57:26 +00:00
}
ExpEmit FxJumpStatement::Emit(VMFunctionBuilder *build)
{
Address = build->Emit(OP_JMP, 0);
return ExpEmit();
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
//==========================================================================
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
FxReturnStatement::FxReturnStatement(FxExpression *value, const FScriptPosition &pos)
- implemented processing of multiple return values in script functions.
2017-01-18 00:27:50 +00:00
: FxExpression(EFX_ReturnStatement, pos)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- implemented processing of multiple return values in script functions.
2017-01-18 00:27:50 +00:00
if (value != nullptr) Args.Push(value);
ValueType = TypeVoid;
}
FxReturnStatement::FxReturnStatement(FArgumentList &values, const FScriptPosition &pos)
: FxExpression(EFX_ReturnStatement, pos)
{
Args = std::move(values);
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
ValueType = TypeVoid;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
FxReturnStatement::~FxReturnStatement()
{
}
FxExpression *FxReturnStatement::Resolve(FCompileContext &ctx)
{
- implemented processing of multiple return values in script functions.
2017-01-18 00:27:50 +00:00
bool fail = false;
Normalize line endings
2016-03-01 15:47:10 +00:00
CHECKRESOLVED();
- implemented processing of multiple return values in script functions.
2017-01-18 00:27:50 +00:00
for (auto &Value : Args)
{
SAFE_RESOLVE_OPT(Value, ctx);
fail |= (Value == nullptr);
}
if (fail)
{
delete this;
return nullptr;
}
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
PPrototype *retproto;
- implemented processing of multiple return values in script functions.
2017-01-18 00:27:50 +00:00
if (Args.Size() == 0)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
TArray<PType *> none(0);
retproto = NewPrototype(none, none);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- implemented processing of multiple return values in script functions.
2017-01-18 00:27:50 +00:00
else if (Args.Size() == 1)
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
{
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
// If we already know the real return type we need at least try to cast the value to its proper type (unless in an anonymous function.)
- scriptified two of the Acolyte's functions. - added a DActorIterator class. - fixed: It was not possible to have functions of the same name in two different classes because the name they were searched for was not qualified by the class. Changed so that the class name is included now, but to avoid renaming several hundreds of functions all at once, if the search fails, it will repeat with 'Actor' as class name. This commit contains preparations for scriptifying Hexen's Dragon, but that doesn't work yet so it's not included.
2016-11-16 00:36:21 +00:00
if (ctx.ReturnProto != nullptr && ctx.ReturnProto->ReturnTypes.Size() > 0 && ctx.Function->SymbolName != NAME_None)
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
{
- implemented processing of multiple return values in script functions.
2017-01-18 00:27:50 +00:00
Args[0] = new FxTypeCast(Args[0], ctx.ReturnProto->ReturnTypes[0], false, false);
Args[0] = Args[0]->Resolve(ctx);
ABORT(Args[0]);
}
retproto = Args[0]->ReturnProto();
}
else if (ctx.ReturnProto != nullptr && ctx.ReturnProto->ReturnTypes.Size() == Args.Size())
{
for (unsigned i = 0; i < Args.Size(); i++)
{
more inventory scriptification * completely scriptified DehackedPickup and FakeInventory. * scriptified all remaining virtual functions of Inventory, so that its inheritance is now 100% script-side. * scriptified CallTryPickup and most of the code called by that. - fixed: Passing local variables by reference did not work in the VM.
2017-01-19 22:42:12 +00:00
Args[i] = new FxTypeCast(Args[i], ctx.ReturnProto->ReturnTypes[i], false, false);
Args[i] = Args[i]->Resolve(ctx);
if (Args[i] == nullptr) fail = true;
- implemented processing of multiple return values in script functions.
2017-01-18 00:27:50 +00:00
}
if (fail)
{
delete this;
return nullptr;
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
}
- implemented processing of multiple return values in script functions.
2017-01-18 00:27:50 +00:00
return this; // no point calling CheckReturn here.
}
else
{
ScriptPosition.Message(MSG_ERROR, "Incorrect number of return values. Got %u, but expected %u", Args.Size(), ctx.ReturnProto->ReturnTypes.Size());
delete this;
return nullptr;
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
}
ctx.CheckReturn(retproto, ScriptPosition);
Normalize line endings
2016-03-01 15:47:10 +00:00
return this;
}
ExpEmit FxReturnStatement::Emit(VMFunctionBuilder *build)
{
- implemented processing of multiple return values in script functions.
2017-01-18 00:27:50 +00:00
TArray<ExpEmit> outs;
Fixed: a register from a return statement's value would not be freed
2016-08-14 17:23:28 +00:00
ExpEmit out(0, REGT_NIL);
- implemented processing of multiple return values in script functions.
2017-01-18 00:27:50 +00:00
// If there's structs to destroy here we need to emit all returns before destroying them.
if (build->ConstructedStructs.Size())
{
for (auto ret : Args)
{
ExpEmit r = ret->Emit(build);
outs.Push(r);
}
}
- added the ability to attach a constructor or destructor to an internally defined struct. There are a few which require explicit native construction or destruction that need to be exported to the VM, e.g. FCheckPosition. The VM cannot handle this directly, it needs two special functions to be attached to handle such elements.
2017-01-11 22:46:03 +00:00
// call the destructors for all structs requiring one.
// go in reverse order of construction
for (int i = build->ConstructedStructs.Size() - 1; i >= 0; i--)
{
auto pstr = static_cast<PStruct*>(build->ConstructedStructs[i]->ValueType);
assert(pstr->mDestructor != nullptr);
ExpEmit reg(build, REGT_POINTER);
build->Emit(OP_ADDA_RK, reg.RegNum, build->FramePointer.RegNum, build->GetConstantInt(build->ConstructedStructs[i]->StackOffset));
build->Emit(OP_PARAM, 0, reg.RegType, reg.RegNum);
build->Emit(OP_CALL_K, build->GetConstantAddress(pstr->mDestructor, ATAG_OBJECT), 1, 0);
reg.Free(build);
}
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
// If we return nothing, use a regular RET opcode.
// Otherwise just return the value we're given.
- implemented processing of multiple return values in script functions.
2017-01-18 00:27:50 +00:00
if (Args.Size() == 0)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
build->Emit(OP_RET, RET_FINAL, REGT_NIL, 0);
}
- implemented processing of multiple return values in script functions.
2017-01-18 00:27:50 +00:00
else if (Args.Size() == 1)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- implemented processing of multiple return values in script functions.
2017-01-18 00:27:50 +00:00
out = outs.Size() > 0? outs[0] : Args[0]->Emit(build);
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
// Check if it is a function call that simplified itself
// into a tail call in which case we don't emit anything.
Fixed: a register from a return statement's value would not be freed
2016-08-14 17:23:28 +00:00
if (!out.Final)
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
{
- implemented processing of multiple return values in script functions.
2017-01-18 00:27:50 +00:00
if (Args[0]->ValueType == TypeVoid)
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
{ // Nothing is returned.
build->Emit(OP_RET, RET_FINAL, REGT_NIL, 0);
}
else
{
Make sure to use the REGT_MULTIREG flags for opcodes that need it
2016-10-30 05:17:37 +00:00
build->Emit(OP_RET, RET_FINAL, EncodeRegType(out), out.RegNum);
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
}
}
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- implemented processing of multiple return values in script functions.
2017-01-18 00:27:50 +00:00
else
{
for (unsigned i = 0; i < Args.Size(); i++)
{
out = outs.Size() > 0 ? outs[i] : Args[i]->Emit(build);
build->Emit(OP_RET, i < Args.Size() - 1 ? i : i+RET_FINAL, EncodeRegType(out), out.RegNum);
}
}
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
out.Final = true;
return out;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
VMFunction *FxReturnStatement::GetDirectFunction()
{
- implemented processing of multiple return values in script functions.
2017-01-18 00:27:50 +00:00
if (Args.Size() == 1)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- implemented processing of multiple return values in script functions.
2017-01-18 00:27:50 +00:00
return Args[0]->GetDirectFunction();
Normalize line endings
2016-03-01 15:47:10 +00:00
}
The return statement now accepts any expression as its return value So something like 'return ++user_x;' is now possible Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
2016-08-02 16:50:34 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
//==========================================================================
- fixed: only explicit class type casts must obey strict namespace rules, i.e. only '(class<type>)(variable_to_cast)' The general rule is as follows: A class name as a string will always be looked up fully, even if the class name gets shadows by another variable because strings are not identifiers. It is only class names as identifiers that must obey the rule that if it is not known yet or hidden by something else that it may not be found to ensure that the older variable does not take over the name if it gets reused.
2017-01-24 09:04:46 +00:00
FxClassTypeCast::FxClassTypeCast(PClassPointer *dtype, FxExpression *x, bool explicitily)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_ClassTypeCast, x->ScriptPosition)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- 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
ValueType = dtype;
desttype = dtype->ClassRestriction;
Normalize line endings
2016-03-01 15:47:10 +00:00
basex=x;
- fixed: only explicit class type casts must obey strict namespace rules, i.e. only '(class<type>)(variable_to_cast)' The general rule is as follows: A class name as a string will always be looked up fully, even if the class name gets shadows by another variable because strings are not identifiers. It is only class names as identifiers that must obey the rule that if it is not known yet or hidden by something else that it may not be found to ensure that the older variable does not take over the name if it gets reused.
2017-01-24 09:04:46 +00:00
Explicit = explicitily;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
//
//
//==========================================================================
FxClassTypeCast::~FxClassTypeCast()
{
SAFE_DELETE(basex);
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxClassTypeCast::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE(basex, ctx);
- 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
- preparations for null pointer support. - add pointer support to FxAssign.
2016-10-21 17:18:39 +00:00
if (basex->ValueType == TypeNullPtr)
{
basex->ValueType = ValueType;
auto x = basex;
basex = nullptr;
delete this;
return x;
}
- better fix for the class type problem: We already know the wanted type so let's use that instead of trying to determine it from the actual name.
2016-10-22 17:51:24 +00:00
auto to = static_cast<PClassPointer *>(ValueType);
- 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
if (basex->ValueType->GetClass() == RUNTIME_CLASS(PClassPointer))
{
auto from = static_cast<PClassPointer *>(basex->ValueType);
if (from->ClassRestriction->IsDescendantOf(to->ClassRestriction))
{
basex->ValueType = to;
auto x = basex;
basex = nullptr;
delete this;
return x;
}
ScriptPosition.Message(MSG_ERROR, "Cannot convert from %s to %s: Incompatible class types", from->ClassRestriction->TypeName.GetChars(), to->ClassRestriction->TypeName.GetChars());
delete this;
return nullptr;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
- 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
if (basex->ValueType != TypeName && basex->ValueType != TypeString)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- 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
ScriptPosition.Message(MSG_ERROR, "Cannot convert %s to class type", basex->ValueType->DescriptiveName());
Normalize line endings
2016-03-01 15:47:10 +00:00
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
if (basex->isConstant())
{
FName clsname = static_cast<FxConstant *>(basex)->GetValue().GetName();
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
PClass *cls = nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (clsname != NAME_None)
{
- fixed: only explicit class type casts must obey strict namespace rules, i.e. only '(class<type>)(variable_to_cast)' The general rule is as follows: A class name as a string will always be looked up fully, even if the class name gets shadows by another variable because strings are not identifiers. It is only class names as identifiers that must obey the rule that if it is not known yet or hidden by something else that it may not be found to ensure that the older variable does not take over the name if it gets reused.
2017-01-24 09:04:46 +00:00
if (Explicit) cls = FindClassType(clsname, ctx);
else cls = PClass::FindClass(clsname);
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
if (cls == nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
/* lax */
// Since this happens in released WADs it must pass without a terminal error... :(
- 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
ScriptPosition.Message(MSG_OPTERROR,
Fixed additional format string warning reported by GCC/Clang See https://forum.zdoom.org/viewtopic.php?t=54541
2016-12-24 12:34:45 +00:00
"Unknown class name '%s' of type '%s'",
Normalize line endings
2016-03-01 15:47:10 +00:00
clsname.GetChars(), desttype->TypeName.GetChars());
}
else
{
if (!cls->IsDescendantOf(desttype))
{
- relaxed the message for incompatible class types in DECORATE to a warning. Like finding no class at all here, this initially fell under a situation that was not discoverable and there's mods that break by making it a fatal error.
2016-11-15 14:34:00 +00:00
ScriptPosition.Message(MSG_OPTERROR, "class '%s' is not compatible with '%s'", clsname.GetChars(), desttype->TypeName.GetChars());
cls = nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- relaxed the message for incompatible class types in DECORATE to a warning. Like finding no class at all here, this initially fell under a situation that was not discoverable and there's mods that break by making it a fatal error.
2016-11-15 14:34:00 +00:00
else ScriptPosition.Message(MSG_DEBUGLOG, "resolving '%s' as class name", clsname.GetChars());
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
- better fix for the class type problem: We already know the wanted type so let's use that instead of trying to determine it from the actual name.
2016-10-22 17:51:24 +00:00
FxExpression *x = new FxConstant(cls, to, ScriptPosition);
Normalize line endings
2016-03-01 15:47:10 +00:00
delete this;
return x;
}
- 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
if (basex->ValueType == TypeString)
{
basex = new FxNameCast(basex);
}
Normalize line endings
2016-03-01 15:47:10 +00:00
return this;
}
//==========================================================================
//
//
//
//==========================================================================
- allow the VM to run on one global stack per thread. It is utterly pointless to require every function that wants to make a VM call to allocate a new stack first. The allocation overhead doubles the time to set up the call. With one stack, previously allocated memory can be reused. The only important thing is, if this ever gets used in a multithreaded environment to have the stack being declared as thread_local, although for ZDoom this is of no consequence. - eliminated all cases where native code was calling other native code through the VM interface. After scriptifying the game code, only 5 places were left which were quickly eliminated. This was mostly to ensure that the native VM function parameters do not need to be propagated further than absolutely necessary.
2016-11-30 16:15:01 +00:00
int BuiltinNameToClass(VMValue *param, TArray<VMValue> &defaultparam, int numparam, VMReturn *ret, int numret)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
assert(numparam == 2);
assert(numret == 1);
assert(param[0].Type == REGT_INT);
assert(param[1].Type == REGT_POINTER);
assert(ret->RegType == REGT_POINTER);
FName clsname = ENamedName(param[0].i);
- fixed: BuiltinNameToClass should treat NAME_None as 'nothing'. It's names that get here, after all, so the name for 'nothing' should actually mean 'nothing' here.
2016-11-25 11:45:17 +00:00
if (clsname != NAME_None)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- fixed: BuiltinNameToClass should treat NAME_None as 'nothing'. It's names that get here, after all, so the name for 'nothing' should actually mean 'nothing' here.
2016-11-25 11:45:17 +00:00
const PClass *cls = PClass::FindClass(clsname);
const PClass *desttype = reinterpret_cast<PClass *>(param[1].a);
if (!cls->IsDescendantOf(desttype))
{
- make dynamic object casts a dedicated VM instruction instead of a builtin function. This can see some heavy use in iterators where saving several hundreds of function calls can be achieved. In these cases, using a function to do the job will become a significant time waster.
2016-12-05 13:52:34 +00:00
// Let the caller check this. Making this an error with a message is only taking away options from the user.
- fixed: BuiltinNameToClass should treat NAME_None as 'nothing'. It's names that get here, after all, so the name for 'nothing' should actually mean 'nothing' here.
2016-11-25 11:45:17 +00:00
cls = nullptr;
}
ret->SetPointer(const_cast<PClass *>(cls), ATAG_OBJECT);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- fixed: BuiltinNameToClass should treat NAME_None as 'nothing'. It's names that get here, after all, so the name for 'nothing' should actually mean 'nothing' here.
2016-11-25 11:45:17 +00:00
else ret->SetPointer(nullptr, ATAG_OBJECT);
Normalize line endings
2016-03-01 15:47:10 +00:00
return 1;
}
ExpEmit FxClassTypeCast::Emit(VMFunctionBuilder *build)
{
if (basex->ValueType != TypeName)
{
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return ExpEmit(build->GetConstantAddress(nullptr, ATAG_OBJECT), REGT_POINTER, true);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
ExpEmit clsname = basex->Emit(build);
assert(!clsname.Konst);
ExpEmit dest(build, REGT_POINTER);
build->Emit(OP_PARAM, 0, clsname.RegType, clsname.RegNum);
build->Emit(OP_PARAM, 0, REGT_POINTER | REGT_KONST, build->GetConstantAddress(const_cast<PClass *>(desttype), ATAG_OBJECT));
- implemented the 'is' operator (i.e. class type check.)
2016-10-29 23:05:56 +00:00
// Call the BuiltinNameToClass function to convert from 'name' to class.
Normalize line endings
2016-03-01 15:47:10 +00:00
VMFunction *callfunc;
- implemented the 'is' operator (i.e. class type check.)
2016-10-29 23:05:56 +00:00
PSymbol *sym = FindBuiltinFunction(NAME_BuiltinNameToClass, BuiltinNameToClass);
Normalize line endings
2016-03-01 15:47:10 +00:00
assert(sym->IsKindOf(RUNTIME_CLASS(PSymbolVMFunction)));
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
assert(((PSymbolVMFunction *)sym)->Function != nullptr);
Normalize line endings
2016-03-01 15:47:10 +00:00
callfunc = ((PSymbolVMFunction *)sym)->Function;
build->Emit(OP_CALL_K, build->GetConstantAddress(callfunc, ATAG_OBJECT), 2, 1);
build->Emit(OP_RESULT, 0, REGT_POINTER, dest.RegNum);
clsname.Free(build);
return dest;
}
added class pointer casts. Due to grammar problems the type has to be put into parentheses to get the class token out of the global parsing namespace: class<Actor> myclass = (class<Actor>)(GetClass());
2016-11-17 19:31:53 +00:00
//==========================================================================
//
//==========================================================================
FxClassPtrCast::FxClassPtrCast(PClass *dtype, FxExpression *x)
: FxExpression(EFX_ClassPtrCast, x->ScriptPosition)
{
ValueType = NewClassPointer(dtype);
desttype = dtype;
basex = x;
}
//==========================================================================
//
//
//
//==========================================================================
FxClassPtrCast::~FxClassPtrCast()
{
SAFE_DELETE(basex);
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxClassPtrCast::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE(basex, ctx);
if (basex->ValueType == TypeNullPtr)
{
basex->ValueType = ValueType;
auto x = basex;
basex = nullptr;
delete this;
return x;
}
auto to = static_cast<PClassPointer *>(ValueType);
if (basex->ValueType->GetClass() == RUNTIME_CLASS(PClassPointer))
{
auto from = static_cast<PClassPointer *>(basex->ValueType);
// Downcast is always ok.
if (from->ClassRestriction->IsDescendantOf(to->ClassRestriction))
{
basex->ValueType = to;
auto x = basex;
basex = nullptr;
delete this;
return x;
}
// Upcast needs a runtime check.
else if (to->ClassRestriction->IsDescendantOf(from->ClassRestriction))
{
return this;
}
}
- scriptified the remaining Doom weapon code. - implemented method calls from struct instances. - optimized disassembly of VM call instructions to print the function's name at the end where it is more visible and does not need to be truncated. Also use the printable name for script functions here.
2016-11-20 11:27:26 +00:00
else if (basex->ValueType == TypeString || basex->ValueType == TypeName)
{
- fixed: only explicit class type casts must obey strict namespace rules, i.e. only '(class<type>)(variable_to_cast)' The general rule is as follows: A class name as a string will always be looked up fully, even if the class name gets shadows by another variable because strings are not identifiers. It is only class names as identifiers that must obey the rule that if it is not known yet or hidden by something else that it may not be found to ensure that the older variable does not take over the name if it gets reused.
2017-01-24 09:04:46 +00:00
FxExpression *x = new FxClassTypeCast(to, basex, true);
- scriptified the remaining Doom weapon code. - implemented method calls from struct instances. - optimized disassembly of VM call instructions to print the function's name at the end where it is more visible and does not need to be truncated. Also use the printable name for script functions here.
2016-11-20 11:27:26 +00:00
basex = nullptr;
delete this;
return x->Resolve(ctx);
}
added class pointer casts. Due to grammar problems the type has to be put into parentheses to get the class token out of the global parsing namespace: class<Actor> myclass = (class<Actor>)(GetClass());
2016-11-17 19:31:53 +00:00
// Everything else is an error.
ScriptPosition.Message(MSG_ERROR, "Cannot cast %s to %s. The types are incompatible.", basex->ValueType->DescriptiveName(), to->DescriptiveName());
delete this;
return nullptr;
}
//==========================================================================
//
//
//
//==========================================================================
- allow the VM to run on one global stack per thread. It is utterly pointless to require every function that wants to make a VM call to allocate a new stack first. The allocation overhead doubles the time to set up the call. With one stack, previously allocated memory can be reused. The only important thing is, if this ever gets used in a multithreaded environment to have the stack being declared as thread_local, although for ZDoom this is of no consequence. - eliminated all cases where native code was calling other native code through the VM interface. After scriptifying the game code, only 5 places were left which were quickly eliminated. This was mostly to ensure that the native VM function parameters do not need to be propagated further than absolutely necessary.
2016-11-30 16:15:01 +00:00
int BuiltinClassCast(VMValue *param, TArray<VMValue> &defaultparam, int numparam, VMReturn *ret, int numret)
added class pointer casts. Due to grammar problems the type has to be put into parentheses to get the class token out of the global parsing namespace: class<Actor> myclass = (class<Actor>)(GetClass());
2016-11-17 19:31:53 +00:00
{
PARAM_PROLOGUE;
PARAM_CLASS(from, DObject);
PARAM_CLASS(to, DObject);
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
ACTION_RETURN_OBJECT(from && to && from->IsDescendantOf(to) ? from : nullptr);
added class pointer casts. Due to grammar problems the type has to be put into parentheses to get the class token out of the global parsing namespace: class<Actor> myclass = (class<Actor>)(GetClass());
2016-11-17 19:31:53 +00:00
}
ExpEmit FxClassPtrCast::Emit(VMFunctionBuilder *build)
{
ExpEmit clsname = basex->Emit(build);
build->Emit(OP_PARAM, 0, clsname.RegType, clsname.RegNum);
build->Emit(OP_PARAM, 0, REGT_POINTER | REGT_KONST, build->GetConstantAddress(desttype, ATAG_OBJECT));
VMFunction *callfunc;
PSymbol *sym = FindBuiltinFunction(NAME_BuiltinClassCast, BuiltinClassCast);
assert(sym->IsKindOf(RUNTIME_CLASS(PSymbolVMFunction)));
assert(((PSymbolVMFunction *)sym)->Function != nullptr);
callfunc = ((PSymbolVMFunction *)sym)->Function;
clsname.Free(build);
ExpEmit dest(build, REGT_POINTER);
build->Emit(OP_CALL_K, build->GetConstantAddress(callfunc, ATAG_OBJECT), 2, 1);
build->Emit(OP_RESULT, 0, REGT_POINTER, dest.RegNum);
return dest;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
// Symbolic state labels.
// Conversion will not happen inside the compiler anymore because it causes
// just too many problems.
Normalize line endings
2016-03-01 15:47:10 +00:00
//
//==========================================================================
FxExpression *FxStateByIndex::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
Fixed: the game could crash while parsing expressions in some places
2016-08-04 17:45:24 +00:00
ABORT(ctx.Class);
- separated the code generation from the DECORATE parser and cleaned up the interface to the code generator. Most importantly, the VMScriptFunctions are now preallocated when being added to the list of functions to compile and will be filled in later by the code generator. This allowed the removal of some ugly maintenance code.
2016-10-12 22:53:59 +00:00
auto aclass = dyn_cast<PClassActor>(ctx.Class);
Fixed: the game could crash while parsing expressions in some places
2016-08-04 17:45:24 +00:00
- don't run constant state indices through the runtime checker.
2016-11-05 17:15:53 +00:00
// This expression type can only be used from actors, for everything else it has already produced a compile error.
- separated the code generation from the DECORATE parser and cleaned up the interface to the code generator. Most importantly, the VMScriptFunctions are now preallocated when being added to the list of functions to compile and will be filled in later by the code generator. This allowed the removal of some ugly maintenance code.
2016-10-12 22:53:59 +00:00
assert(aclass != nullptr && aclass->NumOwnedStates > 0);
if (aclass->NumOwnedStates <= index)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
ScriptPosition.Message(MSG_ERROR, "%s: Attempt to jump to non existing state index %d",
DECORATE can now handle jump statements break and continue were added but are not yet useable anywhere This was made general enough so that loops and switch statements that accept breaks/continues can be done without much difficulty as well as goto statements with explicit labels if those are ever wanted
2016-07-26 21:57:26 +00:00
ctx.Class->TypeName.GetChars(), index);
Normalize line endings
2016-03-01 15:47:10 +00:00
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
int symlabel = StateLabels.AddPointer(aclass->OwnedStates + index);
FxExpression *x = new FxConstant(symlabel, ScriptPosition);
x->ValueType = TypeStateLabel;
Normalize line endings
2016-03-01 15:47:10 +00:00
delete this;
return x;
}
Re-allow indexes as state parameter in sequences
2016-08-05 15:26:33 +00:00
//==========================================================================
//
//
//
//==========================================================================
FxRuntimeStateIndex::FxRuntimeStateIndex(FxExpression *index)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
: FxExpression(EFX_RuntimeStateIndex, index->ScriptPosition), Index(index)
Re-allow indexes as state parameter in sequences
2016-08-05 15:26:33 +00:00
{
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
ValueType = TypeStateLabel;
Re-allow indexes as state parameter in sequences
2016-08-05 15:26:33 +00:00
}
FxRuntimeStateIndex::~FxRuntimeStateIndex()
{
SAFE_DELETE(Index);
}
FxExpression *FxRuntimeStateIndex::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
SAFE_RESOLVE(Index, ctx);
if (!Index->IsNumeric())
{
ScriptPosition.Message(MSG_ERROR, "Numeric type expected");
delete this;
return nullptr;
}
- removed a parsing hack for the old internal definitions. - fixed: The state cast hack for DECORATE could not properly create state constants. Instead they were passed to FxRuntimeStateIndex without resolving them to something constant. This adds proper handling of constant indices within that class.
2016-11-06 22:10:23 +00:00
else if (Index->isConstant())
- fixed: The states parser tried to simplify the head node for random duration but it has to simplify the two value nodes separately. - added jump by index to ZScript.
2016-11-04 23:39:00 +00:00
{
- removed a parsing hack for the old internal definitions. - fixed: The state cast hack for DECORATE could not properly create state constants. Instead they were passed to FxRuntimeStateIndex without resolving them to something constant. This adds proper handling of constant indices within that class.
2016-11-06 22:10:23 +00:00
int index = static_cast<FxConstant *>(Index)->GetValue().GetInt();
if (index < 0 || (index == 0 && !ctx.FromDecorate))
{
ScriptPosition.Message(MSG_ERROR, "State index must be positive");
delete this;
return nullptr;
}
else if (index == 0)
{
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
int symlabel = StateLabels.AddPointer(nullptr);
auto x = new FxConstant(symlabel, ScriptPosition);
- removed a parsing hack for the old internal definitions. - fixed: The state cast hack for DECORATE could not properly create state constants. Instead they were passed to FxRuntimeStateIndex without resolving them to something constant. This adds proper handling of constant indices within that class.
2016-11-06 22:10:23 +00:00
delete this;
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
x->ValueType = TypeStateLabel;
return x;
- removed a parsing hack for the old internal definitions. - fixed: The state cast hack for DECORATE could not properly create state constants. Instead they were passed to FxRuntimeStateIndex without resolving them to something constant. This adds proper handling of constant indices within that class.
2016-11-06 22:10:23 +00:00
}
else
{
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
auto x = new FxStateByIndex(ctx.StateIndex + index, ScriptPosition);
- removed a parsing hack for the old internal definitions. - fixed: The state cast hack for DECORATE could not properly create state constants. Instead they were passed to FxRuntimeStateIndex without resolving them to something constant. This adds proper handling of constant indices within that class.
2016-11-06 22:10:23 +00:00
delete this;
return x->Resolve(ctx);
}
- fixed: The states parser tried to simplify the head node for random duration but it has to simplify the two value nodes separately. - added jump by index to ZScript.
2016-11-04 23:39:00 +00:00
}
Re-allow indexes as state parameter in sequences
2016-08-05 15:26:33 +00:00
else if (Index->ValueType->GetRegType() != REGT_INT)
{ // Float.
- the compile context now knows if it is invoked by ZScript or DECORATE, so that it can be more strict with ZScript if needed. - added a truncation warning to FxIntCast, which only occurs with ZScript, not with DECORATE. FxBoolCast is intentionally left out because it would defeat the reason for this cast type.
2016-10-15 19:35:31 +00:00
Index = new FxIntCast(Index, ctx.FromDecorate);
Re-allow indexes as state parameter in sequences
2016-08-05 15:26:33 +00:00
SAFE_RESOLVE(Index, ctx);
}
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
auto aclass = dyn_cast<PClassActor>(ctx.Class);
assert(aclass != nullptr && aclass->NumOwnedStates > 0);
symlabel = StateLabels.AddPointer(aclass->OwnedStates + ctx.StateIndex);
ValueType = TypeStateLabel;
Re-allow indexes as state parameter in sequences
2016-08-05 15:26:33 +00:00
return this;
}
ExpEmit FxRuntimeStateIndex::Emit(VMFunctionBuilder *build)
{
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
ExpEmit out = Index->Emit(build);
// out = (clamp(Index, 0, 32767) << 16) | symlabel | 0x80000000; 0x80000000 is here to make it negative.
build->Emit(OP_MAX_RK, out.RegNum, out.RegNum, build->GetConstantInt(0));
build->Emit(OP_MIN_RK, out.RegNum, out.RegNum, build->GetConstantInt(32767));
build->Emit(OP_SLL_RI, out.RegNum, out.RegNum, 16);
build->Emit(OP_OR_RK, out.RegNum, out.RegNum, build->GetConstantInt(symlabel|0x80000000));
Re-allow indexes as state parameter in sequences
2016-08-05 15:26:33 +00:00
return out;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
//
//
//==========================================================================
FxMultiNameState::FxMultiNameState(const char *_statestring, const FScriptPosition &pos)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
:FxExpression(EFX_MultiNameState, pos)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
FName scopename;
FString statestring = _statestring;
int scopeindex = statestring.IndexOf("::");
if (scopeindex >= 0)
{
scopename = FName(statestring, scopeindex, false);
statestring = statestring.Right(statestring.Len() - scopeindex - 2);
}
else
{
- 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
scopename = NAME_None;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
names = MakeStateNameList(statestring);
names.Insert(0, scopename);
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
scope = nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//==========================================================================
//
//
//
//==========================================================================
FxExpression *FxMultiNameState::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
Fixed: the game could crash while parsing expressions in some places
2016-08-04 17:45:24 +00:00
ABORT(ctx.Class);
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
int symlabel;
- allow functions in structs. This is needed for several internal data types like players, sectors, lines, etc. - added a new type 'NativeStruct'. This will be used for types that cannot be instantiated, and is also needed to cleanly handle many internal types that only can exist as reference.
2016-11-19 11:12:29 +00:00
auto clstype = dyn_cast<PClassActor>(ctx.Class);
Fixed: the game could crash while parsing expressions in some places
2016-08-04 17:45:24 +00:00
Normalize line endings
2016-03-01 15:47:10 +00:00
if (names[0] == NAME_None)
{
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
scope = nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- allow functions in structs. This is needed for several internal data types like players, sectors, lines, etc. - added a new type 'NativeStruct'. This will be used for types that cannot be instantiated, and is also needed to cleanly handle many internal types that only can exist as reference.
2016-11-19 11:12:29 +00:00
else if (clstype == nullptr)
{
// not in an actor, so any further checks are pointless.
ScriptPosition.Message(MSG_ERROR, "'%s' is not an ancestor of '%s'", names[0].GetChars(), ctx.Class->TypeName.GetChars());
delete this;
return nullptr;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
else if (names[0] == NAME_Super)
{
- allow functions in structs. This is needed for several internal data types like players, sectors, lines, etc. - added a new type 'NativeStruct'. This will be used for types that cannot be instantiated, and is also needed to cleanly handle many internal types that only can exist as reference.
2016-11-19 11:12:29 +00:00
scope = dyn_cast<PClassActor>(clstype->ParentClass);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
scope = PClass::FindActor(names[0]);
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
if (scope == nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
ScriptPosition.Message(MSG_ERROR, "Unknown class '%s' in state label", names[0].GetChars());
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- allow functions in structs. This is needed for several internal data types like players, sectors, lines, etc. - added a new type 'NativeStruct'. This will be used for types that cannot be instantiated, and is also needed to cleanly handle many internal types that only can exist as reference.
2016-11-19 11:12:29 +00:00
else if (!scope->IsAncestorOf(clstype))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- pass the current function to the compile context instead of just the containing class.
2016-10-15 15:40:27 +00:00
ScriptPosition.Message(MSG_ERROR, "'%s' is not an ancestor of '%s'", names[0].GetChars(), ctx.Class->TypeName.GetChars());
Normalize line endings
2016-03-01 15:47:10 +00:00
delete this;
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
if (scope != nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
FState *destination = nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
// If the label is class specific we can resolve it right here
if (names[1] != NAME_None)
{
destination = scope->FindState(names.Size()-1, &names[1], false);
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
if (destination == nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- 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
ScriptPosition.Message(MSG_OPTERROR, "Unknown state jump destination");
Normalize line endings
2016-03-01 15:47:10 +00:00
/* lax */
return this;
}
}
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
symlabel = StateLabels.AddPointer(destination);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
names.Delete(0);
symlabel = StateLabels.AddNames(names);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
FxExpression *x = new FxConstant(symlabel, ScriptPosition);
x->ValueType = TypeStateLabel;
delete this;
return x;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- added processing of compound statements to the compiler. This means that anonymous functions without control statements are generating code now. - added local variable declarations to the code generator. This is not tested yet, that will come with the next commit.
2016-10-19 17:05:48 +00:00
//==========================================================================
//
// declares a single local variable (no arrays)
//
//==========================================================================
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
FxLocalVariableDeclaration::FxLocalVariableDeclaration(PType *type, FName name, FxExpression *initval, int varflags, const FScriptPosition &p)
- Gave FxExpression a type identifier field so that certain combinations that are easy to optimize can be detected.
2016-10-22 23:14:49 +00:00
:FxExpression(EFX_LocalVariableDeclaration, p)
- added processing of compound statements to the compiler. This means that anonymous functions without control statements are generating code now. - added local variable declarations to the code generator. This is not tested yet, that will come with the next commit.
2016-10-19 17:05:48 +00:00
{
ValueType = type;
- process most of the remaining statement types. - extend assignment operations to handle local variables (untested.) - make the implicit function arguments read only.
2016-10-20 23:12:54 +00:00
VarFlags = varflags;
- added processing of compound statements to the compiler. This means that anonymous functions without control statements are generating code now. - added local variable declarations to the code generator. This is not tested yet, that will come with the next commit.
2016-10-19 17:05:48 +00:00
Name = name;
- implemented local vector variables. Currently only the definition plus initial assignment works. - removed all vector4 handling that had already been added, now that this type can no longer be defined.
2016-10-28 13:15:30 +00:00
RegCount = type == TypeVector2 ? 2 : type == TypeVector3 ? 3 : 1;
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
Init = initval;
- added processing of compound statements to the compiler. This means that anonymous functions without control statements are generating code now. - added local variable declarations to the code generator. This is not tested yet, that will come with the next commit.
2016-10-19 17:05:48 +00:00
}
use a memory arena for allocating code generation nodes. - Since the number of small allocations here is extremely high this will help a lot to prevent fragmentation and since most nodes are collected up front and this is done when no large resources are being loaded it won't cause heap spikes. let Emit methods delete FxExpression arrays when they are done. - For some reason the deletion process does not work 100%, there are always some nodes left behind and so far I haven't found them. This ensures that these arrays do not live any longer than needed.
2016-11-10 14:13:31 +00:00
FxLocalVariableDeclaration::~FxLocalVariableDeclaration()
{
SAFE_DELETE(Init);
}
- added processing of compound statements to the compiler. This means that anonymous functions without control statements are generating code now. - added local variable declarations to the code generator. This is not tested yet, that will come with the next commit.
2016-10-19 17:05:48 +00:00
FxExpression *FxLocalVariableDeclaration::Resolve(FCompileContext &ctx)
{
CHECKRESOLVED();
if (ctx.Block == nullptr)
{
ScriptPosition.Message(MSG_ERROR, "Variable declaration outside compound statement");
delete this;
return nullptr;
}
- added automatic type deduction capabilities for local variables. If you type 'let variable = value;' the type of 'variable' will be deduced from the given value. This is mostly of interest for type casting pointers, because 'let p = Classtype(objectvar);' does not require writing the class type name twice.
2016-12-05 12:24:42 +00:00
if (ValueType->RegType == REGT_NIL && ValueType != TypeAuto)
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
{
auto sfunc = static_cast<VMScriptFunction *>(ctx.Function->Variants[0].Implementation);
StackOffset = sfunc->AllocExtraStack(ValueType);
// Todo: Process the compound initializer once implemented.
- added automatic type deduction capabilities for local variables. If you type 'let variable = value;' the type of 'variable' will be deduced from the given value. This is mostly of interest for type casting pointers, because 'let p = Classtype(objectvar);' does not require writing the class type name twice.
2016-12-05 12:24:42 +00:00
if (Init != nullptr)
{
ScriptPosition.Message(MSG_ERROR, "Cannot initialize non-scalar variable %s here", Name.GetChars());
delete this;
return nullptr;
}
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
}
- added automatic type deduction capabilities for local variables. If you type 'let variable = value;' the type of 'variable' will be deduced from the given value. This is mostly of interest for type casting pointers, because 'let p = Classtype(objectvar);' does not require writing the class type name twice.
2016-12-05 12:24:42 +00:00
else if (ValueType !=TypeAuto)
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
{
if (Init) Init = new FxTypeCast(Init, ValueType, false);
SAFE_RESOLVE_OPT(Init, ctx);
}
- added automatic type deduction capabilities for local variables. If you type 'let variable = value;' the type of 'variable' will be deduced from the given value. This is mostly of interest for type casting pointers, because 'let p = Classtype(objectvar);' does not require writing the class type name twice.
2016-12-05 12:24:42 +00:00
else
{
if (Init == nullptr)
{
ScriptPosition.Message(MSG_ERROR, "Automatic type deduction requires an initializer for variable %s", Name.GetChars());
delete this;
return nullptr;
}
SAFE_RESOLVE_OPT(Init, ctx);
if (Init->ValueType->RegType == REGT_NIL)
{
ScriptPosition.Message(MSG_ERROR, "Cannot initialize non-scalar variable %s here", Name.GetChars());
delete this;
return nullptr;
}
ValueType = Init->ValueType;
// check for undersized ints and floats. These are not allowed as local variables.
if (IsInteger() && ValueType->Align < sizeof(int)) ValueType = TypeSInt32;
else if (IsFloat() && ValueType->Align < sizeof(double)) ValueType = TypeFloat64;
}
- added an error check for duplicate local variable definitions. Note that this only applies if both are in the same block. Just like in C++, it is perfectly legal to have the same variable name in two different nested scopes.
2016-12-03 11:33:58 +00:00
if (Name != NAME_None)
{
for (auto l : ctx.Block->LocalVars)
{
if (l->Name == Name)
{
ScriptPosition.Message(MSG_ERROR, "Local variable %s already defined", Name.GetChars());
l->ScriptPosition.Message(MSG_ERROR, "Original definition is here ");
delete this;
return nullptr;
}
}
}
- added processing of compound statements to the compiler. This means that anonymous functions without control statements are generating code now. - added local variable declarations to the code generator. This is not tested yet, that will come with the next commit.
2016-10-19 17:05:48 +00:00
ctx.Block->LocalVars.Push(this);
return this;
}
- scriptified A_Saw. - implemented multiple-return-value assignment. Due to some grammar conflicts the originally intended Lua-inspired syntax of 'a, b = Function()' could not be done, so it's '[a, b] = Function()'
2016-11-19 23:25:38 +00:00
void FxLocalVariableDeclaration::SetReg(ExpEmit emit)
{
assert(ValueType->GetRegType() == emit.RegType && ValueType->GetRegCount() == emit.RegCount);
RegNum = emit.RegNum;
}
- added processing of compound statements to the compiler. This means that anonymous functions without control statements are generating code now. - added local variable declarations to the code generator. This is not tested yet, that will come with the next commit.
2016-10-19 17:05:48 +00:00
ExpEmit FxLocalVariableDeclaration::Emit(VMFunctionBuilder *build)
{
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
if (ValueType->RegType != REGT_NIL)
- added processing of compound statements to the compiler. This means that anonymous functions without control statements are generating code now. - added local variable declarations to the code generator. This is not tested yet, that will come with the next commit.
2016-10-19 17:05:48 +00:00
{
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
if (Init == nullptr)
- added processing of compound statements to the compiler. This means that anonymous functions without control statements are generating code now. - added local variable declarations to the code generator. This is not tested yet, that will come with the next commit.
2016-10-19 17:05:48 +00:00
{
- scriptified a_strifeitems.cpp and a_debris.cpp. - Changed the glass shards so that they do not have to override FloorBounceMissile. It was the only place where this was virtually overridden and provided little usefulness. - made 'out' variables work. - fixed virtual call handling for HandlePickup.
2016-11-29 11:17:05 +00:00
if (RegNum == -1)
{
if (!(VarFlags & VARF_Out)) RegNum = build->Registers[ValueType->GetRegType()].Get(RegCount);
else RegNum = build->Registers[REGT_POINTER].Get(1);
}
- added processing of compound statements to the compiler. This means that anonymous functions without control statements are generating code now. - added local variable declarations to the code generator. This is not tested yet, that will come with the next commit.
2016-10-19 17:05:48 +00:00
}
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
else
- added processing of compound statements to the compiler. This means that anonymous functions without control statements are generating code now. - added local variable declarations to the code generator. This is not tested yet, that will come with the next commit.
2016-10-19 17:05:48 +00:00
{
- scriptified a_strifeitems.cpp and a_debris.cpp. - Changed the glass shards so that they do not have to override FloorBounceMissile. It was the only place where this was virtually overridden and provided little usefulness. - made 'out' variables work. - fixed virtual call handling for HandlePickup.
2016-11-29 11:17:05 +00:00
assert(!(VarFlags & VARF_Out)); // 'out' variables should never be initialized, they can only exist as function parameters.
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
ExpEmit emitval = Init->Emit(build);
int regtype = emitval.RegType;
if (regtype < REGT_INT || regtype > REGT_TYPE)
- added processing of compound statements to the compiler. This means that anonymous functions without control statements are generating code now. - added local variable declarations to the code generator. This is not tested yet, that will come with the next commit.
2016-10-19 17:05:48 +00:00
{
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
ScriptPosition.Message(MSG_ERROR, "Attempted to assign a non-value");
return ExpEmit();
}
if (emitval.Konst)
{
auto constval = static_cast<FxConstant *>(Init);
RegNum = build->Registers[regtype].Get(1);
switch (regtype)
{
default:
case REGT_INT:
build->Emit(OP_LK, RegNum, build->GetConstantInt(constval->GetValue().GetInt()));
break;
- added processing of compound statements to the compiler. This means that anonymous functions without control statements are generating code now. - added local variable declarations to the code generator. This is not tested yet, that will come with the next commit.
2016-10-19 17:05:48 +00:00
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
case REGT_FLOAT:
build->Emit(OP_LKF, RegNum, build->GetConstantFloat(constval->GetValue().GetFloat()));
break;
- added processing of compound statements to the compiler. This means that anonymous functions without control statements are generating code now. - added local variable declarations to the code generator. This is not tested yet, that will come with the next commit.
2016-10-19 17:05:48 +00:00
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
case REGT_POINTER:
- implemented the string concatenation operator '..'. This is capable of stringifying all of the common types for output. - gave OP_CONCAT some sane semantics. The way this was defined, by specifying the source operands as a range of registers instead of a pair like everything else made it completely useless for the task at hand. - changed formatting for floats to %.5f which for normal output in a game makes more sense. For special cases there should be a special formatting function for ints and floats that can do more specialized conversions.
2016-11-18 16:44:25 +00:00
{
bool isobject = ValueType->IsKindOf(RUNTIME_CLASS(PClassPointer)) || (ValueType->IsKindOf(RUNTIME_CLASS(PPointer)) && static_cast<PPointer*>(ValueType)->PointedType->IsKindOf(RUNTIME_CLASS(PClass)));
build->Emit(OP_LKP, RegNum, build->GetConstantAddress(constval->GetValue().GetPointer(), isobject ? ATAG_OBJECT : ATAG_GENERIC));
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
break;
- implemented the string concatenation operator '..'. This is capable of stringifying all of the common types for output. - gave OP_CONCAT some sane semantics. The way this was defined, by specifying the source operands as a range of registers instead of a pair like everything else made it completely useless for the task at hand. - changed formatting for floats to %.5f which for normal output in a game makes more sense. For special cases there should be a special formatting function for ints and floats that can do more specialized conversions.
2016-11-18 16:44:25 +00:00
}
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
case REGT_STRING:
build->Emit(OP_LKS, RegNum, build->GetConstantString(constval->GetValue().GetString()));
}
emitval.Free(build);
}
- fixed: initialization of local vector variables did not properly allocate registers if the initializer was a subelement of another local vector variable.
2017-01-07 10:36:57 +00:00
else if (!emitval.Fixed)
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
{
// take over the register that got allocated while emitting the Init expression.
RegNum = emitval.RegNum;
}
else
{
ExpEmit out(build, emitval.RegType, emitval.RegCount);
build->Emit(ValueType->GetMoveOp(), out.RegNum, emitval.RegNum);
RegNum = out.RegNum;
- added processing of compound statements to the compiler. This means that anonymous functions without control statements are generating code now. - added local variable declarations to the code generator. This is not tested yet, that will come with the next commit.
2016-10-19 17:05:48 +00:00
}
- fixed initialization of local variables with other local variables. - fixed several occurenced where vectors were treated as floats. NOTE: The entire codegen.cpp file needs to be carefully reviewed for bad use of the REGT_ constants, there's probably more places where using them has broken some type checks. - fixed: committed test version of zscript.txt instead of changed actor.txt by accident. Initialization and assignment for strings is working with this commit.
2016-10-29 14:49:21 +00:00
}
- added processing of compound statements to the compiler. This means that anonymous functions without control statements are generating code now. - added local variable declarations to the code generator. This is not tested yet, that will come with the next commit.
2016-10-19 17:05:48 +00:00
}
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
else
{
// Init arrays and structs.
- added the ability to attach a constructor or destructor to an internally defined struct. There are a few which require explicit native construction or destruction that need to be exported to the VM, e.g. FCheckPosition. The VM cannot handle this directly, it needs two special functions to be attached to handle such elements.
2017-01-11 22:46:03 +00:00
if (ValueType->IsA(RUNTIME_CLASS(PStruct)))
{
auto pstr = static_cast<PStruct*>(ValueType);
if (pstr->mConstructor != nullptr)
{
ExpEmit reg(build, REGT_POINTER);
build->Emit(OP_ADDA_RK, reg.RegNum, build->FramePointer.RegNum, build->GetConstantInt(StackOffset));
build->Emit(OP_PARAM, 0, reg.RegType, reg.RegNum);
build->Emit(OP_CALL_K, build->GetConstantAddress(pstr->mConstructor, ATAG_OBJECT), 1, 0);
reg.Free(build);
}
if (pstr->mDestructor != nullptr) build->ConstructedStructs.Push(this);
}
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
}
- added processing of compound statements to the compiler. This means that anonymous functions without control statements are generating code now. - added local variable declarations to the code generator. This is not tested yet, that will come with the next commit.
2016-10-19 17:05:48 +00:00
return ExpEmit();
}
void FxLocalVariableDeclaration::Release(VMFunctionBuilder *build)
{
// Release the register after the containing block gets closed
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
if(RegNum != -1)
{
build->Registers[ValueType->GetRegType()].Return(RegNum, RegCount);
}
- added the ability to attach a constructor or destructor to an internally defined struct. There are a few which require explicit native construction or destruction that need to be exported to the VM, e.g. FCheckPosition. The VM cannot handle this directly, it needs two special functions to be attached to handle such elements.
2017-01-11 22:46:03 +00:00
else
{
if (ValueType->IsA(RUNTIME_CLASS(PStruct)))
{
auto pstr = static_cast<PStruct*>(ValueType);
if (pstr->mDestructor != nullptr)
{
ExpEmit reg(build, REGT_POINTER);
build->Emit(OP_ADDA_RK, reg.RegNum, build->FramePointer.RegNum, build->GetConstantInt(StackOffset));
build->Emit(OP_PARAM, 0, reg.RegType, reg.RegNum);
build->Emit(OP_CALL_K, build->GetConstantAddress(pstr->mDestructor, ATAG_OBJECT), 1, 0);
reg.Free(build);
}
build->ConstructedStructs.Delete(build->ConstructedStructs.Find(this));
}
}
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
// Stack space will not be released because that would make controlled destruction impossible.
// For that all local stack variables need to live for the entire execution of a function.
- added processing of compound statements to the compiler. This means that anonymous functions without control statements are generating code now. - added local variable declarations to the code generator. This is not tested yet, that will come with the next commit.
2016-10-19 17:05:48 +00:00
}
- added static constant arrays. At the moment they can only be defined inside functions due to lack of dedicated storage inside classes for static data. - added new VM instructions to access the constant tables with a variable index. - refactored VMFunctionBuilder's constant tables so that they are not limited to one entry per value. While this works fine for single values, it makes it impossible to store constant arrays in here.
2016-11-20 17:00:37 +00:00
FxStaticArray::FxStaticArray(PType *type, FName name, FArgumentList &args, const FScriptPosition &pos)
: FxLocalVariableDeclaration(NewArray(type, args.Size()), name, nullptr, VARF_Static|VARF_ReadOnly, pos)
{
ElementType = type;
ExprType = EFX_StaticArray;
values = std::move(args);
}
FxExpression *FxStaticArray::Resolve(FCompileContext &ctx)
{
bool fail = false;
for (unsigned i = 0; i < values.Size(); i++)
{
values[i] = new FxTypeCast(values[i], ElementType, false);
values[i] = values[i]->Resolve(ctx);
if (values[i] == nullptr) fail = true;
else if (!values[i]->isConstant())
{
ScriptPosition.Message(MSG_ERROR, "Initializer must be constant");
fail = true;
}
}
if (fail)
{
delete this;
return nullptr;
}
if (ElementType->GetRegType() == REGT_NIL)
{
ScriptPosition.Message(MSG_ERROR, "Invalid type for constant array");
delete this;
return nullptr;
}
ctx.Block->LocalVars.Push(this);
return this;
}
ExpEmit FxStaticArray::Emit(VMFunctionBuilder *build)
{
switch (ElementType->GetRegType())
{
default:
assert(false && "Invalid register type");
break;
case REGT_INT:
{
TArray<int> cvalues;
for (auto v : values) cvalues.Push(static_cast<FxConstant *>(v)->GetValue().GetInt());
StackOffset = build->AllocConstantsInt(cvalues.Size(), &cvalues[0]);
break;
}
case REGT_FLOAT:
{
TArray<double> cvalues;
for (auto v : values) cvalues.Push(static_cast<FxConstant *>(v)->GetValue().GetFloat());
StackOffset = build->AllocConstantsFloat(cvalues.Size(), &cvalues[0]);
break;
}
case REGT_STRING:
{
TArray<FString> cvalues;
for (auto v : values) cvalues.Push(static_cast<FxConstant *>(v)->GetValue().GetString());
StackOffset = build->AllocConstantsString(cvalues.Size(), &cvalues[0]);
break;
}
case REGT_POINTER:
{
TArray<void*> cvalues;
for (auto v : values) cvalues.Push(static_cast<FxConstant *>(v)->GetValue().GetPointer());
StackOffset = build->AllocConstantsAddress(cvalues.Size(), &cvalues[0], ElementType->GetLoadOp() == OP_LO ? ATAG_OBJECT : ATAG_GENERIC);
break;
}
}
return ExpEmit();
}
Reference in a new issue Copy permalink