marko10_000
/
openclonk
forked from Mirrors/openclonk
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
openclonk/src/script/C4AulCompiler.cpp

2213 lines
64 KiB
C++
Raw Permalink Blame History

/*
* OpenClonk, http://www.openclonk.org
*
* Copyright (c) 2001-2009, RedWolf Design GmbH, http://www.clonk.de/
* Copyright (c) 2009-2018, The OpenClonk Team and contributors
*
* Distributed under the terms of the ISC license; see accompanying file
* "COPYING" for details.
*
* "Clonk" is a registered trademark of Matthes Bender, used with permission.
* See accompanying file "TRADEMARK" for details.
*
* To redistribute this file separately, substitute the full license texts
* for the above references.
*/
#include "C4Include.h"
#include "script/C4AulCompiler.h"
#include "script/C4Aul.h"
#include "script/C4AulParse.h"
#include "script/C4AulScriptFunc.h"
#include "script/C4ScriptHost.h"
#include <cinttypes>
#include <deque>
#define C4AUL_Inherited "inherited"
#define C4AUL_SafeInherited "_inherited"
#define C4AUL_DebugBreak "__debugbreak"
namespace
{
enum class ScriptLinkType
{
Include,
Same,
Appendto,
};
}
static ScriptLinkType GetScriptLinkType(const C4ScriptHost *source_host, const C4ScriptHost *target_host)
{
if (source_host == target_host)
return ScriptLinkType::Same;
const auto &sources = target_host->SourceScripts;
const auto source_script_index = std::find(begin(sources), end(sources), source_host);
const auto target_script_index = std::find(begin(sources), end(sources), target_host);
assert(source_script_index != target_script_index);
if (source_script_index < target_script_index)
return ScriptLinkType::Include;
else if (source_script_index > target_script_index)
return ScriptLinkType::Appendto;
return ScriptLinkType::Same;
}
static std::string FormatCodePosition(const C4ScriptHost *source_host, const char *pos, const C4ScriptHost *target_host = nullptr, const C4AulScriptFunc *func = nullptr)
{
std::string s;
if (func && func->GetFullName())
{
s += strprintf(" (in %s", func->GetFullName().getData());
if (source_host && pos)
s += ", ";
else
s += ")";
}
if (source_host && pos)
{
if (!func || !func->GetFullName())
s += " (";
int line = SGetLine(source_host->GetScript(), pos);
int col = SLineGetCharacters(source_host->GetScript(), pos);
s += strprintf("%s:%d:%d)", source_host->GetFilePath(), line, col);
}
if (target_host && source_host != target_host)
{
if (GetScriptLinkType(source_host, target_host) == ScriptLinkType::Include)
s += strprintf(" (included by %s)", target_host->ScriptName.getData());
else
s += strprintf(" (appended to %s)", target_host->ScriptName.getData());
}
return s;
}
#pragma GCC diagnostic push
// GCC does not properly handle that warning for strprintf in templated code, see #1992.
#pragma GCC diagnostic ignored "-Wformat-security"
template<class... T>
static void Warn(const C4ScriptHost *target_host, const C4ScriptHost *host, const char *SPos, const C4AulScriptFunc *func, C4AulWarningId warning, T &&...args)
{
if (!host)
{
// Without a script host, just fall back to the default settings
#define DIAG(id, msg, enabled) if (warning == C4AulWarningId::id && !enabled) return;
#include "C4AulWarnings.h"
#undef DIAG
}
else if (target_host && GetScriptLinkType(host, target_host) == ScriptLinkType::Include)
{
// Don't re-emit warnings for an #include'd script, they've already
// been shown when the original script was compiled
return;
}
else if (!host->IsWarningEnabled(SPos, warning))
{
return;
}
const char *msg = C4AulWarningMessages[static_cast<size_t>(warning)];
std::string message = sizeof...(T) > 0 ? strprintf(msg, std::forward<T>(args)...) : msg;
message += FormatCodePosition(host, SPos, target_host, func);
message += " [";
message += C4AulWarningIDs[static_cast<size_t>(warning)];
message += ']';
::ScriptEngine.GetErrorHandler()->OnWarning(message.c_str());
}
template<class... T>
static void Warn(const C4ScriptHost *target_host, const C4ScriptHost *host, const ::aul::ast::Node *n, const C4AulScriptFunc *func, C4AulWarningId warning, T &&...args)
{
return Warn(target_host, host, n->loc, func, warning, std::forward<T>(args)...);
}
template<class... T>
static void Warn(const C4ScriptHost *target_host, const C4ScriptHost *host, const std::nullptr_t &, const C4AulScriptFunc *func, C4AulWarningId warning, T &&...args)
{
return Warn(target_host, host, static_cast<const char*>(nullptr), func, warning, std::forward<T>(args)...);
}
template<class... T>
static C4AulParseError Error(const C4ScriptHost *target_host, const C4ScriptHost *host, const char *SPos, const C4AulScriptFunc *func, const char *msg, T &&...args)
{
std::string message = sizeof...(T) > 0 ? strprintf(msg, std::forward<T>(args)...) : msg;
message += FormatCodePosition(host, SPos, target_host, func);
return C4AulParseError(static_cast<C4ScriptHost*>(nullptr), message.c_str());
}
template<class... T>
static C4AulParseError Error(const C4ScriptHost *target_host, const C4ScriptHost *host, const ::aul::ast::Node *n, const C4AulScriptFunc *func, const char *msg, T &&...args)
{
return Error(target_host, host, n->loc, func, msg, std::forward<T>(args)...);
}
template<class... T>
static C4AulParseError Error(const C4ScriptHost *target_host, const C4ScriptHost *host, const std::nullptr_t &, const C4AulScriptFunc *func, const char *msg, T &&...args)
{
return Error(target_host, host, static_cast<const char*>(nullptr), func, msg, std::forward<T>(args)...);
}
#pragma GCC diagnostic pop
class C4AulCompiler::PreparseAstVisitor : public ::aul::DefaultRecursiveVisitor
{
// target_host: The C4ScriptHost on which compilation is done
C4ScriptHost *target_host = nullptr;
// host: The C4ScriptHost where the script actually resides in
C4ScriptHost *host = nullptr;
// Fn: The C4AulScriptFunc that is currently getting parsed
C4AulScriptFunc *Fn = nullptr;
public:
PreparseAstVisitor(C4ScriptHost *host, C4ScriptHost *source_host, C4AulScriptFunc *func = nullptr) : target_host(host), host(source_host), Fn(func) {}
explicit PreparseAstVisitor(C4AulScriptFunc *func) : Fn(func), target_host(func->pOrgScript), host(target_host) {}
~PreparseAstVisitor() override = default;
using DefaultRecursiveVisitor::visit;
void visit(const ::aul::ast::RangeLoop *n) override;
void visit(const ::aul::ast::VarDecl *n) override;
void visit(const ::aul::ast::FunctionDecl *n) override;
void visit(const ::aul::ast::CallExpr *n) override;
void visit(const ::aul::ast::ParExpr *n) override;
void visit(const ::aul::ast::AppendtoPragma *n) override;
void visit(const ::aul::ast::IncludePragma *n) override;
void visit(const ::aul::ast::Script *n) override;
};
class C4AulCompiler::CodegenAstVisitor : public ::aul::DefaultRecursiveVisitor
{
C4AulScriptFunc *Fn = nullptr;
// target_host: The C4ScriptHost on which compilation is done
C4ScriptHost *target_host = nullptr;
// host: The C4ScriptHost where the script actually resides in
C4ScriptHost *host = nullptr;
int32_t stack_height = 0;
bool at_jump_target = false;
struct Loop
{
explicit Loop(int stack_height) : stack_height(stack_height) {}
int stack_height = 0;
std::vector<int> continues;
std::vector<int> breaks;
enum class Control
{
Continue,
Break
};
};
std::stack<Loop> active_loops;
struct Scope
{
std::set<std::string> variables;
};
std::deque<Scope> scopes;
// The type of the variable on top of the value stack. C4V_Any if unknown.
C4V_Type type_of_stack_top = C4V_Any;
constexpr static bool IsJump(C4AulBCCType t)
{
return t == AB_JUMP || t == AB_JUMPAND || t == AB_JUMPOR || t == AB_JUMPNNIL || t == AB_CONDN || t == AB_COND;
}
int AddJumpTarget();
void AddJumpTo(const char *loc, C4AulBCCType type, int target);
void UpdateJump(int jump, int target);
void PushLoop();
void PopLoop(int continue_target);
void AddLoopControl(const char *loc, Loop::Control c);
int AddVarAccess(const char *TokenSPos, C4AulBCCType eType, intptr_t varnum);
int AddBCC(const char *TokenSPos, C4AulBCCType eType, intptr_t X = 0);
int AddBCC(const char *SPos, const C4AulBCC &bcc);
template<class T>
void MaybePopValueOf(const std::unique_ptr<T> &n)
{
if (!n) return;
if (!n->has_value()) return;
AddBCC(n->loc, AB_STACK, -1);
}
static int GetStackValue(C4AulBCCType eType, intptr_t X);
void RemoveLastBCC();
C4AulBCC MakeSetter(const char *SPos, bool fLeaveValue);
void HandleError(const C4AulError &e)
{
if (Fn)
{
AddBCC(nullptr, AB_ERR, (intptr_t)::Strings.RegString(e.what()));
}
if (target_host) // target_host may be nullptr for DirectExec scripts
{
target_host->Engine->ErrorHandler->OnError(e.what());
}
}
template<class T>
bool SafeVisit(const T &node)
{
// Swallows exceptions during evaluation of node. Use if you want to
// keep doing syntax checks for subsequent children. (Generated code
// will cause a runtime error if executed.)
try
{
node->accept(this);
return true;
}
catch (C4AulParseError &e)
{
HandleError(e);
return false;
}
}
class StackGuard
{
// Ensures that the Aul value stack ends up at the expected height
CodegenAstVisitor *parent;
const int32_t target_stack_height;
public:
explicit StackGuard(CodegenAstVisitor *parent, int32_t offset = 0) : parent(parent), target_stack_height(parent->stack_height + offset)
{}
~StackGuard()
{
assert(parent->stack_height == target_stack_height);
if (parent->stack_height != target_stack_height)
{
parent->HandleError(Error(parent->target_host, parent->host, nullptr, parent->Fn, "internal error: value stack left unbalanced"));
parent->AddBCC(nullptr, AB_STACK, target_stack_height - parent->stack_height);
}
}
};
class ScopeGuard
{
// Ensures that the scope stack is properly updated
CodegenAstVisitor * const parent;
public:
explicit ScopeGuard(CodegenAstVisitor *parent) : parent(parent)
{
parent->scopes.emplace_front();
}
~ScopeGuard()
{
parent->scopes.pop_front();
}
// moveable, not copyable
ScopeGuard(ScopeGuard &&rhs) = default;
ScopeGuard &operator=(ScopeGuard &&) = default;
ScopeGuard(const ScopeGuard &) = delete;
ScopeGuard &operator=(const ScopeGuard &) = delete;
};
ScopeGuard enterScope() { return ScopeGuard(this); }
void WarnOnAssignment(const ::aul::ast::ExprPtr &n) const
{
if (dynamic_cast<const ::aul::ast::AssignmentExpr*>(n.get()) != nullptr)
{
Warn(target_host, host, n.get(), Fn, C4AulWarningId::suspicious_assignment);
}
}
public:
CodegenAstVisitor(C4ScriptHost *host, C4ScriptHost *source_host) : target_host(host), host(source_host) {}
explicit CodegenAstVisitor(C4AulScriptFunc *func) : Fn(func), target_host(func->pOrgScript), host(target_host) {}
~CodegenAstVisitor() override = default;
using DefaultRecursiveVisitor::visit;
void visit(const ::aul::ast::Noop *) override;
void visit(const ::aul::ast::StringLit *n) override;
void visit(const ::aul::ast::IntLit *n) override;
void visit(const ::aul::ast::BoolLit *n) override;
void visit(const ::aul::ast::ArrayLit *n) override;
void visit(const ::aul::ast::ProplistLit *n) override;
void visit(const ::aul::ast::NilLit *n) override;
void visit(const ::aul::ast::ThisLit *n) override;
void visit(const ::aul::ast::VarExpr *n) override;
void visit(const ::aul::ast::UnOpExpr *n) override;
void visit(const ::aul::ast::BinOpExpr *n) override;
void visit(const ::aul::ast::AssignmentExpr *n) override;
void visit(const ::aul::ast::SubscriptExpr *n) override;
void visit(const ::aul::ast::SliceExpr *n) override;
void visit(const ::aul::ast::CallExpr *n) override;
void visit(const ::aul::ast::ParExpr *n) override;
void visit(const ::aul::ast::Block *n) override;
void visit(const ::aul::ast::Return *n) override;
void visit(const ::aul::ast::ForLoop *n) override;
void visit(const ::aul::ast::RangeLoop *n) override;
void visit(const ::aul::ast::DoLoop *n) override;
void visit(const ::aul::ast::WhileLoop *n) override;
void visit(const ::aul::ast::Break *n) override;
void visit(const ::aul::ast::Continue *n) override;
void visit(const ::aul::ast::If *n) override;
void visit(const ::aul::ast::VarDecl *n) override;
void visit(const ::aul::ast::FunctionDecl *n) override;
void visit(const ::aul::ast::FunctionExpr *n) override;
void visit(const ::aul::ast::Script *n) override;
template<class T>
void EmitFunctionCode(const T *n)
{
// This dynamic_cast resolves the problem where we have a Function*
// and want to emit code to it. All classes derived from Function
// are also ultimately derived from Node, so this call is fine
// without any additional checking.
EmitFunctionCode(n, dynamic_cast<const ::aul::ast::Node*>(n));
}
private:
void EmitFunctionCode(const ::aul::ast::Function *f, const ::aul::ast::Node *n);
};
class C4AulCompiler::ConstexprEvaluator : public ::aul::AstVisitor
{
public:
enum EvalFlag
{
// If this flag is set, ConstexprEvaluator will assume unset values
// are nil. If it is not set, evaluation of unset values will send an
// ExpressionNotConstant to the error handler.
IgnoreUnset = 1<<0,
// If this flag is set, ConstexprEvaluator will not send exceptions to
// the error handler (so it doesn't report them twice: once from the
// preparsing step, then again from the compile step).
SuppressErrors = 1<<1
};
typedef int EvalFlags;
// Evaluates constant AST subtrees and returns the final C4Value.
// Flags ExpressionNotConstant if evaluation fails.
static C4Value eval(C4ScriptHost *host, const ::aul::ast::Expr *e, EvalFlags flags = 0);
static C4Value eval_static(C4ScriptHost *host, C4PropListStatic *parent, const std::string &parent_key, const ::aul::ast::Expr *e, EvalFlags flags = 0);
private:
C4ScriptHost *host = nullptr;
C4Value v;
bool ignore_unset_values = false;
bool quiet = false;
struct ProplistMagic
{
bool active = false;
C4PropListStatic *parent = nullptr;
std::string key;
ProplistMagic() = default;
ProplistMagic(bool active, C4PropListStatic *parent, std::string key) : active(active), parent(parent), key(std::move(key)) {}
} proplist_magic;
explicit ConstexprEvaluator(C4ScriptHost *host) : host(host) {}
template<typename... T>
NORETURN void nonconst(const ::aul::ast::Node *n, const char *msg, T&&...args) const
{
throw ExpressionNotConstant(host, n, msg, std::forward<T>(args)...);
}
void AssertValueType(const C4Value &v, C4V_Type Type1, const char *opname, const ::aul::ast::Node *n)
{
// Typecheck parameter
if (!v.CheckParConversion(Type1))
throw Error(host, host, n, nullptr, R"(operator "%s": got %s, but expected %s)", opname, v.GetTypeName(), GetC4VName(Type1));
}
public:
class ExpressionNotConstant : public C4AulParseError
{
public:
template<typename... T>
ExpressionNotConstant(const C4ScriptHost *host, const ::aul::ast::Node *n, const char *reason, T&&...args) :
C4AulParseError(Error(host, host, n, nullptr, reason, std::forward<T>(args)...)) {}
};
using AstVisitor::visit;
void visit(const ::aul::ast::StringLit *n) override;
void visit(const ::aul::ast::IntLit *n) override;
void visit(const ::aul::ast::BoolLit *n) override;
void visit(const ::aul::ast::ArrayLit *n) override;
void visit(const ::aul::ast::ProplistLit *n) override;
void visit(const ::aul::ast::NilLit *) override;
void visit(const ::aul::ast::ThisLit *n) override;
void visit(const ::aul::ast::VarExpr *n) override;
void visit(const ::aul::ast::UnOpExpr *n) override;
void visit(const ::aul::ast::BinOpExpr *n) override;
void visit(const ::aul::ast::AssignmentExpr *n) override;
void visit(const ::aul::ast::SubscriptExpr *n) override;
void visit(const ::aul::ast::SliceExpr *n) override;
void visit(const ::aul::ast::CallExpr *n) override;
void visit(const ::aul::ast::FunctionExpr *n) override;
};
class C4AulCompiler::ConstantResolver : public ::aul::DefaultRecursiveVisitor
{
C4ScriptHost *host;
bool quiet = false;
explicit ConstantResolver(C4ScriptHost *host) : host(host) {}
public:
static void resolve_quiet(C4ScriptHost *host, const ::aul::ast::Script *script)
{
// Does the same as resolve, but doesn't emit errors/warnings
// (because we'll emit them again later).
ConstantResolver r(host);
r.quiet = true;
r.visit(script);
}
static void resolve(C4ScriptHost *host, const ::aul::ast::Script *script)
{
// We resolve constants *twice*; this allows people to create circular
// references in proplists or arrays.
// Unfortunately it also results in unexpected behaviour in code like
// this:
// static const c1 = c2, c2 = c3, c3 = 1;
// which will set c1 to nil, and both c2 and c3 to 1.
// While this is unlikely to happen often, we should fix that so it
// resolves all three constants to 1.
ConstantResolver r(host);
r.visit(script);
}
~ConstantResolver() override = default;
using DefaultRecursiveVisitor::visit;
void visit(const ::aul::ast::Script *n) override;
void visit(const ::aul::ast::VarDecl *n) override;
};
void C4AulCompiler::Preparse(C4ScriptHost *host, C4ScriptHost *source_host, const ::aul::ast::Script *script)
{
PreparseAstVisitor v(host, source_host);
v.visit(script);
ConstantResolver::resolve_quiet(host, script);
}
void C4AulCompiler::Compile(C4ScriptHost *host, C4ScriptHost *source_host, const ::aul::ast::Script *script)
{
ConstantResolver::resolve(host, script);
CodegenAstVisitor v(host, source_host);
v.visit(script);
}
void C4AulCompiler::Compile(C4AulScriptFunc *func, const ::aul::ast::Function *def)
{
{
// Don't visit the whole definition here; that would create a new function
// and we don't want that.
PreparseAstVisitor v(func);
def->body->accept(&v);
}
{
CodegenAstVisitor v(func);
v.EmitFunctionCode(def);
}
}
#define ENSURE_COND(cond, failmsg) do { if (!(cond)) throw Error(target_host, host, n, Fn, failmsg); } while (0)
void C4AulCompiler::PreparseAstVisitor::visit(const ::aul::ast::RangeLoop *n)
{
const char *cname = n->var.c_str();
if (n->scoped_var)
{
Fn->VarNamed.AddName(cname);
}
else
{
// Loop variable not explicitly declared here. Look it up in
// the function and warn if it hasn't been declared at all.
if (Fn->VarNamed.GetItemNr(cname) == -1)
{
Warn(target_host, host, n, Fn, C4AulWarningId::implicit_range_loop_var_decl, cname);
Fn->VarNamed.AddName(cname);
}
}
DefaultRecursiveVisitor::visit(n);
}
void C4AulCompiler::PreparseAstVisitor::visit(const ::aul::ast::VarDecl *n)
{
if (n->constant && n->scope != ::aul::ast::VarDecl::Scope::Global)
{
Warn(target_host, host, n, Fn, C4AulWarningId::non_global_var_is_never_const);
}
for (const auto &var : n->decls)
{
const char *cname = var.name.c_str();
switch (n->scope)
{
case ::aul::ast::VarDecl::Scope::Func:
{
assert(Fn && "function-local var declaration outside of function");
if (!Fn)
throw Error(target_host, host, n, Fn, "internal error: function-local var declaration outside of function");
if (target_host)
{
// if target_host is unset, we're parsing this func for direct execution,
// in which case we don't want to warn about variable hiding.
if (target_host->Engine->GlobalNamedNames.GetItemNr(cname) >= 0 || target_host->Engine->GlobalConstNames.GetItemNr(cname) >= 0)
Warn(target_host, host, n, Fn, C4AulWarningId::variable_shadows_variable, "local variable", cname, "global variable");
C4String *s = ::Strings.FindString(cname);
if (s && target_host->GetPropList()->HasProperty(s))
Warn(target_host, host, n, Fn, C4AulWarningId::variable_shadows_variable, "local variable", cname, "object-local variable");
if (Fn->ParNamed.GetItemNr(cname) != -1)
{
// The parameter order of this warning is correct:
// Aul looks up parameters before local variables, so
// the parameter actually shadows the local variable.
// This doesn't make a whole lot of sense and should
// probably be changed.
Warn(target_host, host, n, Fn, C4AulWarningId::variable_shadows_variable, "parameter", cname, "local variable");
}
}
Fn->VarNamed.AddName(cname);
break;
}
case ::aul::ast::VarDecl::Scope::Object:
{
if (host->Engine->GlobalNamedNames.GetItemNr(cname) >= 0 || host->Engine->GlobalConstNames.GetItemNr(cname) >= 0)
Warn(target_host, host, n, Fn, C4AulWarningId::variable_shadows_variable, "object-local variable", cname, "global variable");
C4String *s = ::Strings.RegString(cname);
if (target_host->GetPropList()->HasProperty(s))
Warn(target_host, host, n, Fn, C4AulWarningId::redeclaration, "object-local variable", cname);
else
target_host->GetPropList()->SetPropertyByS(s, C4VNull);
break;
}
case ::aul::ast::VarDecl::Scope::Global:
assert(!Fn && "global var declaration inside function");
if (Fn)
throw Error(target_host, host, n, Fn, "internal error: global var declaration inside function");
if (host->Engine->GlobalNamedNames.GetItemNr(cname) >= 0 || host->Engine->GlobalConstNames.GetItemNr(cname) >= 0)
Warn(target_host, host, n, Fn, C4AulWarningId::redeclaration, "global variable", cname);
if (n->constant)
host->Engine->GlobalConstNames.AddName(cname);
else
host->Engine->GlobalNamedNames.AddName(cname);
break;
}
}
if (n->scope == ::aul::ast::VarDecl::Scope::Func)
{
// only func-scoped variables can potentially have initializers we care
// about in the pre-parsing stage: they may have calls that pass
// unnamed parameters
DefaultRecursiveVisitor::visit(n);
}
}
void C4AulCompiler::PreparseAstVisitor::visit(const ::aul::ast::FunctionDecl *n)
{
// create script fn
C4PropListStatic *Parent = n->is_global ? target_host->Engine->GetPropList() : target_host->GetPropList();
const char *cname = n->name.c_str();
assert(!Fn);
// Look up the overloaded function before adding the overloading one
C4AulFunc *parent_func = Parent->GetFunc(cname);
Fn = new C4AulScriptFunc(Parent, target_host, cname, n->loc);
host->ownedFunctions.push_back(C4VFunction(Fn));
for (const auto &param : n->params)
{
Fn->AddPar(param.name.c_str(), param.type);
}
if (n->has_unnamed_params)
Fn->ParCount = C4AUL_MAX_Par;
// Add function to def/engine
Fn->SetOverloaded(parent_func);
Parent->SetPropertyByS(Fn->Name, C4VFunction(Fn));
try
{
DefaultRecursiveVisitor::visit(n);
Fn = nullptr;
}
catch (...)
{
Fn = nullptr;
throw;
}
}
void C4AulCompiler::PreparseAstVisitor::visit(const ::aul::ast::CallExpr *n)
{
if (n->append_unnamed_pars && Fn->ParCount != C4AUL_MAX_Par)
{
Fn->ParCount = C4AUL_MAX_Par;
}
DefaultRecursiveVisitor::visit(n);
}
void C4AulCompiler::PreparseAstVisitor::visit(const ::aul::ast::ParExpr *n)
{
if (Fn->ParCount != C4AUL_MAX_Par)
{
Warn(target_host, host, n, Fn, C4AulWarningId::undeclared_varargs, "Par()");
Fn->ParCount = C4AUL_MAX_Par;
}
DefaultRecursiveVisitor::visit(n);
}
void C4AulCompiler::PreparseAstVisitor::visit(const ::aul::ast::AppendtoPragma *n)
{
if (n->what.empty())
host->Appends.emplace_back("*");
else
host->Appends.emplace_back(n->what.c_str());
}
void C4AulCompiler::PreparseAstVisitor::visit(const ::aul::ast::IncludePragma *n)
{
host->Includes.emplace_back(n->what.c_str());
}
void C4AulCompiler::PreparseAstVisitor::visit(const::aul::ast::Script * n)
{
for (const auto &d : n->declarations)
{
try
{
d->accept(this);
}
catch (C4AulParseError &e)
{
target_host->Engine->GetErrorHandler()->OnError(e.what());
}
}
}
int C4AulCompiler::CodegenAstVisitor::GetStackValue(C4AulBCCType eType, intptr_t X)
{
switch (eType)
{
case AB_INT:
case AB_BOOL:
case AB_STRING:
case AB_CPROPLIST:
case AB_CARRAY:
case AB_CFUNCTION:
case AB_NIL:
case AB_LOCALN:
case AB_GLOBALN:
case AB_DUP:
case AB_DUP_CONTEXT:
case AB_THIS:
return 1;
case AB_Pow:
case AB_Div:
case AB_Mul:
case AB_Mod:
case AB_Sub:
case AB_Sum:
case AB_LeftShift:
case AB_RightShift:
case AB_LessThan:
case AB_LessThanEqual:
case AB_GreaterThan:
case AB_GreaterThanEqual:
case AB_Equal:
case AB_NotEqual:
case AB_BitAnd:
case AB_BitXOr:
case AB_BitOr:
case AB_PROP_SET:
case AB_ARRAYA:
case AB_CONDN:
case AB_COND:
case AB_POP_TO:
case AB_RETURN:
// JUMPAND/JUMPOR/JUMPNNIL are special: They either jump over instructions adding one to the stack
// or decrement the stack. Thus, for stack counting purposes, they decrement.
case AB_JUMPAND:
case AB_JUMPOR:
case AB_JUMPNNIL:
return -1;
case AB_FUNC:
return -reinterpret_cast<C4AulFunc *>(X)->GetParCount() + 1;
case AB_CALL:
case AB_CALLFS:
return -C4AUL_MAX_Par;
case AB_STACK_SET:
case AB_LOCALN_SET:
case AB_PROP:
case AB_GLOBALN_SET:
case AB_Inc:
case AB_Dec:
case AB_BitNot:
case AB_Not:
case AB_Neg:
case AB_PAR:
case AB_FOREACH_NEXT:
case AB_ERR:
case AB_EOFN:
case AB_JUMP:
case AB_DEBUG:
return 0;
case AB_STACK:
return X;
case AB_NEW_ARRAY:
return -X + 1;
case AB_NEW_PROPLIST:
return -X * 2 + 1;
case AB_ARRAYA_SET:
case AB_ARRAY_SLICE:
return -2;
case AB_ARRAY_SLICE_SET:
return -3;
}
assert(0 && "GetStackValue: unexpected bytecode not handled");
return 0;
}
int C4AulCompiler::CodegenAstVisitor::AddVarAccess(const char *TokenSPos, C4AulBCCType eType, intptr_t varnum)
{
return AddBCC(TokenSPos, eType, 1 + varnum - (stack_height + Fn->VarNamed.iSize));
}
int C4AulCompiler::CodegenAstVisitor::AddBCC(const char *TokenSPos, C4AulBCCType eType, intptr_t X)
{
// Track stack size
stack_height += GetStackValue(eType, X);
// Use stack operation instead of 0-Any (enable optimization)
if (eType == AB_NIL)
{
eType = AB_STACK;
X = 1;
}
assert(eType != AB_STACK || X != 0);
// Join checks only if it's not a jump target
if (!at_jump_target && Fn->GetLastCode())
{
C4AulBCC *pCPos1 = Fn->GetLastCode();
// Skip noop stack operation
if (eType == AB_STACK && X == 0)
{
return Fn->GetCodePos() - 1;
}
// Join together stack operations
if (eType == AB_STACK && pCPos1->bccType == AB_STACK &&
(X <= 0 || pCPos1->Par.i >= 0))
{
pCPos1->Par.i += X;
// Empty? Remove it. This relies on the parser not issuing
// multiple negative stack operations consecutively, as
// that could result in removing a jump target bytecode.
if (!pCPos1->Par.i)
Fn->RemoveLastBCC();
return Fn->GetCodePos() - 1;
}
// Prune unneeded Incs / Decs
if (eType == AB_STACK && X < 0 && (pCPos1->bccType == AB_Inc || pCPos1->bccType == AB_Dec))
{
if (!pCPos1->Par.X)
{
pCPos1->bccType = eType;
pCPos1->Par.i = X;
return Fn->GetCodePos() - 1;
}
else
{
// If it was a result modifier, we can safely remove it knowing that it was neither
// the first chunk nor a jump target. We can therefore apply additional optimizations.
Fn->RemoveLastBCC();
pCPos1--;
}
}
// Join STACK_SET + STACK -1 to POP_TO (equivalent)
if (eType == AB_STACK && X == -1 && pCPos1->bccType == AB_STACK_SET)
{
pCPos1->bccType = AB_POP_TO;
return Fn->GetCodePos() - 1;
}
// Join POP_TO + DUP to AB_STACK_SET if both target the same slot
if (eType == AB_DUP && pCPos1->bccType == AB_POP_TO && X == pCPos1->Par.i + 1)
{
pCPos1->bccType = AB_STACK_SET;
return Fn->GetCodePos() - 1;
}
// Reduce some constructs like SUM + INT 1 to INC or DEC
if ((eType == AB_Sum || eType == AB_Sub) &&
pCPos1->bccType == AB_INT &&
(pCPos1->Par.i == 1 || pCPos1->Par.i == -1))
{
if ((pCPos1->Par.i > 0) == (eType == AB_Sum))
pCPos1->bccType = AB_Inc;
else
pCPos1->bccType = AB_Dec;
pCPos1->Par.i = X;
return Fn->GetCodePos() - 1;
}
// Reduce Not + CONDN to COND, Not + COND to CONDN
if ((eType == AB_CONDN || eType == AB_COND) && pCPos1->bccType == AB_Not)
{
pCPos1->bccType = eType == AB_CONDN ? AB_COND : AB_CONDN;
pCPos1->Par.i = X + 1;
return Fn->GetCodePos() - 1;
}
// Join AB_STRING + AB_ARRAYA to AB_PROP
if (eType == AB_ARRAYA && pCPos1->bccType == AB_STRING)
{
pCPos1->bccType = AB_PROP;
return Fn->GetCodePos() - 1;
}
// Join AB_INT + AB_Neg to AB_INT
if (eType == AB_Neg && pCPos1->bccType == AB_INT)
{
pCPos1->Par.i *= -1;
return Fn->GetCodePos() - 1;
}
}
// Add
Fn->AddBCC(eType, X, TokenSPos);
// Reset jump flag
at_jump_target = false;
return Fn->GetCodePos() - 1;
}
void C4AulCompiler::CodegenAstVisitor::RemoveLastBCC()
{
// Security: This is unsafe on anything that might get optimized away
C4AulBCC *pBCC = Fn->GetLastCode();
assert(pBCC->bccType != AB_STACK && pBCC->bccType != AB_STACK_SET && pBCC->bccType != AB_POP_TO);
// Correct stack
stack_height -= GetStackValue(pBCC->bccType, pBCC->Par.X);
// Remove
Fn->RemoveLastBCC();
}
int C4AulCompiler::CodegenAstVisitor::AddBCC(const char *SPos, const C4AulBCC &bcc)
{
return AddBCC(SPos, bcc.bccType, bcc.Par.X);
}
C4AulBCC C4AulCompiler::CodegenAstVisitor::MakeSetter(const char *SPos, bool fLeaveValue)
{
assert(Fn);
C4AulBCC Value = *(Fn->GetLastCode()), Setter = Value;
// Check type
switch (Value.bccType)
{
case AB_ARRAYA: Setter.bccType = AB_ARRAYA_SET; break;
case AB_ARRAY_SLICE: Setter.bccType = AB_ARRAY_SLICE_SET; break;
case AB_DUP:
Setter.bccType = AB_STACK_SET;
// the setter additionally has the new value on the stack
--Setter.Par.i;
break;
case AB_STACK_SET: Setter.bccType = AB_STACK_SET; break;
case AB_LOCALN:
Setter.bccType = AB_LOCALN_SET;
break;
case AB_PROP:
Setter.bccType = AB_PROP_SET;
break;
case AB_GLOBALN: Setter.bccType = AB_GLOBALN_SET; break;
default:
throw Error(target_host, host, SPos, Fn, "assignment to a constant");
}
// If the new value is produced using the old one, the parameters to get the old one need to be duplicated.
// Otherwise, the setter can just use the parameters originally meant for the getter.
// All getters push one value, so the parameter count is one more than the values they pop from the stack.
int iParCount = 1 - GetStackValue(Value.bccType, Value.Par.X);
if (Value.bccType == AB_STACK_SET)
{
// STACK_SET has a side effect, so it can't be simply removed.
// Discard the unused value the usual way instead.
if (!fLeaveValue)
AddBCC(SPos, AB_STACK, -1);
// The original parameter isn't needed anymore, since in contrast to the other getters
// it does not indicate a position.
iParCount = 0;
}
else if (!fLeaveValue || iParCount)
{
RemoveLastBCC();
at_jump_target = true; // In case the original BCC was a jump target
}
if (fLeaveValue && iParCount)
{
for (int i = 0; i < iParCount; i++)
AddBCC(SPos, AB_DUP, 1 - iParCount);
// Finally re-add original BCC
AddBCC(SPos, Value.bccType, Value.Par.X);
}
// Done. The returned BCC should be added later once the value to be set was pushed on top.
assert(iParCount == -GetStackValue(Setter.bccType, Setter.Par.X));
return Setter;
}
int C4AulCompiler::CodegenAstVisitor::AddJumpTarget()
{
assert(Fn && "Jump target outside of function");
if (!Fn)
throw C4AulParseError(host, "internal error: jump target outside of function");
at_jump_target = true;
return Fn->GetCodePos();
}
void C4AulCompiler::CodegenAstVisitor::UpdateJump(int jump, int target)
{
C4AulBCC *code = Fn->GetCodeByPos(jump);
assert(IsJump(code->bccType));
code->Par.i = target - jump;
}
void C4AulCompiler::CodegenAstVisitor::AddJumpTo(const char *loc, C4AulBCCType type, int target)
{
AddBCC(loc, type, target - Fn->GetCodePos());
}
void C4AulCompiler::CodegenAstVisitor::PushLoop()
{
active_loops.emplace(stack_height);
}
void C4AulCompiler::CodegenAstVisitor::PopLoop(int continue_target)
{
assert(!active_loops.empty());
assert(stack_height == active_loops.top().stack_height);
// Update all loop control jumps
const auto &loop = active_loops.top();
for (auto &c : loop.continues)
UpdateJump(c, continue_target);
int loop_exit = AddJumpTarget();
for (auto &b : loop.breaks)
UpdateJump(b, loop_exit);
active_loops.pop();
}
void C4AulCompiler::CodegenAstVisitor::AddLoopControl(const char *loc, Loop::Control c)
{
assert(!active_loops.empty());
if (active_loops.empty())
throw C4AulParseError(host, "internal error: loop control code emitted outside of loop");
// Clear stack
assert(active_loops.top().stack_height == stack_height);
if (active_loops.top().stack_height - stack_height > 0)
AddBCC(loc, AB_STACK, active_loops.top().stack_height - stack_height);
int jump = AddBCC(loc, AB_JUMP, 0);
switch (c)
{
case Loop::Control::Continue:
active_loops.top().continues.push_back(jump);
break;
case Loop::Control::Break:
active_loops.top().breaks.push_back(jump);
break;
}
}
void C4AulCompiler::CodegenAstVisitor::visit(const ::aul::ast::Noop *) {}
void C4AulCompiler::CodegenAstVisitor::visit(const ::aul::ast::StringLit *n)
{
StackGuard g(this, 1);
AddBCC(n->loc, AB_STRING, (intptr_t)::Strings.RegString(n->value.c_str()));
type_of_stack_top = C4V_String;
}
void C4AulCompiler::CodegenAstVisitor::visit(const ::aul::ast::IntLit *n)
{
StackGuard g(this, 1);
AddBCC(n->loc, AB_INT, n->value);
type_of_stack_top = C4V_Int;
}
void C4AulCompiler::CodegenAstVisitor::visit(const ::aul::ast::BoolLit *n)
{
StackGuard g(this, 1);
AddBCC(n->loc, AB_BOOL, n->value);
type_of_stack_top = C4V_Bool;
}
void C4AulCompiler::CodegenAstVisitor::visit(const ::aul::ast::ArrayLit *n)
{
StackGuard g(this, 1);
for (const auto &e : n->values)
{
SafeVisit(e);
}
AddBCC(n->loc, AB_NEW_ARRAY, n->values.size());
type_of_stack_top = C4V_Array;
}
void C4AulCompiler::CodegenAstVisitor::visit(const ::aul::ast::ProplistLit *n)
{
StackGuard g(this, 1);
for (const auto &e : n->values)
{
StackGuard g(this, 2);
AddBCC(n->loc, AB_STRING, (intptr_t)::Strings.RegString(e.first.c_str()));
SafeVisit(e.second);
}
AddBCC(n->loc, AB_NEW_PROPLIST, n->values.size());
type_of_stack_top = C4V_PropList;
}
void C4AulCompiler::CodegenAstVisitor::visit(const ::aul::ast::NilLit *n)
{
StackGuard g(this, 1);
AddBCC(n->loc, AB_NIL);
type_of_stack_top = C4V_Nil;
}
void C4AulCompiler::CodegenAstVisitor::visit(const ::aul::ast::ThisLit *n)
{
StackGuard g(this, 1);
AddBCC(n->loc, AB_THIS);
type_of_stack_top = C4V_PropList;
}
void C4AulCompiler::CodegenAstVisitor::visit(const ::aul::ast::VarExpr *n)
{
StackGuard g(this, 1);
assert(Fn);
assert(!scopes.empty());
C4Value dummy;
const char *cname = n->identifier.c_str();
C4String *interned = ::Strings.FindString(cname);
// Reset known type of top of value stack so we don't keep the old one around
type_of_stack_top = C4V_Any;
// Lookup order: Parameters > var > local > global > global const
// Why parameters are considered before function-scoped variables
// you ask? I've no idea, but that's how it was before I started
// changing things.
// NOTE: If you change this, remember to also change the warning
// (variable_shadows_variable) in PreparseAstVisitor.
if (Fn->ParNamed.GetItemNr(cname) != -1)
{
int pos = Fn->ParNamed.GetItemNr(cname);
AddVarAccess(n->loc, AB_DUP, -Fn->GetParCount() + pos);
type_of_stack_top = Fn->GetParType()[pos];
}
else if (Fn->VarNamed.GetItemNr(cname) != -1)
{
const bool in_scope = end(scopes) != std::find_if(begin(scopes), end(scopes), [n](const Scope &scope) {
return scope.variables.find(n->identifier) != scope.variables.end();
});
if (!in_scope)
{
Warn(target_host, host, n, Fn, C4AulWarningId::variable_out_of_scope, cname);
}
AddVarAccess(n->loc, AB_DUP, Fn->VarNamed.GetItemNr(cname));
}
// Can't use Fn->Parent->HasProperty here because that only returns true
// for immediate properties, while we also want to interrogate prototypes
else if (Fn->Parent && interned && Fn->Parent->GetPropertyByS(interned, &dummy))
{
AddBCC(n->loc, AB_LOCALN, (intptr_t)interned);
}
else if (ScriptEngine.GlobalNamedNames.GetItemNr(cname) != -1)
{
AddBCC(n->loc, AB_GLOBALN, ScriptEngine.GlobalNamedNames.GetItemNr(cname));
}
else if (ScriptEngine.GlobalConstNames.GetItemNr(cname) != -1)
{
C4Value v;
ENSURE_COND(ScriptEngine.GetGlobalConstant(cname, &v), "internal error: global constant not retrievable");
switch (v.GetType())
{
case C4V_Nil:
AddBCC(n->loc, AB_NIL);
break;
case C4V_Int:
AddBCC(n->loc, AB_INT, v._getInt());
break;
case C4V_Bool:
AddBCC(n->loc, AB_BOOL, v._getBool());
break;
case C4V_PropList:
AddBCC(n->loc, AB_CPROPLIST, reinterpret_cast<intptr_t>(v._getPropList()));
break;
case C4V_String:
AddBCC(n->loc, AB_STRING, reinterpret_cast<intptr_t>(v._getStr()));
break;
case C4V_Array:
AddBCC(n->loc, AB_CARRAY, reinterpret_cast<intptr_t>(v._getArray()));
break;
case C4V_Function:
AddBCC(n->loc, AB_CFUNCTION, reinterpret_cast<intptr_t>(v._getFunction()));
default:
AddBCC(n->loc, AB_NIL);
throw Error(target_host, host, n, Fn, "internal error: global constant of unexpected type: %s (of type %s)", cname, v.GetTypeName());
}
type_of_stack_top = v.GetType();
}
else
{
AddBCC(n->loc, AB_NIL);
throw Error(target_host, host, n, Fn, "symbol not found in any symbol table: %s", cname);
}
}
void C4AulCompiler::CodegenAstVisitor::visit(const ::aul::ast::UnOpExpr *n)
{
StackGuard g(this, 1);
n->operand->accept(this);
const auto &op = C4ScriptOpMap[n->op];
if (op.Changer)
{
C4AulBCC setter = MakeSetter(n->loc, true);
AddBCC(n->loc, op.Code, 0);
AddBCC(n->loc, setter);
// On postfix inc/dec, regenerate the previous value
if (op.Postfix && (op.Code == AB_Inc || op.Code == AB_Dec))
{
AddBCC(n->loc, op.Code == AB_Inc ? AB_Dec : AB_Inc, 1);
}
}
else
{
AddBCC(n->loc, op.Code);
}
type_of_stack_top = op.RetType;
}
void C4AulCompiler::CodegenAstVisitor::visit(const ::aul::ast::BinOpExpr *n)
{
StackGuard g(this, 1);
SafeVisit(n->lhs);
const auto &op = C4ScriptOpMap[n->op];
if (op.Code == AB_JUMPAND || op.Code == AB_JUMPOR || op.Code == AB_JUMPNNIL)
{
// Short-circuiting operators. These are slightly more complex
// because we don't want to evaluate their rhs operand when the
// lhs one already decided the result
int jump = AddBCC(n->loc, op.Code);
SafeVisit(n->rhs);
UpdateJump(jump, AddJumpTarget());
}
else if (op.Changer)
{
try
{
C4AulBCC setter = MakeSetter(n->loc, true);
SafeVisit(n->rhs);
AddBCC(n->loc, op.Code);
AddBCC(n->loc, setter);
}
catch (C4AulParseError &e)
{
HandleError(e);
}
}
else
{
SafeVisit(n->rhs);
AddBCC(n->loc, op.Code, 0);
}
type_of_stack_top = op.RetType;
}
void C4AulCompiler::CodegenAstVisitor::visit(const ::aul::ast::AssignmentExpr *n)
{
StackGuard g(this, 1);
SafeVisit(n->lhs);
try
{
C4AulBCC setter = MakeSetter(n->loc, false);
SafeVisit(n->rhs);
AddBCC(n->loc, setter);
}
catch (C4AulParseError &e)
{
HandleError(e);
}
// Assignment does not change the type of the variable
}
void C4AulCompiler::CodegenAstVisitor::visit(const ::aul::ast::SubscriptExpr *n)
{
StackGuard g(this, 1);
SafeVisit(n->object);
SafeVisit(n->index);
AddBCC(n->loc, AB_ARRAYA);
// FIXME: Check if the subscripted object is a literal and if so, retrieve type
type_of_stack_top = C4V_Any;
}
void C4AulCompiler::CodegenAstVisitor::visit(const ::aul::ast::SliceExpr *n)
{
StackGuard g(this, 1);
SafeVisit(n->object);
SafeVisit(n->start);
SafeVisit(n->end);
AddBCC(n->loc, AB_ARRAY_SLICE);
type_of_stack_top = C4V_Array;
}
void C4AulCompiler::CodegenAstVisitor::visit(const ::aul::ast::CallExpr *n)
{
const char *cname = n->callee.c_str();
if (n->callee == C4AUL_DebugBreak)
{
if (n->context)
throw Error(target_host, host, n, Fn, R"("%s" can't be called in a different context)", cname);
if (!n->args.empty())
throw Error(target_host, host, n, Fn, R"("%s" must not have any arguments)", cname);
AddBCC(n->loc, AB_DEBUG);
// Add a pseudo-nil to keep the stack balanced
AddBCC(n->loc, AB_NIL);
type_of_stack_top = C4V_Nil;
return;
}
if (n->callee == C4AUL_Inherited || n->callee == C4AUL_SafeInherited)
{
// inherited can only be called within the same context
if (n->context)
{
throw Error(target_host, host, n, Fn, R"("%s" can't be called in a different context)", cname);
}
}
if (n->callee == C4AUL_Inherited && !Fn->OwnerOverloaded)
{
throw Error(target_host, host, n, Fn, "inherited function not found (use " C4AUL_SafeInherited " to disable this message)");
}
const auto pre_call_stack = stack_height;
if (n->context)
SafeVisit(n->context);
std::vector<C4V_Type> known_par_types;
known_par_types.reserve(n->args.size());
for (const auto &arg : n->args)
{
SafeVisit(arg);
known_par_types.push_back(type_of_stack_top);
}
C4AulFunc *callee = nullptr;
// Special handling for the overload chain
if (n->callee == C4AUL_Inherited || n->callee == C4AUL_SafeInherited)
{
callee = Fn->OwnerOverloaded;
}
size_t fn_argc = C4AUL_MAX_Par;
if (!n->context)
{
// if this is a function without explicit context, we resolve it
if (!callee)
callee = Fn->Parent->GetFunc(cname);
if (!callee && target_host)
callee = target_host->Engine->GetFunc(cname);
if (callee)
{
fn_argc = callee->GetParCount();
}
else
{
// pop all args off the stack
if (!n->args.empty())
AddBCC(n->loc, AB_STACK, -(intptr_t)n->args.size());
// and "return" nil
AddBCC(n->loc, AB_NIL);
type_of_stack_top = C4V_Nil;
if (n->callee != C4AUL_SafeInherited)
{
HandleError(Error(target_host, host, n, Fn, "called function not found: %s", cname));
}
return;
}
}
if (n->args.size() > fn_argc)
{
// Pop off any args that are over the limit
Warn(target_host, host, n->args[fn_argc].get(), Fn, C4AulWarningId::arg_count_mismatch,
cname, (unsigned)n->args.size(), fn_argc);
AddBCC(n->loc, AB_STACK, fn_argc - n->args.size());
}
else if (n->args.size() < fn_argc)
{
if (n->append_unnamed_pars)
{
assert(Fn->GetParCount() == C4AUL_MAX_Par);
int missing_par_count = fn_argc - n->args.size();
int available_par_count = Fn->GetParCount() - Fn->ParNamed.iSize;
for (int i = 0; i < std::min(missing_par_count, available_par_count); ++i)
{
AddVarAccess(n->loc, AB_DUP, -Fn->GetParCount() + Fn->ParNamed.iSize + i);
}
// Fill up remaining, unsettable parameters with nil
if (available_par_count < missing_par_count)
AddBCC(n->loc, AB_STACK, missing_par_count - available_par_count);
}
else if (fn_argc > n->args.size())
{
// Add nil for each missing parameter
AddBCC(n->loc, AB_STACK, fn_argc - n->args.size());
}
}
// Check passed parameters for this call (as far as possible)
std::vector<C4V_Type> expected_par_types;
if (n->context)
{
AddBCC(n->loc, n->safe_call ? AB_CALLFS : AB_CALL, (intptr_t)::Strings.RegString(cname));
// Since we don't know the context in which this call will happen at
// runtime, we'll check whether all available functions with the same
// name agree on their parameters.
const C4AulFunc *candidate = target_host ? target_host->Engine->GetFirstFunc(cname) : nullptr;
if (candidate)
{
expected_par_types.assign(candidate->GetParType(), candidate->GetParType() + candidate->GetParCount());
while ((candidate = target_host->Engine->GetNextSNFunc(candidate)) != nullptr)
{
if (candidate->GetParCount() > expected_par_types.size())
{
expected_par_types.resize(candidate->GetParCount(), C4V_Any);
}
for (size_t i = 0; i < expected_par_types.size(); ++i)
{
C4V_Type a = expected_par_types[i];
C4V_Type b = candidate->GetParType()[i];
// If we can convert one of the types into the other
// without a warning, use the wider one
bool implicit_a_to_b = !C4Value::WarnAboutConversion(a, b);
bool implicit_b_to_a = !C4Value::WarnAboutConversion(b, a);
if (implicit_a_to_b && !implicit_b_to_a)
expected_par_types[i] = b;
else if (implicit_b_to_a && !implicit_a_to_b)
expected_par_types[i] = a;
// but if we can convert neither of the types into the
// other, give up and assume the user will do the right
// thing
else if (!implicit_a_to_b && !implicit_b_to_a)
expected_par_types[i] = C4V_Any;
}
}
}
type_of_stack_top = C4V_Any;
}
else
{
assert(callee);
AddBCC(n->loc, AB_FUNC, (intptr_t)callee);
expected_par_types.assign(callee->GetParType(), callee->GetParType() + callee->GetParCount());
type_of_stack_top = callee->GetRetType();
}
// Check parameters
for (size_t i = 0; i < std::min(known_par_types.size(), expected_par_types.size()); ++i)
{
C4V_Type from = known_par_types[i];
C4V_Type to = expected_par_types[i];
if (C4Value::WarnAboutConversion(from, to))
{
Warn(target_host, host, n->args[i].get(), Fn, C4AulWarningId::arg_type_mismatch, (unsigned)i, cname, GetC4VName(from), GetC4VName(to));
}
}
// We leave one value (the return value) on the stack
assert(pre_call_stack + 1 == stack_height);
}
void C4AulCompiler::CodegenAstVisitor::visit(const ::aul::ast::ParExpr *n)
{
StackGuard g(this, 1);
SafeVisit(n->arg);
AddBCC(n->loc, AB_PAR);
type_of_stack_top = C4V_Any;
}
void C4AulCompiler::CodegenAstVisitor::visit(const ::aul::ast::Block *n)
{
auto scope = enterScope();
for (const auto &s : n->children)
{
StackGuard g(this, 0);
if (SafeVisit(s))
{
// If the statement has left a stack value, pop it off
MaybePopValueOf(s);
}
}
}
void C4AulCompiler::CodegenAstVisitor::visit(const ::aul::ast::Return *n)
{
StackGuard g(this, 0);
WarnOnAssignment(n->value);
SafeVisit(n->value);
AddBCC(n->loc, AB_RETURN);
}
void C4AulCompiler::CodegenAstVisitor::visit(const ::aul::ast::ForLoop *n)
{
// Bytecode arranged like this:
// initializer
// cond: condition
// CONDN exit
// body: body
// incr: incrementor
// JUMP cond
// exit:
//
// continue jumps to incr
// break jumps to exit
auto scope = enterScope();
if (n->init)
{
if (SafeVisit(n->init))
MaybePopValueOf(n->init);
}
int cond = -1, condition_jump = -1;
PushLoop();
if (n->cond)
{
// XXX:
// Assignments in the condition here should warn as well (like they do in
// if conditions) but a ton of code uses those assignments at the moment
// and people are divided about allowing it
cond = AddJumpTarget();
SafeVisit(n->cond);
active_loops.top().breaks.push_back(AddBCC(n->cond->loc, AB_CONDN));
}
int body = AddJumpTarget();
if (!n->cond)
cond = body;
if (SafeVisit(n->body))
MaybePopValueOf(n->body);
int incr = -1;
if (n->incr)
{
incr = AddJumpTarget();
if (SafeVisit(n->incr))
MaybePopValueOf(n->incr);
}
else
{
// If no incrementor exists, just jump straight to the condition
incr = cond;
}
// start the next iteration of the loop
AddJumpTo(n->loc, AB_JUMP, cond);
PopLoop(incr);
}
void C4AulCompiler::CodegenAstVisitor::visit(const ::aul::ast::RangeLoop *n)
{
// Bytecode arranged like this:
// condition (aka iterated array)
// INT 0 (the loop index variable)
// cond: FOREACH_NEXT
// JUMP exit
// body: body
// JUMP cond
// exit: STACK -2 (to clean the iteration variables)
//
// continue jumps to cond
// break jumps to exit
auto scope = enterScope();
scopes.front().variables.insert(n->var);
const char *cname = n->var.c_str();
int var_id = Fn->VarNamed.GetItemNr(cname);
assert(var_id != -1 && "CodegenAstVisitor: unable to find variable in foreach");
if (var_id == -1)
throw Error(target_host, host, n, Fn, "internal error: unable to find variable in foreach: %s", cname);
// Emit code for array
SafeVisit(n->cond);
// Emit code for iteration
AddBCC(n->loc, AB_INT, 0);
int cond = AddJumpTarget();
PushLoop();
AddVarAccess(n->loc, AB_FOREACH_NEXT, var_id);
AddLoopControl(n->loc, Loop::Control::Break); // Will be skipped by AB_FOREACH_NEXT as long as more entries exist
// Emit body
if (SafeVisit(n->body))
MaybePopValueOf(n->body);
// continue starts the next iteration of the loop
AddLoopControl(n->loc, Loop::Control::Continue);
PopLoop(cond);
// Pop off iterator and array
AddBCC(n->loc, AB_STACK, -2);
}
void C4AulCompiler::CodegenAstVisitor::EmitFunctionCode(const ::aul::ast::Function *f, const ::aul::ast::Node *n)
{
assert(Fn != nullptr);
assert(scopes.empty());
Fn->ClearCode();
// Reserve var stack space
if (Fn->VarNamed.iSize > 0)
AddBCC(n->loc, AB_STACK, Fn->VarNamed.iSize);
stack_height = 0;
auto scope = enterScope();
try
{
f->body->accept(this);
}
catch (C4AulParseError &e)
{
AddBCC(nullptr, AB_ERR, (intptr_t)::Strings.RegString(e.what()));
throw;
}
if (f->body->children.empty() || !dynamic_cast<::aul::ast::Return*>(f->body->children.rbegin()->get()))
{
// If the last statement isn't a return, add one to the byte
// code. We're not doing CFA because the worst thing that might
// happen is we insert two instructions that never get executed.
AddBCC(n->loc, AB_NIL);
AddBCC(n->loc, AB_RETURN);
}
Fn->DumpByteCode();
// This instruction should never be reached but we'll add it just in
// case.
AddBCC(n->loc, AB_EOFN);
assert(stack_height == 0);
}
void C4AulCompiler::CodegenAstVisitor::visit(const ::aul::ast::DoLoop *n)
{
auto scope = enterScope();
int body = AddJumpTarget();
PushLoop();
if (SafeVisit(n->body))
MaybePopValueOf(n->body);
int cond = AddJumpTarget();
// XXX:
// Assignments in the condition here should warn as well (like they do in
// if conditions) but a ton of code uses those assignments at the moment
// and people are divided about allowing it
SafeVisit(n->cond);
AddJumpTo(n->loc, AB_COND, body);
PopLoop(cond);
}
void C4AulCompiler::CodegenAstVisitor::visit(const ::aul::ast::WhileLoop *n)
{
auto scope = enterScope();
int cond = AddJumpTarget();
PushLoop();
// XXX:
// Assignments in the condition here should warn as well (like they do in
// if conditions) but a ton of code uses those assignments at the moment
// and people are divided about allowing it
SafeVisit(n->cond);
active_loops.top().breaks.push_back(AddBCC(n->cond->loc, AB_CONDN));
if (SafeVisit(n->body))
MaybePopValueOf(n->body);
// continue starts the next iteration of the loop
AddLoopControl(n->loc, Loop::Control::Continue);
PopLoop(cond);
}
void C4AulCompiler::CodegenAstVisitor::visit(const ::aul::ast::Break *n)
{
ENSURE_COND(!active_loops.empty(), "'break' outside loop");
AddLoopControl(n->loc, Loop::Control::Break);
}
void C4AulCompiler::CodegenAstVisitor::visit(const ::aul::ast::Continue *n)
{
ENSURE_COND(!active_loops.empty(), "'continue' outside loop");
AddLoopControl(n->loc, Loop::Control::Continue);
}
void C4AulCompiler::CodegenAstVisitor::visit(const ::aul::ast::If *n)
{
auto scope = enterScope();
WarnOnAssignment(n->cond);
SafeVisit(n->cond);
int jump = AddBCC(n->loc, AB_CONDN);
// Warn if we're controlling a no-op ("if (...);")
if (dynamic_cast<::aul::ast::Noop*>(n->iftrue.get()))
{
Warn(target_host, host, n->iftrue->loc, Fn, C4AulWarningId::empty_if);
}
if (SafeVisit(n->iftrue))
MaybePopValueOf(n->iftrue);
if (dynamic_cast<::aul::ast::Noop*>(n->iffalse.get()))
{
Warn(target_host, host, n->iffalse->loc, Fn, C4AulWarningId::empty_if);
}
if (n->iffalse)
{
int jumpout = AddBCC(n->loc, AB_JUMP);
UpdateJump(jump, AddJumpTarget());
jump = jumpout;
if (SafeVisit(n->iffalse))
MaybePopValueOf(n->iffalse);
}
UpdateJump(jump, AddJumpTarget());
}
void C4AulCompiler::CodegenAstVisitor::visit(const ::aul::ast::VarDecl *n)
{
for (const auto &dec : n->decls)
{
const char *cname = dec.name.c_str();
switch (n->scope)
{
case ::aul::ast::VarDecl::Scope::Func:
scopes.front().variables.insert(dec.name);
if (dec.init)
{
// Emit code for the initializer
SafeVisit(dec.init);
int var_idx = Fn->VarNamed.GetItemNr(cname);
assert(var_idx >= 0 && "CodegenAstVisitor: var not found in variable table");
if (var_idx < 0)
{
AddBCC(n->loc, AB_STACK, -1);
throw Error(target_host, host, n, Fn, "internal error: var not found in variable table: %s", cname);
}
AddVarAccess(n->loc, AB_POP_TO, var_idx);
}
break;
case ::aul::ast::VarDecl::Scope::Object:
case ::aul::ast::VarDecl::Scope::Global:
// Object-local and global constants are handled by ConstantResolver.
break;
}
}
}
void C4AulCompiler::CodegenAstVisitor::visit(const ::aul::ast::FunctionDecl *n)
{
assert(!Fn && "CodegenAstVisitor: function declaration encountered within active function");
if (Fn)
throw Error(target_host, host, n, Fn, "internal error: function declaration for '%s' encountered within active function", n->name.c_str());
C4PropListStatic *Parent = n->is_global ? target_host->Engine->GetPropList() : target_host->GetPropList();
C4String *name = ::Strings.FindString(n->name.c_str());
C4AulFunc *f = Parent->GetFunc(name);
while (f)
{
if (f->SFunc() && f->SFunc()->pOrgScript == host && f->Parent == Parent)
{
if (Fn)
Warn(target_host, host, n, Fn, C4AulWarningId::redeclaration, "function", f->GetName());
Fn = f->SFunc();
}
f = f->SFunc() ? f->SFunc()->OwnerOverloaded : nullptr;
}
if (!Fn && Parent->HasProperty(name))
{
throw Error(target_host, host, n, Fn, "declaration of '%s': cannot override local variable via 'func %s'", n->name.c_str(), n->name.c_str());
}
assert(Fn && "CodegenAstVisitor: unable to find function definition");
if (!Fn)
throw Error(target_host, host, n, Fn, "internal error: unable to find function definition for %s", n->name.c_str());
// If this isn't a global function, but there is a global one with
// the same name, and this function isn't overloading a different
// one, add the global function to the overload chain
if (!n->is_global && !Fn->OwnerOverloaded)
{
C4AulFunc *global_parent = target_host->Engine->GetFunc(Fn->GetName());
if (global_parent)
Fn->SetOverloaded(global_parent);
}
try
{
EmitFunctionCode(n);
Fn = nullptr;
}
catch (...)
{
Fn = nullptr;
throw;
}
}
void C4AulCompiler::CodegenAstVisitor::visit(const::aul::ast::FunctionExpr * n)
{
AddBCC(n->loc, AB_NIL);
throw Error(target_host, host, n, Fn, "can't define a function in a function-scoped proplist");
}
void C4AulCompiler::CodegenAstVisitor::visit(const::aul::ast::Script * n)
{
for (const auto &d : n->declarations)
{
SafeVisit(d);
}
}
#undef ENSURE_COND
#define ENSURE_COND(cond, failmsg) do { if (!(cond)) throw Error(host, host, n, nullptr, failmsg); } while (0)
// Evaluates constant AST subtrees and returns the final C4Value.
// Throws ExpressionNotConstant if evaluation fails.
C4Value C4AulCompiler::ConstexprEvaluator::eval(C4ScriptHost *host, const ::aul::ast::Expr *e, EvalFlags flags)
{
ConstexprEvaluator ce(host);
ce.ignore_unset_values = (flags & IgnoreUnset) == IgnoreUnset;
try
{
e->accept(&ce);
return ce.v;
}
catch (C4AulParseError &e)
{
if ((flags & SuppressErrors) == 0)
host->Engine->ErrorHandler->OnError(e.what());
return C4VNull;
}
}
C4Value C4AulCompiler::ConstexprEvaluator::eval_static(C4ScriptHost *host, C4PropListStatic *parent, const std::string &parent_key, const ::aul::ast::Expr *e, EvalFlags flags)
{
ConstexprEvaluator ce(host);
ce.proplist_magic = ConstexprEvaluator::ProplistMagic{ true, parent, parent_key };
ce.ignore_unset_values = (flags & IgnoreUnset) == IgnoreUnset;
try
{
e->accept(&ce);
return ce.v;
}
catch (C4AulParseError &e)
{
if ((flags & SuppressErrors) == 0)
host->Engine->ErrorHandler->OnError(e.what());
return C4VNull;
}
}
void C4AulCompiler::ConstexprEvaluator::visit(const ::aul::ast::StringLit *n) { v = C4VString(n->value.c_str()); }
void C4AulCompiler::ConstexprEvaluator::visit(const ::aul::ast::IntLit *n) { v = C4VInt(n->value); }
void C4AulCompiler::ConstexprEvaluator::visit(const ::aul::ast::BoolLit *n) { v = C4VBool(n->value); }
void C4AulCompiler::ConstexprEvaluator::visit(const ::aul::ast::ArrayLit *n)
{
auto a = std::make_unique<C4ValueArray>(n->values.size());
for (size_t i = 0; i < n->values.size(); ++i)
{
n->values[i]->accept(this);
a->SetItem(i, v);
}
v = C4VArray(a.release());
}
void C4AulCompiler::ConstexprEvaluator::visit(const ::aul::ast::ProplistLit *n)
{
std::unique_ptr<C4PropList> new_proplist;
C4PropList *p = nullptr;
bool first_pass = true;
if (proplist_magic.active)
{
// Check if there's already a proplist available
C4String *key = ::Strings.RegString(proplist_magic.key.c_str());
C4Value old;
if (proplist_magic.parent)
{
proplist_magic.parent->GetPropertyByS(key, &old);
}
else
{
// If proplist_magic.parent is nullptr, we're handling a global constant.
host->Engine->GetGlobalConstant(key->GetCStr(), &old);
}
if (old.getPropList())
{
p = old.getPropList();
first_pass = false;
}
else
{
p = C4PropList::NewStatic(nullptr, proplist_magic.parent, key);
new_proplist.reset(p);
}
}
else
{
p = C4PropList::New();
new_proplist.reset(p);
}
// Since the values may be functions that refer to other values in the
// proplist, pre-populate the new proplist with dummy values until the
// real ones are set
if (first_pass)
{
for (const auto &kv : n->values)
{
p->SetPropertyByS(::Strings.RegString(kv.first.c_str()), C4VNull);
}
}
auto saved_magic = std::move(proplist_magic);
for (const auto &kv : n->values)
{
proplist_magic = ProplistMagic { saved_magic.active, p->IsStatic(), kv.first };
kv.second->accept(this);
p->SetPropertyByS(::Strings.RegString(kv.first.c_str()), v);
}
proplist_magic = std::move(saved_magic);
v = C4VPropList(p);
new_proplist.release();
}
void C4AulCompiler::ConstexprEvaluator::visit(const ::aul::ast::NilLit *) { v = C4VNull; }
void C4AulCompiler::ConstexprEvaluator::visit(const ::aul::ast::ThisLit *n) { nonconst(n, "\"this\" is not a global constant"); }
void C4AulCompiler::ConstexprEvaluator::visit(const ::aul::ast::VarExpr *n)
{
const char *cname = n->identifier.c_str();
C4String *interned = ::Strings.FindString(cname);
if (interned && host->GetPropList()->GetPropertyByS(interned, &v))
return;
if (host->Engine->GetGlobalConstant(cname, &v))
return;
if (ignore_unset_values)
{
v = C4VNull;
return;
}
nonconst(n, "the variable \"%s\" is not a global constant", cname);
}
void C4AulCompiler::ConstexprEvaluator::visit(const ::aul::ast::UnOpExpr *n)
{
n->operand->accept(this);
assert(n->op > 0);
const auto &op = C4ScriptOpMap[n->op];
if (op.Changer)
nonconst(n, "unary operator %s is applied in a non-const fashion", op.Identifier);
AssertValueType(v, op.Type1, op.Identifier, n);
switch (op.Code)
{
case AB_BitNot:
v.SetInt(~v._getInt());
break;
case AB_Not:
v.SetBool(!v.getBool());
break;
case AB_Neg:
v.SetInt(-v._getInt());
break;
default:
assert(!"ConstexprEvaluator: Unexpected unary operator");
throw Error(host, host, n, nullptr, "internal error: unary operator not found in operator table");
}
}
void C4AulCompiler::ConstexprEvaluator::visit(const ::aul::ast::BinOpExpr *n)
{
assert(n->op > 0);
const auto &op = C4ScriptOpMap[n->op];
if (op.Changer)
nonconst(n, "binary operator %s is applied in a non-const fashion", op.Identifier);
n->lhs->accept(this);
C4Value lhs = v;
// Evaluate the short-circuiting operators here
if ((op.Code == AB_JUMPAND && !lhs) || (op.Code == AB_JUMPOR && lhs) || (op.Code == AB_JUMPNNIL && lhs.GetType() != C4V_Nil))
{
v = lhs;
return;
}
n->rhs->accept(this);
C4Value &rhs = v;
AssertValueType(lhs, op.Type1, op.Identifier, n);
AssertValueType(rhs, op.Type2, op.Identifier, n);
switch (op.Code)
{
case AB_Pow:
v.SetInt(Pow(lhs._getInt(), rhs._getInt()));
break;
case AB_Div:
ENSURE_COND(rhs._getInt() != 0, "division by zero");
ENSURE_COND(lhs._getInt() != INT32_MIN || rhs._getInt() != -1, "division overflow");
v.SetInt(lhs._getInt() / rhs._getInt());
break;
case AB_Mul:
v.SetInt(lhs._getInt() * rhs._getInt());
break;
case AB_Mod:
ENSURE_COND(rhs._getInt() != 0, "division by zero");
ENSURE_COND(lhs._getInt() != INT32_MIN || rhs._getInt() != -1, "division overflow");
v.SetInt(lhs._getInt() / rhs._getInt());
break;
#define INT_BINOP(code, op) case code: v.SetInt(lhs._getInt() op rhs._getInt()); break
INT_BINOP(AB_Sum, +);
INT_BINOP(AB_Sub, -);
INT_BINOP(AB_LeftShift, << );
INT_BINOP(AB_RightShift, >> );
INT_BINOP(AB_BitAnd, &);
INT_BINOP(AB_BitXOr, ^);
INT_BINOP(AB_BitOr, | );
#undef INT_BINOP
#define BOOL_BINOP(code, op) case code: v.SetBool(lhs._getInt() op rhs._getInt()); break
BOOL_BINOP(AB_LessThan, <);
BOOL_BINOP(AB_LessThanEqual, <= );
BOOL_BINOP(AB_GreaterThan, >);
BOOL_BINOP(AB_GreaterThanEqual, >= );
#undef BOOL_BINOP
case AB_Equal:
v.SetBool(lhs.IsIdenticalTo(rhs));
break;
case AB_NotEqual:
v.SetBool(!lhs.IsIdenticalTo(rhs));
break;
case AB_JUMPAND:
case AB_JUMPOR:
case AB_JUMPNNIL:
// If we hit this, then the short-circuit above failed
v = rhs;
break;
default:
assert(!"ConstexprEvaluator: Unexpected binary operator");
throw Error(host, host, n, nullptr, "internal error: binary operator not found in operator table");
break;
}
}
void C4AulCompiler::ConstexprEvaluator::visit(const ::aul::ast::AssignmentExpr *n)
{
nonconst(n, "updating assignment used in a non-const fashion");
}
void C4AulCompiler::ConstexprEvaluator::visit(const ::aul::ast::SubscriptExpr *n)
{
n->object->accept(this);
C4Value obj = v;
n->index->accept(this);
C4Value &index = v;
if (obj.CheckConversion(C4V_Array))
{
ENSURE_COND(index.CheckConversion(C4V_Int), FormatString("array access: index of type %s, but expected int", index.GetTypeName()).getData());
v = obj.getArray()->GetItem(index.getInt());
}
else if (obj.CheckConversion(C4V_PropList))
{
ENSURE_COND(index.CheckConversion(C4V_String), FormatString("proplist access: index of type %s, but expected string", index.GetTypeName()).getData());
if (!obj.getPropList()->GetPropertyByS(index.getStr(), &v))
v.Set0();
}
else
{
ENSURE_COND(false, FormatString("can't access %s as array or proplist", obj.GetTypeName()).getData());
}
}
void C4AulCompiler::ConstexprEvaluator::visit(const ::aul::ast::SliceExpr *n)
{
n->object->accept(this);
C4Value obj = v;
n->start->accept(this);
C4Value start = v;
n->end->accept(this);
C4Value &end = v;
ENSURE_COND(obj.CheckConversion(C4V_Array), FormatString("array slice: can't access %s as an array", obj.GetTypeName()).getData());
ENSURE_COND(start.CheckConversion(C4V_Int), FormatString("array slice: start index of type %s, int expected", start.GetTypeName()).getData());
ENSURE_COND(end.CheckConversion(C4V_Int), FormatString("array slice: end index of type %s, int expected", end.GetTypeName()).getData());
v.SetArray(obj.getArray()->GetSlice(start.getInt(), end.getInt()));
}
void C4AulCompiler::ConstexprEvaluator::visit(const ::aul::ast::CallExpr *n)
{
// TODO: allow side-effect-free calls here
nonconst(n, "call to function (%s) not supported in constant expressions", n->callee.c_str());
}
void C4AulCompiler::ConstexprEvaluator::visit(const ::aul::ast::FunctionExpr *n)
{
// Function expressions can only occur inside static proplists.
ENSURE_COND(proplist_magic.active, "internal error: function expression outside of static proplist");
C4AulScriptFunc *sfunc = nullptr;
bool first_pass = true;
if (auto func = proplist_magic.parent->GetFunc(proplist_magic.key.c_str()))
{
sfunc = func->SFunc();
first_pass = false;
}
else
{
sfunc = new C4AulScriptFunc(proplist_magic.parent, host, proplist_magic.key.c_str(), n->loc);
}
ENSURE_COND(sfunc != nullptr, "internal error: function expression target resolved to non-function value");
if (first_pass)
{
for (const auto &param : n->params)
{
sfunc->AddPar(param.name.c_str());
}
if (n->has_unnamed_params)
sfunc->ParCount = C4AUL_MAX_Par;
PreparseAstVisitor preparser(host, host, sfunc);
preparser.visit(n->body.get());
}
else
{
CodegenAstVisitor cg(sfunc);
cg.EmitFunctionCode(n);
}
v.SetFunction(sfunc);
}
void C4AulCompiler::ConstantResolver::visit(const::aul::ast::Script *n)
{
for (const auto &d : n->declarations)
{
try
{
d->accept(this);
}
catch (C4AulParseError &e)
{
host->Engine->GetErrorHandler()->OnError(e.what());
}
}
}
void C4AulCompiler::ConstantResolver::visit(const ::aul::ast::VarDecl *n)
{
const int quiet_flag = quiet ? ConstexprEvaluator::SuppressErrors : 0;
for (const auto &dec : n->decls)
{
const char *cname = dec.name.c_str();
C4RefCntPointer<C4String> name = ::Strings.RegString(cname);
switch (n->scope)
{
case ::aul::ast::VarDecl::Scope::Func:
// Function-scoped declarations and their initializers are handled by CodegenAstVisitor.
break;
case ::aul::ast::VarDecl::Scope::Object:
if (!host->GetPropList()->HasProperty(name))
host->GetPropList()->SetPropertyByS(name, C4VNull);
if (dec.init)
{
assert(host->GetPropList()->IsStatic());
try
{
C4Value v = ConstexprEvaluator::eval_static(host, host->GetPropList()->IsStatic(), dec.name, dec.init.get(), ConstexprEvaluator::IgnoreUnset | quiet_flag);
host->GetPropList()->SetPropertyByS(name, v);
}
catch (C4AulParseError &e)
{
if (!quiet)
host->Engine->ErrorHandler->OnError(e.what());
}
}
break;
case ::aul::ast::VarDecl::Scope::Global:
if ((dec.init != nullptr) != n->constant)
{
if (!quiet)
host->Engine->ErrorHandler->OnError(Error(host, host, n->loc, nullptr, "global variable must be either constant or uninitialized: %s", cname).what());
}
else if (dec.init)
{
try
{
assert(n->constant && "CodegenAstVisitor: initialized global variable isn't const");
C4Value *v = host->Engine->GlobalConsts.GetItem(cname);
assert(v && "CodegenAstVisitor: global constant not found in variable table");
if (!v)
throw Error(host, host, n->loc, nullptr, "internal error: global constant not found in variable table: %s", cname);
*v = ConstexprEvaluator::eval_static(host, nullptr, dec.name, dec.init.get(), ConstexprEvaluator::IgnoreUnset | quiet_flag);
}
catch (C4AulParseError &e)
{
if (!quiet)
host->Engine->ErrorHandler->OnError(e.what());
}
}
break;
}
}
}
Reference in New Issue View Git Blame Copy Permalink