Access global objects

SingularityT3 · SingularityT3 · commit c45fabfecf13 · 2023-02-23T17:22:15.000+05:30
diff --git a/src/nodes/functions/function.cpp b/src/nodes/functions/function.cpp
@@ -26,7 +26,7 @@ FunctionNode::FunctionNode(
 
 std::unique_ptr<NodeResult> FunctionNode::evaluate(PSC::Context &ctx) {
     if (ctx.getFunction(functionName) != nullptr)
-        throw PSC::RedeclarationError(token, ctx, functionName);
+        throw PSC::RedefinitionError(token, ctx, functionName);
 
     PSC::DataType returnDataType = ctx.getType(returnType);
     if (returnDataType == PSC::DataType::NONE)
diff --git a/src/nodes/functions/procedure.cpp b/src/nodes/functions/procedure.cpp
@@ -24,7 +24,7 @@ ProcedureNode::ProcedureNode(
 
 std::unique_ptr<NodeResult> ProcedureNode::evaluate(PSC::Context &ctx) {
     if (ctx.getProcedure(procedureName) != nullptr)
-        throw PSC::RedeclarationError(token, ctx, procedureName);
+        throw PSC::RedefinitionError(token, ctx, procedureName);
 
     size_t parametersSize = parameterNames.size();
     std::vector<PSC::Parameter> parameters;
diff --git a/src/nodes/variable/array.cpp b/src/nodes/variable/array.cpp
@@ -15,7 +15,7 @@ std::unique_ptr<NodeResult> ArrayDeclareNode::evaluate(PSC::Context &ctx) {
     if (bounds.size() % 2 != 0 || bounds.size() == 0) std::abort();
 
     for (auto identifier : identifiers) {
-        if (ctx.getArray(identifier->value) != nullptr)
+        if (ctx.getArray(identifier->value, false) != nullptr)
             throw PSC::RedeclarationError(token, ctx, identifier->value);
     }
 
diff --git a/src/nodes/variable/composite.cpp b/src/nodes/variable/composite.cpp
@@ -8,8 +8,8 @@ CompositeDefineNode::CompositeDefineNode(const Token &token, const Token &name,
     : Node(token), name(name), initBlock(initBlock) {}
 
 std::unique_ptr<NodeResult> CompositeDefineNode::evaluate(PSC::Context &ctx) {
-    if (ctx.isIdentifierType(name))
-        throw PSC::RuntimeError(token, ctx, "Redefinition of type '" + name.value + "'");
+    if (ctx.isIdentifierType(name, false))
+        throw PSC::RedefinitionError(token, ctx, name.value);
     
     PSC::CompositeTypeDefinition definition(name.value, initBlock);
     ctx.createCompositeDefinition(std::move(definition));
diff --git a/src/nodes/variable/enum.cpp b/src/nodes/variable/enum.cpp
@@ -8,8 +8,8 @@ EnumDefineNode::EnumDefineNode(const Token &token, const Token &name, std::vecto
     : Node(token), name(name), values(std::move(values)) {}
 
 std::unique_ptr<NodeResult> EnumDefineNode::evaluate(PSC::Context &ctx) {
-    if (ctx.isIdentifierType(name))
-        throw PSC::RuntimeError(token, ctx, "Redefinition of type '" + name.value + "'");
+    if (ctx.isIdentifierType(name, false))
+        throw PSC::RedefinitionError(token, ctx, name.value);
 
     PSC::EnumTypeDefinition definition(name.value, std::move(values));
     ctx.createEnumDefinition(std::move(definition));
diff --git a/src/nodes/variable/pointer.cpp b/src/nodes/variable/pointer.cpp
@@ -12,8 +12,8 @@ std::unique_ptr<NodeResult> PointerDefineNode::evaluate(PSC::Context &ctx) {
     if (pointerType == PSC::DataType::NONE)
         throw PSC::NotDefinedError(token, ctx, "Type '" + type.value + "'");
 
-    if (ctx.isIdentifierType(name))
-        throw PSC::RuntimeError(token, ctx, "Redefinition of type '" + name.value + "'");
+    if (ctx.isIdentifierType(name, false))
+        throw PSC::RedefinitionError(token, ctx, name.value);
 
     PSC::PointerTypeDefinition definition(name.value, pointerType);
     ctx.createPointerDefinition(std::move(definition));
diff --git a/src/nodes/variable/variable.cpp b/src/nodes/variable/variable.cpp
@@ -9,7 +9,7 @@ DeclareNode::DeclareNode(const Token &token, std::vector<const Token*> &&identif
 
 std::unique_ptr<NodeResult> DeclareNode::evaluate(PSC::Context &ctx) {
     for (auto identifier : identifiers) {
-        if (ctx.getVariable(identifier->value) != nullptr)
+        if (ctx.getVariable(identifier->value, false) != nullptr)
             throw PSC::RedeclarationError(token, ctx, identifier->value);
 
         if (ctx.isIdentifierType(*identifier))
@@ -33,7 +33,7 @@ ConstDeclareNode::ConstDeclareNode(const Token &token, Node &node, const Token &
 std::unique_ptr<NodeResult> ConstDeclareNode::evaluate(PSC::Context &ctx) {
     auto value = node.evaluate(ctx);
 
-    if (ctx.getVariable(identifier.value) != nullptr)
+    if (ctx.getVariable(identifier.value, false) != nullptr)
         throw PSC::RedeclarationError(token, ctx, identifier.value);
 
     ctx.addVariable(new PSC::Variable(identifier.value, value->type, true, &ctx, value->data.get()));
diff --git a/src/psc/error.cpp b/src/psc/error.cpp
@@ -95,6 +95,10 @@ RedeclarationError::RedeclarationError(const Token &token, const Context &contex
     : RuntimeError(token, context, "Redeclaration of '" + identifier + "'")
 {}
 
+RedefinitionError::RedefinitionError(const Token &token, const Context &context, const std::string &identifier)
+    : RuntimeError(token, context, "Redefinition of '" + identifier + "'")
+{}
+
 ConstAssignError::ConstAssignError(const Token &token, const Context &context, const std::string &constant)
     : RuntimeError(token, context, "Assignment to constant '" + constant + "'")
 {}
diff --git a/src/psc/error.h b/src/psc/error.h
@@ -79,6 +79,11 @@ namespace PSC {
         RedeclarationError(const Token &token, const Context &context, const std::string &identifier);
     };
 
+    class RedefinitionError : public RuntimeError {
+    public:
+        RedefinitionError(const Token &token, const Context &context, const std::string &identifier);
+    };
+
     class ConstAssignError : public RuntimeError {
     public:
         ConstAssignError(const Token &token, const Context &context, const std::string &constant);
diff --git a/src/psc/scope/context.cpp b/src/psc/scope/context.cpp
@@ -90,6 +90,12 @@ Context *Context::getParent() const {
     return parent;
 }
 
+Context *Context::getGlobalContext() {
+    Context *ctx = this;
+    while (ctx->parent != nullptr) {ctx = ctx->parent;}
+    return ctx;
+}
+
 const std::string &Context::getName() const {
     return name;
 }
@@ -98,12 +104,13 @@ void Context::addVariable(Variable *variable) {
     variables.emplace_back(variable);
 }
 
-Variable *Context::getVariable(const std::string &varName) {
+Variable *Context::getVariable(const std::string &varName, bool global) {
     for (auto &var : variables) {
         if (var->name == varName) return var.get();
     }
 
-    return nullptr;
+    if (!global || parent == nullptr) return nullptr;
+    return getGlobalContext()->getVariable(varName);
 }
 
 void Context::addProcedure(std::unique_ptr<Procedure> &&procedure) {
@@ -142,17 +149,18 @@ void Context::addArray(std::unique_ptr<Array> &&array) {
     arrays.emplace_back(std::move(array));
 }
 
-Array *Context::getArray(const std::string &arrayName) {
+Array *Context::getArray(const std::string &arrayName, bool global) {
     for (auto &array : arrays) {
         if (arrayName == array->name) {
             return array.get();
         }
     }
 
-    return nullptr;
+    if (!global || parent == nullptr) return nullptr;
+    return getGlobalContext()->getArray(arrayName);
 }
 
-PSC::DataType Context::getType(const Token &token) {
+PSC::DataType Context::getType(const Token &token, bool global) {
     if (token.type == TokenType::DATA_TYPE) {
         if (token.value == "INTEGER") return PSC::DataType(PSC::DataType::INTEGER);
         else if (token.value == "REAL") return PSC::DataType(PSC::DataType::REAL);
@@ -161,15 +169,15 @@ PSC::DataType Context::getType(const Token &token) {
         else if (token.value == "STRING") return PSC::DataType(PSC::DataType::STRING);
         else std::abort();
     } else if (token.type == TokenType::IDENTIFIER) {
-        auto *enumDefinition = getEnumDefinition(token.value);
+        auto *enumDefinition = getEnumDefinition(token.value, global);
         if (enumDefinition != nullptr)
             return PSC::DataType(PSC::DataType::ENUM, &enumDefinition->name);
         
-        auto *pointerDefinition = getPointerDefinition(token.value);
+        auto *pointerDefinition = getPointerDefinition(token.value, global);
         if (pointerDefinition != nullptr)
             return PSC::DataType(PSC::DataType::POINTER, &pointerDefinition->name);
         
-        auto *compositeDefinition = getCompositeDefinition(token.value);
+        auto *compositeDefinition = getCompositeDefinition(token.value, global);
         if (compositeDefinition != nullptr)
             return PSC::DataType(PSC::DataType::COMPOSITE, &compositeDefinition->name);
         
@@ -178,19 +186,19 @@ PSC::DataType Context::getType(const Token &token) {
     std::abort();
 }
 
-bool Context::isIdentifierType(const Token &identifier) {
-    PSC::DataType dataType = getType(identifier);
+bool Context::isIdentifierType(const Token &identifier, bool global) {
+    PSC::DataType dataType = getType(identifier, global);
     if (dataType != PSC::DataType::NONE)
         return true;
 
-    std::unique_ptr<PSC::Enum> enumEl(getEnumElement(identifier.value));
+    std::unique_ptr<PSC::Enum> enumEl(getEnumElement(identifier.value, global));
     if (enumEl.get() != nullptr)
         return true;
 
     return false;
 }
 
-Enum *Context::getEnumElement(const std::string &value) {
+Enum *Context::getEnumElement(const std::string &value, bool global) {
     for (auto &definition : enums) {
         for (size_t i = 0; i < definition->values.size(); i++) {
             if (definition->values[i] == value) {
@@ -200,7 +208,7 @@ Enum *Context::getEnumElement(const std::string &value) {
             }
         }
     }
-    if (parent != nullptr) return parent->getEnumElement(value);
+    if (global && parent != nullptr) return getGlobalContext()->getEnumElement(value);
     return nullptr;
 }
 
@@ -216,26 +224,26 @@ void Context::createCompositeDefinition(CompositeTypeDefinition &&definition) {
     composites.emplace_back(std::make_unique<CompositeTypeDefinition>(std::move(definition)));
 }
 
-const EnumTypeDefinition *Context::getEnumDefinition(const std::string &name) {
+const EnumTypeDefinition *Context::getEnumDefinition(const std::string &name, bool global) {
     for (const auto &e : enums) {
         if (e->name == name) return e.get();
     }
-    if (parent != nullptr) return parent->getEnumDefinition(name);
+    if (global && parent != nullptr) return getGlobalContext()->getEnumDefinition(name);
     return nullptr;
 }
 
-const PointerTypeDefinition *Context::getPointerDefinition(const std::string &name) {
+const PointerTypeDefinition *Context::getPointerDefinition(const std::string &name, bool global) {
     for (const auto &p : pointers) {
         if (p->name == name) return p.get();
     }
-    if (parent != nullptr) return parent->getPointerDefinition(name);
+    if (global && parent != nullptr) return getGlobalContext()->getPointerDefinition(name);
     return nullptr;
 }
 
-const CompositeTypeDefinition *Context::getCompositeDefinition(const std::string &name) {
+const CompositeTypeDefinition *Context::getCompositeDefinition(const std::string &name, bool global) {
     for (const auto &c : composites) {
         if (c->name == name) return c.get();
     }
-    if (parent != nullptr) return parent->getCompositeDefinition(name);
+    if (global && parent != nullptr) return getGlobalContext()->getCompositeDefinition(name);
     return nullptr;
 }
diff --git a/src/psc/scope/context.h b/src/psc/scope/context.h
@@ -46,11 +46,13 @@ namespace PSC {
 
         Context *getParent() const;
 
+        Context *getGlobalContext();
+
         const std::string &getName() const;
 
         void addVariable(Variable *variable);
 
-        Variable *getVariable(const std::string &varName);
+        Variable *getVariable(const std::string &varName, bool global = true);
 
         void addProcedure(std::unique_ptr<Procedure> &&procedure);
 
@@ -62,24 +64,24 @@ namespace PSC {
 
         void addArray(std::unique_ptr<Array> &&array);
 
-        Array *getArray(const std::string &arrayName);
+        Array *getArray(const std::string &arrayName, bool global = true);
 
-        PSC::DataType getType(const Token &token);
+        PSC::DataType getType(const Token &token, bool global = true);
 
-        bool isIdentifierType(const Token &identifier);
+        bool isIdentifierType(const Token &identifier, bool global = true);
 
-        Enum *getEnumElement(const std::string &value);
+        Enum *getEnumElement(const std::string &value, bool global = true);
 
         void createEnumDefinition(EnumTypeDefinition &&definition);
 
         void createPointerDefinition(PointerTypeDefinition &&definition);
 
         void createCompositeDefinition(CompositeTypeDefinition &&definition);
 
-        const EnumTypeDefinition *getEnumDefinition(const std::string &name);
+        const EnumTypeDefinition *getEnumDefinition(const std::string &name, bool global = true);
 
-        const PointerTypeDefinition *getPointerDefinition(const std::string &name);
+        const PointerTypeDefinition *getPointerDefinition(const std::string &name, bool global = true);
 
-        const CompositeTypeDefinition *getCompositeDefinition(const std::string &name);
+        const CompositeTypeDefinition *getCompositeDefinition(const std::string &name, bool global = true);
     };
 }

Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ std::unique_ptr<NodeResult> ArrayDeclareNode::evaluate(PSC::Context &ctx) {`
`15`	`15`	`if (bounds.size() % 2 != 0 \|\| bounds.size() == 0) std::abort();`
`16`	`16`
`17`	`17`	`for (auto identifier : identifiers) {`
`18`		`- if (ctx.getArray(identifier->value) != nullptr)`
	`18`	`+ if (ctx.getArray(identifier->value, false) != nullptr)`
`19`	`19`	`throw PSC::RedeclarationError(token, ctx, identifier->value);`
`20`	`20`	`}`
`21`	`21`
Original file line number	Diff line number	Diff line change
`@@ -90,6 +90,12 @@ Context *Context::getParent() const {`
`90`	`90`	`return parent;`
`91`	`91`	`}`
`92`	`92`
	`93`	`+Context *Context::getGlobalContext() {`
	`94`	`+ Context *ctx = this;`
	`95`	`+ while (ctx->parent != nullptr) {ctx = ctx->parent;}`
	`96`	`+ return ctx;`
	`97`	`+}`
	`98`	`+`
`93`	`99`	`const std::string &Context::getName() const {`
`94`	`100`	`return name;`
`95`	`101`	`}`
`@@ -98,12 +104,13 @@ void Context::addVariable(Variable *variable) {`
`98`	`104`	`variables.emplace_back(variable);`
`99`	`105`	`}`
`100`	`106`
`101`		`-Variable *Context::getVariable(const std::string &varName) {`
	`107`	`+Variable *Context::getVariable(const std::string &varName, bool global) {`
`102`	`108`	`for (auto &var : variables) {`
`103`	`109`	`if (var->name == varName) return var.get();`
`104`	`110`	`}`
`105`	`111`
`106`		`- return nullptr;`
	`112`	`+ if (!global \|\| parent == nullptr) return nullptr;`
	`113`	`+ return getGlobalContext()->getVariable(varName);`
`107`	`114`	`}`
`108`	`115`
`109`	`116`	`void Context::addProcedure(std::unique_ptr<Procedure> &&procedure) {`
`@@ -142,17 +149,18 @@ void Context::addArray(std::unique_ptr<Array> &&array) {`
`142`	`149`	`arrays.emplace_back(std::move(array));`
`143`	`150`	`}`
`144`	`151`
`145`		`-Array *Context::getArray(const std::string &arrayName) {`
	`152`	`+Array *Context::getArray(const std::string &arrayName, bool global) {`
`146`	`153`	`for (auto &array : arrays) {`
`147`	`154`	`if (arrayName == array->name) {`
`148`	`155`	`return array.get();`
`149`	`156`	`}`
`150`	`157`	`}`
`151`	`158`
`152`		`- return nullptr;`
	`159`	`+ if (!global \|\| parent == nullptr) return nullptr;`
	`160`	`+ return getGlobalContext()->getArray(arrayName);`
`153`	`161`	`}`
`154`	`162`
`155`		`-PSC::DataType Context::getType(const Token &token) {`
	`163`	`+PSC::DataType Context::getType(const Token &token, bool global) {`
`156`	`164`	`if (token.type == TokenType::DATA_TYPE) {`
`157`	`165`	`if (token.value == "INTEGER") return PSC::DataType(PSC::DataType::INTEGER);`
`158`	`166`	`else if (token.value == "REAL") return PSC::DataType(PSC::DataType::REAL);`
`@@ -161,15 +169,15 @@ PSC::DataType Context::getType(const Token &token) {`
`161`	`169`	`else if (token.value == "STRING") return PSC::DataType(PSC::DataType::STRING);`
`162`	`170`	`else std::abort();`
`163`	`171`	`} else if (token.type == TokenType::IDENTIFIER) {`
`164`		`- auto *enumDefinition = getEnumDefinition(token.value);`
	`172`	`+ auto *enumDefinition = getEnumDefinition(token.value, global);`
`165`	`173`	`if (enumDefinition != nullptr)`
`166`	`174`	`return PSC::DataType(PSC::DataType::ENUM, &enumDefinition->name);`
`167`	`175`
`168`		`- auto *pointerDefinition = getPointerDefinition(token.value);`
	`176`	`+ auto *pointerDefinition = getPointerDefinition(token.value, global);`
`169`	`177`	`if (pointerDefinition != nullptr)`
`170`	`178`	`return PSC::DataType(PSC::DataType::POINTER, &pointerDefinition->name);`
`171`	`179`
`172`		`- auto *compositeDefinition = getCompositeDefinition(token.value);`
	`180`	`+ auto *compositeDefinition = getCompositeDefinition(token.value, global);`
`173`	`181`	`if (compositeDefinition != nullptr)`
`174`	`182`	`return PSC::DataType(PSC::DataType::COMPOSITE, &compositeDefinition->name);`
`175`	`183`
`@@ -178,19 +186,19 @@ PSC::DataType Context::getType(const Token &token) {`
`178`	`186`	`std::abort();`
`179`	`187`	`}`
`180`	`188`
`181`		`-bool Context::isIdentifierType(const Token &identifier) {`
`182`		`- PSC::DataType dataType = getType(identifier);`
	`189`	`+bool Context::isIdentifierType(const Token &identifier, bool global) {`
	`190`	`+ PSC::DataType dataType = getType(identifier, global);`
`183`	`191`	`if (dataType != PSC::DataType::NONE)`
`184`	`192`	`return true;`
`185`	`193`
`186`		`- std::unique_ptr<PSC::Enum> enumEl(getEnumElement(identifier.value));`
	`194`	`+ std::unique_ptr<PSC::Enum> enumEl(getEnumElement(identifier.value, global));`
`187`	`195`	`if (enumEl.get() != nullptr)`
`188`	`196`	`return true;`
`189`	`197`
`190`	`198`	`return false;`
`191`	`199`	`}`
`192`	`200`
`193`		`-Enum *Context::getEnumElement(const std::string &value) {`
	`201`	`+Enum *Context::getEnumElement(const std::string &value, bool global) {`
`194`	`202`	`for (auto &definition : enums) {`
`195`	`203`	`for (size_t i = 0; i < definition->values.size(); i++) {`
`196`	`204`	`if (definition->values[i] == value) {`
`@@ -200,7 +208,7 @@ Enum *Context::getEnumElement(const std::string &value) {`
`200`	`208`	`}`
`201`	`209`	`}`
`202`	`210`	`}`
`203`		`- if (parent != nullptr) return parent->getEnumElement(value);`
	`211`	`+ if (global && parent != nullptr) return getGlobalContext()->getEnumElement(value);`
`204`	`212`	`return nullptr;`
`205`	`213`	`}`
`206`	`214`
`@@ -216,26 +224,26 @@ void Context::createCompositeDefinition(CompositeTypeDefinition &&definition) {`
`216`	`224`	`composites.emplace_back(std::make_unique<CompositeTypeDefinition>(std::move(definition)));`
`217`	`225`	`}`
`218`	`226`
`219`		`-const EnumTypeDefinition *Context::getEnumDefinition(const std::string &name) {`
	`227`	`+const EnumTypeDefinition *Context::getEnumDefinition(const std::string &name, bool global) {`
`220`	`228`	`for (const auto &e : enums) {`
`221`	`229`	`if (e->name == name) return e.get();`
`222`	`230`	`}`
`223`		`- if (parent != nullptr) return parent->getEnumDefinition(name);`
	`231`	`+ if (global && parent != nullptr) return getGlobalContext()->getEnumDefinition(name);`
`224`	`232`	`return nullptr;`
`225`	`233`	`}`
`226`	`234`
`227`		`-const PointerTypeDefinition *Context::getPointerDefinition(const std::string &name) {`
	`235`	`+const PointerTypeDefinition *Context::getPointerDefinition(const std::string &name, bool global) {`
`228`	`236`	`for (const auto &p : pointers) {`
`229`	`237`	`if (p->name == name) return p.get();`
`230`	`238`	`}`
`231`		`- if (parent != nullptr) return parent->getPointerDefinition(name);`
	`239`	`+ if (global && parent != nullptr) return getGlobalContext()->getPointerDefinition(name);`
`232`	`240`	`return nullptr;`
`233`	`241`	`}`
`234`	`242`
`235`		`-const CompositeTypeDefinition *Context::getCompositeDefinition(const std::string &name) {`
	`243`	`+const CompositeTypeDefinition *Context::getCompositeDefinition(const std::string &name, bool global) {`
`236`	`244`	`for (const auto &c : composites) {`
`237`	`245`	`if (c->name == name) return c.get();`
`238`	`246`	`}`
`239`		`- if (parent != nullptr) return parent->getCompositeDefinition(name);`
	`247`	`+ if (global && parent != nullptr) return getGlobalContext()->getCompositeDefinition(name);`
`240`	`248`	`return nullptr;`
`241`	`249`	`}`