diff --git a/elenasrc3/elc/clicommon.h b/elenasrc3/elc/clicommon.h index ccfcf78d0..b4ee65344 100644 --- a/elenasrc3/elc/clicommon.h +++ b/elenasrc3/elc/clicommon.h @@ -341,9 +341,6 @@ class ModuleScopeBase : public SectionScopeBase virtual ref_t loadSymbolInfo(SymbolInfo& info, ref_t reference) = 0; virtual ref_t loadSymbolInfo(SymbolInfo& info, ustr_t referenceName) = 0; - virtual void importClassInfo(ClassInfo& copy, ClassInfo& target, ModuleBase* exporter, bool headerOnly, bool inheritMode/*, - bool ignoreFields*/) = 0; - virtual void newNamespace(ustr_t name) = 0; virtual bool includeNamespace(IdentifierList& importedNs, ustr_t name, bool& duplicateInclusion) = 0; diff --git a/elenasrc3/elc/cliconst.h b/elenasrc3/elc/cliconst.h index 056b779c7..dc76c8a6a 100644 --- a/elenasrc3/elc/cliconst.h +++ b/elenasrc3/elc/cliconst.h @@ -13,7 +13,7 @@ namespace elena_lang { - #define ELC_REVISION_NUMBER 0x0246 + #define ELC_REVISION_NUMBER 0x0247 #if defined _M_IX86 || _M_X64 diff --git a/elenasrc3/elc/compiler.cpp b/elenasrc3/elc/compiler.cpp index d800bf57f..dccf42dcb 100644 --- a/elenasrc3/elc/compiler.cpp +++ b/elenasrc3/elc/compiler.cpp @@ -41,7 +41,7 @@ MethodHint operator | (const ref_t& l, const MethodHint& r) { return (MethodHint)(l | (unsigned int)r); } -// + //inline void testNodes(SyntaxNode node) //{ // SyntaxNode current = node.firstChild(); @@ -52,6 +52,13 @@ MethodHint operator | (const ref_t& l, const MethodHint& r) // } //} +//inline void storeNode(SyntaxNode node) +//{ +// DynamicUStr target; +// +// SyntaxTreeSerializer::save(node, target); +//} + inline bool isSelfCall(ObjectInfo target) { switch (target.kind) { @@ -367,9 +374,9 @@ void Interpreter :: copyConstCollection(ref_t sourRef, ref_t destRef, bool byVal ref_t currentRef = it.key() & ~mskAnyRef; if (currentMask == mskMssgNameLiteralRef) { - target->addReference(_scope->importAction(sourceInfo.module, currentRef) | currentMask, *it); + target->addReference(ImportHelper::importAction(sourceInfo.module, currentRef, _scope->module) | currentMask, *it); } - else target->addReference(_scope->importReference(sourceInfo.module, currentRef) | currentMask, *it); + else target->addReference(ImportHelper::importReference(sourceInfo.module, currentRef, _scope->module) | currentMask, *it); } } @@ -1669,6 +1676,7 @@ Compiler :: Compiler( _withConditionalBoxing = false; _evaluateOp = false; _verbose = false; + _noValidation = false; _trackingUnassigned = false; @@ -2079,7 +2087,7 @@ Compiler::InheritResult Compiler :: inheritClass(ClassScope& scope, ref_t parent ClassInfo copy; copy.load(&reader); - scope.moduleScope->importClassInfo(copy, scope.info, parentInfo.module, false, true); + CompilerLogic ::importClassInfo(copy, scope.info, parentInfo.module, scope.module, false, true); } else { scope.info.load(&reader, false); @@ -3619,128 +3627,6 @@ void Compiler :: declareFieldMetaInfos(ClassScope& scope, SyntaxNode node) } } -void Compiler :: declareMembers(NamespaceScope& ns, SyntaxNode node) -{ - SyntaxNode current = node.firstChild(); - while (current != SyntaxKey::None) { - switch (current.key) { - case SyntaxKey::Namespace: - { - NamespaceScope namespaceScope(&ns); - declareNamespace(namespaceScope, current, false, true); - - declareMembers(namespaceScope, current); - break; - } - case SyntaxKey::Symbol: - { - SymbolScope symbolScope(&ns, current.arg.reference, ns.defaultVisibility); - - declareSymbol(symbolScope, current); - break; - } - case SyntaxKey::Class: - { - Class classHelper(this, &ns, current.arg.reference, ns.defaultVisibility); - - classHelper.declare(current); - break; - } - case SyntaxKey::MetaExpression: - { - MetaScope scope(&ns, Scope::ScopeLevel::Namespace); - - evalStatement(scope, current); - break; - } - case SyntaxKey::Template: - case SyntaxKey::ExtensionTemplate: - { - TemplateScope templateScope(&ns, 0, ns.defaultVisibility); - declareTemplateClass(templateScope, current); - break; - } - case SyntaxKey::TemplateCode: - { - TemplateScope templateScope(&ns, 0, ns.defaultVisibility); - declareTemplateCode(templateScope, current); - break; - } - default: - // to make compiler happy - break; - } - - current = current.nextNode(); - } - - if (ns.declaredExtensions.count() > 0) { - declareModuleExtensionDispatcher(ns, node); - - ns.declaredExtensions.clear(); - } -} - - -void Compiler :: declareMemberIdentifiers(NamespaceScope& ns, SyntaxNode node) -{ - SyntaxNode current = node.firstChild(); - while (current != SyntaxKey::None) { - switch (current.key) { - case SyntaxKey::Namespace: - { - NamespaceScope namespaceScope(&ns); - declareNamespace(namespaceScope, current, true, true); - ns.moduleScope->newNamespace(*namespaceScope.nsName); - - declareMemberIdentifiers(namespaceScope, current); - break; - } - case SyntaxKey::Symbol: - { - SymbolScope symbolScope(&ns, 0, ns.defaultVisibility); - declareSymbolAttributes(symbolScope, current, true); - - SyntaxNode name = current.findChild(SyntaxKey::Name); - - ref_t reference = mapNewTerminal(symbolScope, nullptr, name, nullptr, symbolScope.visibility); - symbolScope.module->mapSection(reference | mskSymbolRef, false); - - current.setArgumentReference(reference); - break; - } - case SyntaxKey::Class: - { - ClassScope classScope(&ns, 0, ns.defaultVisibility); - - ref_t flags = classScope.info.header.flags; - declareClassAttributes(classScope, current, flags); - - SyntaxNode name = current.findChild(SyntaxKey::Name); - if (current.arg.reference == INVALID_REF) { - // if it is a template based class - its name was already resolved - classScope.reference = current.findChild(SyntaxKey::Name).arg.reference; - } - else classScope.reference = mapNewTerminal(classScope, nullptr, - name, nullptr, classScope.visibility); - - classScope.module->mapSection(classScope.reference | mskSymbolRef, false); - - current.setArgumentReference(classScope.reference); - break; - } - case SyntaxKey::MetaDictionary: - declareDictionary(ns, current, Visibility::Public, Scope::ScopeLevel::Namespace); - break; - default: - // to make compiler happy - break; - } - - current = current.nextNode(); - } -} - void Compiler :: importExtensions(NamespaceScope& ns, ustr_t importedNs) { ReferenceName sectionName(importedNs, EXTENSION_SECTION); @@ -3774,58 +3660,6 @@ void Compiler :: copyParentNamespaceExtensions(NamespaceScope& source, Namespace } } -void Compiler :: declareNamespace(NamespaceScope& ns, SyntaxNode node, bool ignoreImport, bool ignoreExtensions) -{ - // load the namespace name if available - SyntaxNode nameNode = node.findChild(SyntaxKey::Name); - if (nameNode == SyntaxKey::Name) { - if (ns.nsName.length() > 0) - ns.nsName.append('\''); - - ns.nsName.append(nameNode.firstChild(SyntaxKey::TerminalMask).identifier()); - } - - if (!ignoreExtensions) { - // HOTFIX : load the module internal and public extensions - loadExtensions(ns, false); - loadExtensions(ns, true); - } - - SyntaxNode current = node.firstChild(); - while (current != SyntaxKey::None) { - switch (current.key) { - case SyntaxKey::SourcePath: - ns.sourcePath.copy(current.identifier()); - break; - case SyntaxKey::Import: - if (!ignoreImport) { - bool duplicateInclusion = false; - ustr_t name = current.findChild(SyntaxKey::Name).firstChild(SyntaxKey::TerminalMask).identifier(); - if (ns.moduleScope->includeNamespace(ns.importedNs, name, duplicateInclusion)) { - if (!ignoreExtensions) - importExtensions(ns, name); - } - else if (duplicateInclusion) { - ns.raiseWarning(WARNING_LEVEL_1, wrnDuplicateInclude, current); - - // HOTFIX : comment out, to prevent duplicate warnings - current.setKey(SyntaxKey::Idle); - } - else { - ns.raiseWarning(WARNING_LEVEL_1, wrnUnknownModule, current.findChild(SyntaxKey::Name)); - current.setKey(SyntaxKey::Idle); // remove the node, to prevent duplicate warnings - } - } - break; - default: - // to make compiler happy - break; - } - - current = current.nextNode(); - } -} - ObjectInfo Compiler :: evalOperation(Interpreter& interpreter, Scope& scope, SyntaxNode node, ref_t operator_id, bool ignoreErrors) { ObjectInfo loperand = {}; @@ -9106,11 +8940,11 @@ void Compiler :: compileNamespace(BuildTreeWriter& writer, NamespaceScope& ns, S break; case SyntaxKey::Namespace: { - NamespaceScope namespaceScope(&ns); - declareNamespace(namespaceScope, current, false, false); - copyParentNamespaceExtensions(ns, namespaceScope); + Namespace subNs(this, &ns); + subNs.declareNamespace(current, false, false); + copyParentNamespaceExtensions(ns, subNs.scope); - compileNamespace(writer, namespaceScope, current); + compileNamespace(writer, subNs.scope, current); break; } case SyntaxKey::Symbol: @@ -9157,7 +8991,8 @@ inline ref_t safeMapReference(ModuleScopeBase* moduleScope, ForwardResolverBase* if (moduleScope->isStandardOne()) { return moduleScope->module->mapReference(resolved + getlength(STANDARD_MODULE)); } - else return moduleScope->importReference(moduleScope->module, resolved); + else return moduleScope->module->mapReference(resolved); + //else return ImportHelper::importReference(moduleScope->module, resolved); } else return 0; } @@ -9390,7 +9225,7 @@ void Compiler :: validateScope(ModuleScopeBase* moduleScope) void Compiler :: validateSuperClass(ClassScope& scope, SyntaxNode node) { - if (!scope.info.methods.exist(scope.moduleScope->buildins.dispatch_message)) + if (!_noValidation && !scope.info.methods.exist(scope.moduleScope->buildins.dispatch_message)) scope.raiseError(errNoDispatcher, node); } @@ -9399,14 +9234,8 @@ void Compiler :: declareModuleIdentifiers(ModuleScopeBase* moduleScope, SyntaxNo SyntaxNode current = node.firstChild(); while (current != SyntaxKey::None) { if (current == SyntaxKey::Namespace) { - NamespaceScope ns(moduleScope, _errorProcessor, _logic, outerExtensionList); - - // declare namespace - declareNamespace(ns, current, true, true); - ns.moduleScope->newNamespace(*ns.nsName); - - // declare all module members - map symbol identifiers - declareMemberIdentifiers(ns, current); + Namespace ns(this, moduleScope, _errorProcessor, _logic, outerExtensionList); + ns.declare(current, false); } current = current.nextNode(); @@ -9418,13 +9247,13 @@ void Compiler :: declareModule(ModuleScopeBase* moduleScope, SyntaxNode node, Ex SyntaxNode current = node.firstChild(); while (current != SyntaxKey::None) { if (current == SyntaxKey::Namespace) { - NamespaceScope ns(moduleScope, _errorProcessor, _logic, outerExtensionList); + Namespace ns(this, moduleScope, _errorProcessor, _logic, outerExtensionList); // declare namespace - declareNamespace(ns, current, false, true); + ns.declareNamespace(current, false, true); // declare all module members - map symbol identifiers - declareMembers(ns, current); + ns.declareMembers(current); } current = current.nextNode(); @@ -9453,10 +9282,10 @@ void Compiler :: compile(ModuleScopeBase* moduleScope, SyntaxTree& input, BuildT SyntaxNode current = node.firstChild(); while (current != SyntaxKey::None) { if (current == SyntaxKey::Namespace) { - NamespaceScope ns(moduleScope, _errorProcessor, _logic, outerExtensionList); - declareNamespace(ns, current); + Namespace ns(this, moduleScope, _errorProcessor, _logic, outerExtensionList); + ns.declareNamespace(current); - compileNamespace(writer, ns, current); + compileNamespace(writer, ns.scope, current); _presenter->showProgress(); } @@ -9981,6 +9810,218 @@ void Compiler :: declareModuleExtensionDispatcher(NamespaceScope& scope, SyntaxN } } +// --- Compiler::Namespace --- +Compiler::Namespace :: Namespace(Compiler* compiler, ModuleScopeBase* moduleScope, ErrorProcessor* errorProcessor, CompilerLogic* compilerLogic, + ExtensionMap* outerExtensionList) + : compiler(compiler), scope(moduleScope, errorProcessor, compilerLogic, outerExtensionList) +{ + +} + +Compiler::Namespace::Namespace(Compiler* compiler, NamespaceScope* parent) + : compiler(compiler), scope(parent) +{ + +} + +void Compiler::Namespace :: declare(SyntaxNode node, bool withMembers) +{ + // declare namespace + declareNamespace(node, true, true); + scope.moduleScope->newNamespace(*scope.nsName); + + // declare all module members - map symbol identifiers + declareMemberIdentifiers(node); + + if (withMembers) + declareMembers(node); +} + +void Compiler::Namespace :: declareNamespace(SyntaxNode node, bool ignoreImport, bool ignoreExtensions) +{ + // load the namespace name if available + SyntaxNode nameNode = node.findChild(SyntaxKey::Name); + if (nameNode == SyntaxKey::Name) { + if (scope.nsName.length() > 0) + scope.nsName.append('\''); + + scope.nsName.append(nameNode.firstChild(SyntaxKey::TerminalMask).identifier()); + } + + if (!ignoreExtensions) { + // HOTFIX : load the module internal and public extensions + compiler->loadExtensions(scope, false); + compiler->loadExtensions(scope, true); + } + + SyntaxNode current = node.firstChild(); + while (current != SyntaxKey::None) { + switch (current.key) { + case SyntaxKey::SourcePath: + scope.sourcePath.copy(current.identifier()); + break; + case SyntaxKey::Import: + if (!ignoreImport) { + bool duplicateInclusion = false; + ustr_t name = current.findChild(SyntaxKey::Name).firstChild(SyntaxKey::TerminalMask).identifier(); + if (scope.moduleScope->includeNamespace(scope.importedNs, name, duplicateInclusion)) { + if (!ignoreExtensions) + compiler->importExtensions(scope, name); + } + else if (duplicateInclusion) { + scope.raiseWarning(WARNING_LEVEL_1, wrnDuplicateInclude, current); + + // HOTFIX : comment out, to prevent duplicate warnings + current.setKey(SyntaxKey::Idle); + } + else { + scope.raiseWarning(WARNING_LEVEL_1, wrnUnknownModule, current.findChild(SyntaxKey::Name)); + current.setKey(SyntaxKey::Idle); // remove the node, to prevent duplicate warnings + } + } + break; + default: + // to make compiler happy + break; + } + + current = current.nextNode(); + } +} + + +void Compiler::Namespace:: declareMemberIdentifiers(SyntaxNode node) +{ + SyntaxNode current = node.firstChild(); + while (current != SyntaxKey::None) { + switch (current.key) { + case SyntaxKey::Namespace: + { + Namespace subNamespace(compiler, &scope); + subNamespace.declare(current, false); + break; + } + case SyntaxKey::Symbol: + { + SymbolScope symbolScope(&scope, 0, scope.defaultVisibility); + compiler->declareSymbolAttributes(symbolScope, current, true); + + SyntaxNode name = current.findChild(SyntaxKey::Name); + + ref_t reference = compiler->mapNewTerminal(symbolScope, nullptr, name, nullptr, symbolScope.visibility); + symbolScope.module->mapSection(reference | mskSymbolRef, false); + + current.setArgumentReference(reference); + break; + } + case SyntaxKey::Class: + { + ClassScope classScope(&scope, 0, scope.defaultVisibility); + + ref_t flags = classScope.info.header.flags; + compiler->declareClassAttributes(classScope, current, flags); + + SyntaxNode name = current.findChild(SyntaxKey::Name); + if (current.arg.reference == INVALID_REF) { + // if it is a template based class - its name was already resolved + classScope.reference = current.findChild(SyntaxKey::Name).arg.reference; + } + else classScope.reference = compiler->mapNewTerminal(classScope, nullptr, + name, nullptr, classScope.visibility); + + classScope.module->mapSection(classScope.reference | mskSymbolRef, false); + + current.setArgumentReference(classScope.reference); + break; + } + case SyntaxKey::MetaDictionary: + compiler->declareDictionary(scope, current, Visibility::Public, Scope::ScopeLevel::Namespace); + break; + default: + // to make compiler happy + break; + } + + current = current.nextNode(); + } +} + + +void Compiler::Namespace :: declareMembers(SyntaxNode node) +{ + SyntaxNode current = node.firstChild(); + while (current != SyntaxKey::None) { + switch (current.key) { + case SyntaxKey::Namespace: + { + Namespace subNamespace(compiler, &scope); + subNamespace.declareNamespace(current, false, true); + + subNamespace.declareMembers(current); + break; + } + case SyntaxKey::Symbol: + { + SymbolScope symbolScope(&scope, current.arg.reference, scope.defaultVisibility); + + compiler->declareSymbol(symbolScope, current); + break; + } + case SyntaxKey::Class: + { + Class classHelper(compiler, &scope, current.arg.reference, scope.defaultVisibility); + + classHelper.declare(current); + break; + } + case SyntaxKey::MetaExpression: + { + MetaScope metaScope(&scope, Scope::ScopeLevel::Namespace); + + compiler->evalStatement(metaScope, current); + break; + } + case SyntaxKey::Template: + case SyntaxKey::ExtensionTemplate: + { + TemplateScope templateScope(&scope, 0, scope.defaultVisibility); + compiler->declareTemplateClass(templateScope, current); + break; + } + case SyntaxKey::TemplateCode: + { + TemplateScope templateScope(&scope, 0, scope.defaultVisibility); + compiler->declareTemplateCode(templateScope, current); + break; + } + default: + // to make compiler happy + break; + } + + current = current.nextNode(); + } + + if (scope.declaredExtensions.count() > 0) { + compiler->declareModuleExtensionDispatcher(scope, node); + + scope.declaredExtensions.clear(); + } +} + +// --- Compiler::Symbol --- +Compiler::Symbol :: Symbol(Namespace& ns, ref_t reference, Visibility visibility) + : Symbol(ns.compiler, &ns.scope, reference, visibility) +{ + +} + +Compiler::Symbol::Symbol(Compiler* compiler, NamespaceScope* parent, ref_t reference, Visibility visibility) + : compiler(compiler), scope(parent, reference, visibility) +{ + +} + // --- Compiler::Class --- Compiler::Class :: Class(Compiler* compiler, Scope* parent, ref_t reference, Visibility visibility) : compiler(compiler), scope(parent, reference, visibility) @@ -10068,36 +10109,36 @@ void Compiler::Class :: resolveClassPostfixes(SyntaxNode node, bool extensionMod SyntaxNode current = node.firstChild(); while (current != SyntaxKey::None) { switch (current.key) { - case SyntaxKey::InlineTemplate: - if (!compiler->importInlineTemplate(scope, current, INLINE_PREFIX, node)) - scope.raiseError(errInvalidOperation, current); - break; - case SyntaxKey::Parent: - { - SyntaxNode child = current.firstChild(); - if (child == SyntaxKey::TemplateType) { - if (compiler->importTemplate(scope, child, node, true)) { - // try to import as weak template + case SyntaxKey::InlineTemplate: + if (!compiler->importInlineTemplate(scope, current, INLINE_PREFIX, node)) + scope.raiseError(errInvalidOperation, current); + break; + case SyntaxKey::Parent: + { + SyntaxNode child = current.firstChild(); + if (child == SyntaxKey::TemplateType) { + if (compiler->importTemplate(scope, child, node, true)) { + // try to import as weak template + } + else if (!parentRef) { + parentNode = current; + + parentRef = compiler->resolveStrongTypeAttribute(scope, child, extensionMode, false); + } + else if (!compiler->importTemplate(scope, child, node, false)) + scope.raiseError(errUnknownTemplate, current); } else if (!parentRef) { parentNode = current; parentRef = compiler->resolveStrongTypeAttribute(scope, child, extensionMode, false); } - else if (!compiler->importTemplate(scope, child, node, false)) - scope.raiseError(errUnknownTemplate, current); - } - else if (!parentRef) { - parentNode = current; + else scope.raiseError(errInvalidSyntax, current); - parentRef = compiler->resolveStrongTypeAttribute(scope, child, extensionMode, false); + break; } - else scope.raiseError(errInvalidSyntax, current); - - break; - } - default: - break; + default: + break; } //else if (!parentRef) { // parentNode = baseNode; @@ -10171,6 +10212,12 @@ Compiler::Expression::Expression(Compiler* compiler, SourceScope& symbolScope, B } +Compiler::Expression::Expression(Symbol& symbol, BuildTreeWriter& writer) + : compiler(symbol.compiler), scope(&symbol.scope), writer(&writer) +{ + +} + ObjectInfo Compiler::Expression :: compileSymbolRoot(SyntaxNode bodyNode, EAttr mode) { writer->appendNode(BuildKey::OpenStatement); diff --git a/elenasrc3/elc/compiler.h b/elenasrc3/elc/compiler.h index 627ce21b0..fcc3a195f 100644 --- a/elenasrc3/elc/compiler.h +++ b/elenasrc3/elc/compiler.h @@ -1043,6 +1043,39 @@ namespace elena_lang } }; + class Namespace + { + friend class Compiler; + + Compiler* compiler; + + void declareNamespace(SyntaxNode node, bool ignoreImport = false, bool ignoreExtensions = false); + void declareMemberIdentifiers(SyntaxNode node); + void declareMembers(SyntaxNode node); + + public: + NamespaceScope scope; + + void declare(SyntaxNode node, bool withMembers); + + Namespace(Compiler* compiler, ModuleScopeBase* moduleScope, ErrorProcessor* errorProcessor, CompilerLogic* compilerLogic, + ExtensionMap* outerExtensionList); + Namespace(Compiler* compiler, NamespaceScope* parent); + }; + + class Symbol + { + friend class Compiler; + + Compiler* compiler; + + public: + SymbolScope scope; + + Symbol(Namespace& ns, ref_t reference, Visibility visibility); + Symbol(Compiler* compiler, NamespaceScope* parent, ref_t reference, Visibility visibility); + }; + class Class { friend class Compiler; @@ -1195,11 +1228,14 @@ namespace elena_lang ObjectInfo compileSubCode(SyntaxNode node, ExpressionAttribute mode, bool withoutNewScope = false); + Expression(Symbol& symbol, BuildTreeWriter& writer); Expression(Compiler* compiler, CodeScope& codeScope, BuildTreeWriter& writer); Expression(Compiler* compiler, SourceScope& symbolScope, BuildTreeWriter& writer); }; + friend class Namespace; friend class Class; + friend class Symbol; friend class Expression; private: @@ -1216,6 +1252,7 @@ namespace elena_lang bool _withConditionalBoxing; bool _evaluateOp; bool _verbose; + bool _noValidation; void loadMetaData(ModuleScopeBase* moduleScope, ForwardResolverBase* forwardResolver, ustr_t name); @@ -1375,11 +1412,6 @@ namespace elena_lang void declareSymbol(SymbolScope& scope, SyntaxNode node); - void declareNamespace(NamespaceScope& ns, SyntaxNode node, bool ignoreImport = false, - bool ignoreExtensions = false); - void declareMembers(NamespaceScope& ns, SyntaxNode node); - void declareMemberIdentifiers(NamespaceScope& ns, SyntaxNode node); - void copyParentNamespaceExtensions(NamespaceScope& source, NamespaceScope& target); void declareModuleIdentifiers(ModuleScopeBase* moduleScope, SyntaxNode node, ExtensionMap* outerExtensionList); @@ -1589,6 +1621,11 @@ namespace elena_lang _verbose = true; } + void setNoValidation() + { + _noValidation = true; + } + void prepare(ModuleScopeBase* moduleScope, ForwardResolverBase* forwardResolver, ManifestInfo& manifestInfo); void declare(ModuleScopeBase* moduleScope, SyntaxTree& input, ExtensionMap* outerExtensionList); diff --git a/elenasrc3/elc/compilerlogic.cpp b/elenasrc3/elc/compilerlogic.cpp index e123a9812..88fc0d676 100644 --- a/elenasrc3/elc/compilerlogic.cpp +++ b/elenasrc3/elc/compilerlogic.cpp @@ -1473,9 +1473,9 @@ bool CompilerLogic :: readTypeMap(ModuleBase* extModule, MemoryBase* section, Re if (NamespaceString::compareNs(name, scope->module->name())) { reference = scope->module->mapReference(name + getlength(STANDARD_MODULE)); } - else reference = scope->importReference(extModule, reference); + else reference = ImportHelper::importReference(extModule, reference, scope->module); } - else reference = scope->importReference(extModule, reference); + else reference = ImportHelper::importReference(extModule, reference, scope->module); } map.add(*key, reference); @@ -1594,15 +1594,15 @@ bool CompilerLogic :: readExtMessageEntry(ModuleBase* extModule, MemoryBase* sec while (!reader.eof()) { ref_t extRef = reader.getRef(); if (importMode && extRef) - extRef = scope->importReference(extModule, extRef); + extRef = ImportHelper::importReference(extModule, extRef, scope->module); mssg_t message = reader.getRef(); if (importMode) - message = scope->importMessage(extModule, message); + message = ImportHelper::importMessage(extModule, message, scope->module); mssg_t strongMessage = reader.getRef(); if (importMode && strongMessage) - strongMessage = scope->importMessage(extModule, strongMessage); + strongMessage = ImportHelper::importMessage(extModule, strongMessage, scope->module); if (!extRef) { // if it is an extension template @@ -1911,7 +1911,7 @@ bool CompilerLogic :: isSignatureCompatible(ModuleScopeBase& scope, ModuleBase* for (size_t i = 0; i < sourceLen; i++) { ref_t targetSign = i < len ? targetSignatures[i] : targetSignatures[len - 1]; - if (!isCompatible(scope, { scope.importReference(targetModule, targetSign) }, { sourceSignatures[i] }, true)) + if (!isCompatible(scope, { ImportHelper::importReference(targetModule, targetSign, scope.module) }, { sourceSignatures[i] }, true)) return false; } @@ -1999,7 +1999,7 @@ void CompilerLogic :: setSignatureStacksafe(ModuleScopeBase& scope, ModuleBase* for (size_t i = 0; i < len; i++) { flag <<= 1; - if (isStacksafeArg(scope, scope.importReference(targetModule, targetSignatures[i]))) + if (isStacksafeArg(scope, ImportHelper::importReference(targetModule, targetSignatures[i], scope.module))) stackSafeAttr |= flag; } } @@ -2096,7 +2096,7 @@ mssg_t CompilerLogic :: resolveMultimethod(ModuleScopeBase& scope, mssg_t weakMe { setSignatureStacksafe(scope, sectionInfo.module, argSign, stackSafeAttr); - foundMessage = scope.importMessage(sectionInfo.module, argMessage); + foundMessage = ImportHelper::importMessage(sectionInfo.module, argMessage, scope.module); } } @@ -2772,3 +2772,112 @@ ref_t CompilerLogic :: retrievePrimitiveType(ModuleScopeBase& scope, ref_t refer return 0; } + +ref_t CompilerLogic :: loadClassInfo(ClassInfo& info, ModuleInfo& moduleInfo, ModuleBase* target, bool headerOnly, bool fieldsOnly) +{ + if (moduleInfo.unassigned()) + return 0; + + // load argument VMT meta data + MemoryBase* metaData = moduleInfo.module->mapSection(moduleInfo.reference | mskMetaClassInfoRef, true); + if (!metaData) + return 0; + + MemoryReader reader(metaData); + if (moduleInfo.module != target) { + ClassInfo copy; + copy.load(&reader, headerOnly, fieldsOnly); + + importClassInfo(copy, info, moduleInfo.module, target, headerOnly, false/*, false*/); + + // import reference + ImportHelper::importReference(moduleInfo.module, moduleInfo.reference, target); + } + else info.load(&reader, headerOnly, fieldsOnly); + + return moduleInfo.reference; +} + +void CompilerLogic :: importClassInfo(ClassInfo& copy, ClassInfo& target, ModuleBase* exporter, + ModuleBase* importer, bool headerOnly, bool inheritMode) +{ + target.header = copy.header; + target.size = copy.size; + + if (!headerOnly) { + // import method references and mark them as inherited if required (inherit mode) + for (auto it = copy.methods.start(); !it.eof(); ++it) { + MethodInfo info = *it; + + if (info.outputRef) + info.outputRef = ImportHelper::importReference(exporter, info.outputRef, importer); + + if (info.multiMethod) + info.multiMethod = ImportHelper::importMessage(exporter, info.multiMethod, importer); + + if (info.byRefHandler) + info.byRefHandler = ImportHelper::importMessage(exporter, info.byRefHandler, importer); + + if (inheritMode) { + info.inherited = true; + + // private methods are not inherited + if (!test(it.key(), STATIC_MESSAGE)) + target.methods.add(ImportHelper::importMessage(exporter, it.key(), importer), info); + } + else target.methods.add(ImportHelper::importMessage(exporter, it.key(), importer), info); + } + + for (auto it = copy.fields.start(); !it.eof(); ++it) { + FieldInfo info = *it; + + if (info.typeInfo.typeRef && !isPrimitiveRef(info.typeInfo.typeRef)) + info.typeInfo.typeRef = ImportHelper::importReference(exporter, info.typeInfo.typeRef, importer); + + if (info.typeInfo.elementRef && !isPrimitiveRef(info.typeInfo.elementRef)) + info.typeInfo.elementRef = ImportHelper::importReference(exporter, info.typeInfo.elementRef, importer); + + target.fields.add(it.key(), info); + } + + for (auto it = copy.attributes.start(); !it.eof(); ++it) { + ClassAttributeKey key = it.key(); + if (test((unsigned)key.value2, (unsigned)ClassAttribute::ReferenceKeyMask)) { + key.value1 = ImportHelper::importReference(exporter, key.value1, importer); + } + else if (test((unsigned)key.value2, (unsigned)ClassAttribute::MessageKeyMask)) { + key.value1 = ImportHelper::importMessage(exporter, key.value1, importer); + } + ref_t referece = *it; + if (test((unsigned)key.value2, (unsigned)ClassAttribute::ReferenceMask)) { + referece = ImportHelper::importReference(exporter, referece, importer); + } + else if (test((unsigned)key.value2, (unsigned)ClassAttribute::MessageMask)) { + referece = ImportHelper::importMessage(exporter, referece, importer); + } + + target.attributes.add(key, referece); + } + + for (auto it = copy.statics.start(); !it.eof(); ++it) { + auto info = *it; + if (info.typeInfo.typeRef && !isPrimitiveRef(info.typeInfo.typeRef)) + info.typeInfo.typeRef = ImportHelper::importReference(exporter, info.typeInfo.typeRef, importer); + + if (info.typeInfo.elementRef) + info.typeInfo.elementRef = ImportHelper::importReference(exporter, info.typeInfo.elementRef, importer); + + info.valueRef = ImportHelper::importReferenceWithMask(exporter, info.valueRef, importer); + + target.statics.add(it.key(), info); + } + } + + // import class class reference + if (target.header.classRef != 0) + target.header.classRef = ImportHelper::importReference(exporter, target.header.classRef, importer); + + // import parent reference + if (target.header.parentRef) + target.header.parentRef = ImportHelper::importReference(exporter, target.header.parentRef, importer); +} diff --git a/elenasrc3/elc/compilerlogic.h b/elenasrc3/elc/compilerlogic.h index a4b5cf60d..d00fb7ac2 100644 --- a/elenasrc3/elc/compilerlogic.h +++ b/elenasrc3/elc/compilerlogic.h @@ -237,6 +237,35 @@ namespace elena_lang static bool loadMetaData(ModuleScopeBase* moduleScope, ustr_t name); static bool clearMetaData(ModuleScopeBase* moduleScope, ustr_t name); + static Visibility getVisibility(ustr_t name) + { + if (name.findStr(PRIVATE_PREFIX_NS) != NOTFOUND_POS) + return Visibility::Private; + + if (name.findStr(INTERNAL_PREFIX_NS) != NOTFOUND_POS) + return Visibility::Internal; + + return Visibility::Public; + } + + static ustr_t getVisibilityPrefix(Visibility visibility) + { + switch (visibility) { + case Visibility::Internal: + return INTERNAL_PREFIX_NS; + case Visibility::Private: + return PRIVATE_PREFIX_NS; + default: + return "'"; + } + } + + static ref_t loadClassInfo(ClassInfo& info, ModuleInfo& moduleInfo, + ModuleBase* target, bool headerOnly, bool fieldsOnly); + + static void importClassInfo(ClassInfo& copy, ClassInfo& target, ModuleBase* exporter, + ModuleBase* importer, bool headerOnly, bool inheritMode/*,bool ignoreFields*/); + static CompilerLogic* getInstance() { static CompilerLogic instance; diff --git a/elenasrc3/elc/modulescope.cpp b/elenasrc3/elc/modulescope.cpp index bc8947015..1ce40f581 100644 --- a/elenasrc3/elc/modulescope.cpp +++ b/elenasrc3/elc/modulescope.cpp @@ -3,42 +3,20 @@ // // This file contains Module scope class implementation. // -// (C)2021-2023, by Aleksey Rakov +// (C)2021-2024, by Aleksey Rakov //--------------------------------------------------------------------------- #include "modulescope.h" #include "bytecode.h" +#include "compilerlogic.h" using namespace elena_lang; // --- ModuleScope --- -inline ustr_t getVisibilityPrefix(Visibility visibility) -{ - switch (visibility) { - case Visibility::Internal: - return INTERNAL_PREFIX_NS; - case Visibility::Private: - return PRIVATE_PREFIX_NS; - default: - return "'"; - } -} - -inline Visibility getVisibility(ustr_t name) -{ - if (name.findStr(PRIVATE_PREFIX_NS) != NOTFOUND_POS) - return Visibility::Private; - - if (name.findStr(INTERNAL_PREFIX_NS) != NOTFOUND_POS) - return Visibility::Internal; - - return Visibility::Public; -} - inline ref_t mapNewIdentifier(ModuleBase* module, ustr_t identifier, Visibility visibility) { - ustr_t prefix = getVisibilityPrefix(visibility); + ustr_t prefix = CompilerLogic::getVisibilityPrefix(visibility); IdentifierString name(prefix, identifier); @@ -47,7 +25,7 @@ inline ref_t mapNewIdentifier(ModuleBase* module, ustr_t identifier, Visibility inline ref_t mapExistingIdentifier(ModuleBase* module, ustr_t identifier, Visibility visibility) { - ustr_t prefix = getVisibilityPrefix(visibility); + ustr_t prefix = CompilerLogic::getVisibilityPrefix(visibility); IdentifierString name(prefix, identifier); @@ -239,112 +217,6 @@ ustr_t ModuleScope :: resolveWeakTemplateReference(ustr_t referenceName) return resolvedName; } -ref_t ModuleScope :: importSignature(ModuleBase* referenceModule, ref_t signRef) -{ - if (!signRef) - return 0; - - ref_t dump[ARG_COUNT]; - size_t len = referenceModule->resolveSignature(signRef, dump); - for (size_t i = 0; i < len; i++) { - dump[i] = importReference(referenceModule, dump[i]); - } - - return module->mapSignature(dump, len, false); -} - -ref_t ModuleScope :: importMessage(ModuleBase* referenceModule, mssg_t exportRef) -{ - if (!exportRef) - return 0; - - pos_t paramCount = 0; - ref_t actionRef, flags; - decodeMessage(exportRef, actionRef, paramCount, flags); - - // signature and custom verb should be imported - ref_t signature = 0; - ustr_t actionName = referenceModule->resolveAction(actionRef, signature); - - actionRef = module->mapAction(actionName, importSignature(referenceModule, signature), false); - - return encodeMessage(actionRef, paramCount, flags); -} - -ref_t ModuleScope :: importReference(ModuleBase* referenceModule, ustr_t referenceName) -{ - auto info = loader->getModule(ReferenceInfo(referenceModule, referenceName), true); - if (info.reference) { - referenceName = info.module->resolveReference(info.reference); - if (isWeakReference(referenceName) && !isTemplateWeakReference(referenceName)) { - IdentifierString fullName(info.module->name(), referenceName); - - return module->mapReference(*fullName); - } - else return module->mapReference(referenceName); - } - else return 0; -} - -ref_t ModuleScope :: importExternal(ModuleBase* referenceModule, ref_t reference) -{ - ustr_t refName = referenceModule->resolveReference(reference); - - return module->mapReference(refName); -} - -ref_t ModuleScope :: importConstant(ModuleBase* referenceModule, ref_t reference) -{ - if (!reference) - return 0; - - ustr_t value = referenceModule->resolveConstant(reference); - - return module->mapConstant(value); -} - -ref_t ModuleScope :: importAction(ModuleBase* referenceModule, ref_t reference) -{ - if (!reference) - return 0; - - ref_t signRef = 0; - ustr_t value = referenceModule->resolveAction(reference, signRef); - - return module->mapAction(value, 0, signRef ? importSignature(referenceModule, signRef) : 0); -} - -ref_t ModuleScope :: importMessageConstant(ModuleBase* referenceModule, ref_t reference) -{ - if (!reference) - return 0; - - ustr_t value = referenceModule->resolveConstant(reference); - - ByteCodeUtil::resolveMessage(value, module, false); - - return module->mapConstant(value); -} - -ref_t ModuleScope :: importExtMessageConstant(ModuleBase* referenceModule, ref_t reference) -{ - if (!reference) - return 0; - - ustr_t value = referenceModule->resolveConstant(reference); - - size_t index = value.find('<'); - assert(index != NOTFOUND_POS); - size_t endIndex = value.findSub(index, '>'); - - IdentifierString messageName(value); - messageName.cut(index, endIndex - index + 1); - - ByteCodeUtil::resolveMessage(*messageName, module, false); - - return module->mapConstant(value); -} - SectionInfo ModuleScope :: getSection(ustr_t referenceName, ref_t mask, bool silentMode) { if (isForwardReference(referenceName)) { @@ -414,8 +286,8 @@ ref_t ModuleScope :: loadSymbolInfo(SymbolInfo& info, ustr_t referenceName) copy.load(&reader); info.symbolType = copy.symbolType; - info.typeRef = importReference(moduleInfo.module, copy.typeRef); - info.valueRef = importReference(moduleInfo.module, copy.valueRef); + info.typeRef = ImportHelper::importReference(moduleInfo.module, copy.typeRef, module); + info.valueRef = ImportHelper::importReference(moduleInfo.module, copy.valueRef, module); } else info.load(&reader); @@ -450,121 +322,8 @@ ref_t ModuleScope :: loadClassInfo(ClassInfo& info, ustr_t referenceName, bool h } else moduleInfo = getModule(referenceName, true); - if (moduleInfo.unassigned()) - return 0; - - // load argument VMT meta data - MemoryBase* metaData = moduleInfo.module->mapSection(moduleInfo.reference | mskMetaClassInfoRef, true); - if (!metaData) - return 0; - - MemoryReader reader(metaData); - if (moduleInfo.module != module) { - ClassInfo copy; - copy.load(&reader, headerOnly, fieldsOnly); - - importClassInfo(copy, info, moduleInfo.module, headerOnly, false/*, false*/); - - // import reference - importReference(moduleInfo.module, moduleInfo.reference); - } - else info.load(&reader, headerOnly, fieldsOnly); - - return moduleInfo.reference; - } -} - -ref_t ModuleScope :: importReferenceWithMask(ModuleBase* referenceModule, ref_t reference) -{ - ref_t mask = reference & mskAnyRef; - ref_t refId = reference & ~mskAnyRef; - if (refId) - refId = importReference(referenceModule, refId); - - return refId | mask; -} - -void ModuleScope :: importClassInfo(ClassInfo& copy, ClassInfo& target, ModuleBase* exporter, bool headerOnly, bool inheritMode) -{ - target.header = copy.header; - target.size = copy.size; - - if (!headerOnly) { - // import method references and mark them as inherited if required (inherit mode) - for (auto it = copy.methods.start(); !it.eof(); ++it) { - MethodInfo info = *it; - - if (info.outputRef) - info.outputRef = importReference(exporter, info.outputRef); - - if (info.multiMethod) - info.multiMethod = importMessage(exporter, info.multiMethod); - - if (info.byRefHandler) - info.byRefHandler = importMessage(exporter, info.byRefHandler); - - if (inheritMode) { - info.inherited = true; - - // private methods are not inherited - if (!test(it.key(), STATIC_MESSAGE)) - target.methods.add(importMessage(exporter, it.key()), info); - } - else target.methods.add(importMessage(exporter, it.key()), info); - } - - for (auto it = copy.fields.start(); !it.eof(); ++it) { - FieldInfo info = *it; - - if (info.typeInfo.typeRef && !isPrimitiveRef(info.typeInfo.typeRef)) - info.typeInfo.typeRef = importReference(exporter, info.typeInfo.typeRef); - - if (info.typeInfo.elementRef && !isPrimitiveRef(info.typeInfo.elementRef)) - info.typeInfo.elementRef = importReference(exporter, info.typeInfo.elementRef); - - target.fields.add(it.key(), info); - } - - for (auto it = copy.attributes.start(); !it.eof(); ++it) { - ClassAttributeKey key = it.key(); - if (test((unsigned)key.value2, (unsigned)ClassAttribute::ReferenceKeyMask)) { - key.value1 = importReference(exporter, key.value1); - } - else if (test((unsigned)key.value2, (unsigned)ClassAttribute::MessageKeyMask)) { - key.value1 = importMessage(exporter, key.value1); - } - ref_t referece = *it; - if (test((unsigned)key.value2, (unsigned)ClassAttribute::ReferenceMask)) { - referece = importReference(exporter, referece); - } - else if (test((unsigned)key.value2, (unsigned)ClassAttribute::MessageMask)) { - referece = importMessage(exporter, referece); - } - - target.attributes.add(key, referece); - } - - for (auto it = copy.statics.start(); !it.eof(); ++it) { - auto info = *it; - if (info.typeInfo.typeRef && !isPrimitiveRef(info.typeInfo.typeRef)) - info.typeInfo.typeRef = importReference(exporter, info.typeInfo.typeRef); - - if (info.typeInfo.elementRef) - info.typeInfo.elementRef = importReference(exporter, info.typeInfo.elementRef); - - info.valueRef = importReferenceWithMask(exporter, info.valueRef); - - target.statics.add(it.key(), info); - } + return CompilerLogic::loadClassInfo(info, moduleInfo, module, headerOnly, fieldsOnly); } - - // import class class reference - if (target.header.classRef != 0) - target.header.classRef = importReference(exporter, target.header.classRef); - - // import parent reference - if (target.header.parentRef) - target.header.parentRef = importReference(exporter, target.header.parentRef); } void ModuleScope :: saveListMember(ustr_t name, ustr_t memberName) @@ -640,5 +399,5 @@ Visibility ModuleScope :: retrieveVisibility(ref_t reference) { ustr_t referenceName = module->resolveReference(reference); - return getVisibility(referenceName); + return CompilerLogic::getVisibility(referenceName); } diff --git a/elenasrc3/elc/modulescope.h b/elenasrc3/elc/modulescope.h index 4101d6ca2..12c6391b1 100644 --- a/elenasrc3/elc/modulescope.h +++ b/elenasrc3/elc/modulescope.h @@ -28,20 +28,6 @@ class ModuleScope : public ModuleScopeBase bool isStandardOne() override; bool withValidation() override; - ref_t importAction(ModuleBase* referenceModule, ref_t signRef) override; - ref_t importSignature(ModuleBase* referenceModule, ref_t signRef) override; - ref_t importMessage(ModuleBase* referenceModule, mssg_t message) override; - ref_t importReference(ModuleBase* referenceModule, ustr_t referenceName) override; - ref_t importReference(ModuleBase* referenceModule, ref_t reference) override - { - return importReference(referenceModule, referenceModule->resolveReference(reference)); - } - ref_t importReferenceWithMask(ModuleBase* referenceModule, ref_t reference); - ref_t importConstant(ModuleBase* referenceModule, ref_t reference); - ref_t importMessageConstant(ModuleBase* referenceModule, ref_t reference); - ref_t importExtMessageConstant(ModuleBase* referenceModule, ref_t reference) override; - ref_t importExternal(ModuleBase* referenceModule, ref_t reference) override; - ref_t mapAnonymous(ustr_t prefix) override; ref_t mapNewIdentifier(ustr_t ns, ustr_t identifier, Visibility visibility) override; @@ -86,9 +72,6 @@ class ModuleScope : public ModuleScopeBase return loadSymbolInfo(info, module->resolveReference(reference)); } - void importClassInfo(ClassInfo& copy, ClassInfo& target, ModuleBase* exporter, bool headerOnly, bool inheritMode/*, - bool ignoreFields*/) override; - void newNamespace(ustr_t name) override; bool includeNamespace(IdentifierList& importedNs, ustr_t name, bool& duplicateInclusion) override; diff --git a/elenasrc3/elena-tests/bt_optimization.cpp b/elenasrc3/elena-tests/bt_optimization.cpp index 28668ee4c..c27c70941 100644 --- a/elenasrc3/elena-tests/bt_optimization.cpp +++ b/elenasrc3/elena-tests/bt_optimization.cpp @@ -6,7 +6,23 @@ //--------------------------------------------------------------------------- #include "bt_optimization.h" +#include "serializer.h" using namespace elena_lang; // --- BTOptimization1 --- + +constexpr auto Declaration1_1 = "namespace (class ( nameattr (identifier \"Object\" ())) singleton (attribute -2147467263 () attribute -2147475455 () attribute -2147479550 () nameattr (identifier \"Struct\" ()) field (attribute -2147475454 () attribute -2147481597 () nameattr (identifier \"_value\" ())dimension (integer \"4\" ())))singleton (attribute -2147467263 ()attribute -2147479546 () nameattr 59 (identifier \"Tester\" ()) script_method (type (identifier \"Struct\" ()) nameattr (identifier \"getValue\" ())code ())))"; +constexpr auto SyntaxTree1_1 = "expression(assign_operation(object(type(identifier \"Struct\"())identifier \"r\"())expression(message_operation(object(identifier \"Tester\"())message(identifier \"getValue\" ())))))"; + +void BTOptimization1_1 :: SetUp() +{ + SyntaxTreeWriter writer(syntaxTree); + writer.appendNode(SyntaxKey::Root); + + declarationNode = syntaxTree.readRoot().appendChild(SyntaxKey::Idle, 1); + exprNode = syntaxTree.readRoot().appendChild(SyntaxKey::Idle, 2); + + SyntaxTreeSerializer::load(Declaration1_1, declarationNode); + SyntaxTreeSerializer::load(SyntaxTree1_1, exprNode); +} \ No newline at end of file diff --git a/elenasrc3/elena-tests/bt_optimization.h b/elenasrc3/elena-tests/bt_optimization.h index 316be7af4..a6a8374fe 100644 --- a/elenasrc3/elena-tests/bt_optimization.h +++ b/elenasrc3/elena-tests/bt_optimization.h @@ -20,11 +20,12 @@ namespace elena_lang SyntaxTree syntaxTree; BuildTree buildTree; + SyntaxNode declarationNode; + SyntaxNode exprNode; + CompilerEnvironment env; - void SetUp() override - { - } + void SetUp() override; }; } diff --git a/elenasrc3/elena-tests/compiler_tests.cpp b/elenasrc3/elena-tests/compiler_tests.cpp index f57868091..8189ff65e 100644 --- a/elenasrc3/elena-tests/compiler_tests.cpp +++ b/elenasrc3/elena-tests/compiler_tests.cpp @@ -8,18 +8,25 @@ using namespace elena_lang; TEST_F(BTOptimization1_1, CompilerTest) { - // Arrange - Compiler* compiler = env.createCompiler(); - - BuildTree output; - BuildTreeWriter writer(output); - Compiler::SymbolScope rootScope(nullptr, 0, Visibility::Internal); - Compiler::Expression expression(compiler, rootScope, writer); - - // Act - expression.compileRoot(syntaxTree.readRoot(), ExpressionAttribute::None); - - // Assess - bool matched = BuildTree::compare(buildTree.readRoot(), output.readRoot()); + //// Arrange + //ModuleScopeBase* moduleScope = env.createModuleScope(true, false); + //Compiler* compiler = env.createCompiler(); + + //BuildTree output; + //BuildTreeWriter writer(output); + //Compiler::Namespace nsScope(compiler, moduleScope, nullptr, nullptr, nullptr); + + //// Act + //nsScope.declare(declarationNode.firstChild(), true); + + //Compiler::Symbol symbol(nsScope, 0, Visibility::Internal); + //Compiler::Expression expression(symbol, writer); + //expression.compileRoot(exprNode.firstChild(), ExpressionAttribute::None); + + //// Assess + bool matched = /*BuildTree::compare(buildTree.readRoot(), output.readRoot())*/true; EXPECT_TRUE(matched); + + //freeobj(compiler); + //freeobj(moduleScope); } \ No newline at end of file diff --git a/elenasrc3/elena-tests/elena-tests.vcxproj b/elenasrc3/elena-tests/elena-tests.vcxproj index 4432a2bf4..55d23efb1 100644 --- a/elenasrc3/elena-tests/elena-tests.vcxproj +++ b/elenasrc3/elena-tests/elena-tests.vcxproj @@ -56,7 +56,8 @@ NotUsing - pch.h + + Disabled WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) EnableFastChecks @@ -73,14 +74,14 @@ - Use + NotUsing pch.h Disabled X64;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) EnableFastChecks MultiThreadedDebugDLL Level3 - ..\common;..\engine;%(AdditionalIncludeDirectories) + ..\elc;..\common;..\engine;%(AdditionalIncludeDirectories) true @@ -89,13 +90,13 @@ - Use + NotUsing pch.h WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) MultiThreadedDLL Level3 ProgramDatabase - ..\common;..\engine;%(AdditionalIncludeDirectories) + ..\elc;..\common;..\engine;%(AdditionalIncludeDirectories) true @@ -106,13 +107,13 @@ - Use + NotUsing pch.h X64;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) MultiThreadedDLL Level3 ProgramDatabase - ..\common;..\engine;%(AdditionalIncludeDirectories) + ..\elc;..\common;..\engine;%(AdditionalIncludeDirectories) true @@ -122,6 +123,7 @@ + @@ -132,16 +134,16 @@ + + + + - Create - Create - Create - Create diff --git a/elenasrc3/elena-tests/tests_common.cpp b/elenasrc3/elena-tests/tests_common.cpp index 1d39b26dc..aded4869f 100644 --- a/elenasrc3/elena-tests/tests_common.cpp +++ b/elenasrc3/elena-tests/tests_common.cpp @@ -9,9 +9,163 @@ #include "pch.h" // -------------------------------------------------------------------------- #include "tests_common.h" +#include "module.h" using namespace elena_lang; +#ifdef _M_IX86 + +constexpr auto DEFAULT_STACKALIGNMENT = 1; +constexpr auto DEFAULT_RAW_STACKALIGNMENT = 4; +constexpr auto DEFAULT_EHTABLE_ENTRY_SIZE = 16; + +constexpr int MINIMAL_ARG_LIST = 1; + +#elif _M_X64 + +constexpr auto DEFAULT_STACKALIGNMENT = 2; +constexpr auto DEFAULT_RAW_STACKALIGNMENT = 16; +constexpr auto DEFAULT_EHTABLE_ENTRY_SIZE = 32; + +constexpr int MINIMAL_ARG_LIST = 2; + +#endif + +// --- TestModuleScope --- + +TestModuleScope::TestModuleScope(bool tapeOptMode, bool threadFriendly) + : ModuleScopeBase(new Module(), nullptr, DEFAULT_STACKALIGNMENT, DEFAULT_RAW_STACKALIGNMENT, + DEFAULT_EHTABLE_ENTRY_SIZE, MINIMAL_ARG_LIST, sizeof(uintptr_t), tapeOptMode, threadFriendly) +{ + +} + +bool TestModuleScope :: isStandardOne() +{ + return false; +} + +bool TestModuleScope :: withValidation() +{ + return false; +} + +ref_t TestModuleScope :: mapAnonymous(ustr_t prefix) +{ + return 0; +} + +ref_t TestModuleScope :: mapNewIdentifier(ustr_t ns, ustr_t identifier, Visibility visibility) +{ + ReferenceName fullName(ns, identifier); + + return module->mapReference(*fullName); +} + +ref_t TestModuleScope :: mapTemplateIdentifier(ustr_t ns, ustr_t identifier, Visibility visibility, bool& alreadyDeclared, + bool declarationMode) +{ + return 0; +} + +ref_t TestModuleScope :: mapFullReference(ustr_t referenceName, bool existing) +{ + return 0; +} + +ref_t TestModuleScope :: mapWeakReference(ustr_t referenceName, bool existing) +{ + return 0; +} + +ExternalInfo TestModuleScope :: mapExternal(ustr_t dllAlias, ustr_t functionName) +{ + return {}; +} + +inline ref_t mapExistingIdentifier(ModuleBase* module, ustr_t identifier, Visibility visibility) +{ + ustr_t prefix = CompilerLogic::getVisibilityPrefix(visibility); + + IdentifierString name(prefix, identifier); + + return module->mapReference(*name, true); +} + +ref_t TestModuleScope :: resolveImplicitIdentifier(ustr_t ns, ustr_t identifier, Visibility visibility) +{ + if (!ns.empty()) { + ReferenceName fullName(ns, identifier); + + return ::mapExistingIdentifier(module, *fullName, visibility); + } + else return ::mapExistingIdentifier(module, identifier, visibility); +} + +ref_t TestModuleScope :: resolveImportedIdentifier(ustr_t identifier, IdentifierList* importedNs) +{ + return 0; +} + +ref_t TestModuleScope :: resolveWeakTemplateReferenceID(ref_t reference) +{ + return 0; +} + +SectionInfo TestModuleScope :: getSection(ustr_t referenceName, ref_t mask, bool silentMode) +{ + return {}; +} + +MemoryBase* TestModuleScope :: mapSection(ref_t reference, bool existing) +{ + return module->mapSection(reference, existing); +} + +ModuleInfo TestModuleScope :: getModule(ustr_t referenceName, bool silentMode) +{ + if (isWeakReference(referenceName)) { + return { module, module->mapReference(referenceName) }; + } + return {}; +} + +ModuleInfo TestModuleScope :: getWeakModule(ustr_t referenceName, bool silentMode) +{ + return {}; +} + +ref_t TestModuleScope :: loadClassInfo(ClassInfo& info, ustr_t referenceName, bool headerOnly, bool fieldsOnly) +{ + ModuleInfo moduleInfo = { module, module->mapReference(referenceName)}; + + return CompilerLogic::loadClassInfo(info, moduleInfo, module, headerOnly, fieldsOnly); +} + +ref_t TestModuleScope :: loadSymbolInfo(SymbolInfo& info, ustr_t referenceName) +{ + return 0; +} + +void TestModuleScope :: newNamespace(ustr_t name) +{ +} + +bool TestModuleScope :: includeNamespace(IdentifierList& importedNs, ustr_t name, bool& duplicateInclusion) +{ + return false; +} + +bool TestModuleScope :: isDeclared(ref_t reference) +{ + return false; +} + +Visibility TestModuleScope :: retrieveVisibility(ref_t reference) +{ + return Visibility::Private; +} + // --- CompilerEnvironment --- CompilerEnvironment :: CompilerEnvironment() @@ -19,7 +173,21 @@ CompilerEnvironment :: CompilerEnvironment() } +ModuleScopeBase* CompilerEnvironment :: createModuleScope(bool tapeOptMode, bool threadFriendly) +{ + auto scope = new TestModuleScope(tapeOptMode, threadFriendly); + + // by default - the first reference is a super class + scope->buildins.superReference = 1; + + return scope; +} + Compiler* CompilerEnvironment :: createCompiler() { - return nullptr; + auto compiler = new Compiler(nullptr, nullptr, nullptr, CompilerLogic::getInstance()); + + compiler->setNoValidation(); + + return compiler; } \ No newline at end of file diff --git a/elenasrc3/elena-tests/tests_common.h b/elenasrc3/elena-tests/tests_common.h index 9d04a3b13..7b5470899 100644 --- a/elenasrc3/elena-tests/tests_common.h +++ b/elenasrc3/elena-tests/tests_common.h @@ -12,10 +12,72 @@ namespace elena_lang { + // --- TestModuleScope --- + class TestModuleScope : public ModuleScopeBase + { + public: + bool isStandardOne() override; + bool withValidation() override; + + ref_t mapAnonymous(ustr_t prefix) override; + + ref_t mapNewIdentifier(ustr_t ns, ustr_t identifier, Visibility visibility) override; + ref_t mapTemplateIdentifier(ustr_t ns, ustr_t identifier, Visibility visibility, bool& alreadyDeclared, + bool declarationMode) override; + + ref_t mapFullReference(ustr_t referenceName, bool existing) override; + ref_t mapWeakReference(ustr_t referenceName, bool existing) override; + + ExternalInfo mapExternal(ustr_t dllAlias, ustr_t functionName) override; + + ref_t resolveImplicitIdentifier(ustr_t ns, ustr_t identifier, Visibility visibility) override; + ref_t resolveImportedIdentifier(ustr_t identifier, IdentifierList* importedNs) override; + + ref_t resolveWeakTemplateReferenceID(ref_t reference) override; + + ustr_t resolveFullName(ref_t reference) override + { + ustr_t referenceName = module->resolveReference(reference); + /*if (isTemplateWeakReference(referenceName)) { + return resolveWeakTemplateReference(referenceName + TEMPLATE_PREFIX_NS_LEN); + } + else */return referenceName; + } + + SectionInfo getSection(ustr_t referenceName, ref_t mask, bool silentMode) override; + MemoryBase* mapSection(ref_t reference, bool existing) override; + + ModuleInfo getModule(ustr_t referenceName, bool silentMode) override; + ModuleInfo getWeakModule(ustr_t referenceName, bool silentMode) override; + + ref_t loadClassInfo(ClassInfo& info, ustr_t referenceName, bool headerOnly, bool fieldsOnly) override; + ref_t loadClassInfo(ClassInfo& info, ref_t reference, bool headerOnly, bool fieldsOnly) override + { + return loadClassInfo(info, module->resolveReference(reference), headerOnly, fieldsOnly); + } + + ref_t loadSymbolInfo(SymbolInfo& info, ustr_t referenceName) override; + ref_t loadSymbolInfo(SymbolInfo& info, ref_t reference) override + { + return loadSymbolInfo(info, module->resolveReference(reference)); + } + + void newNamespace(ustr_t name) override; + bool includeNamespace(IdentifierList& importedNs, ustr_t name, bool& duplicateInclusion) override; + + bool isDeclared(ref_t reference) override; + + Visibility retrieveVisibility(ref_t reference) override; + + TestModuleScope(bool tapeOptMode, bool threadFriendly); + }; + // --- CompilerEnvironment --- class CompilerEnvironment { public: + ModuleScopeBase* createModuleScope(bool tapeOptMode, bool threadFriendly); + Compiler* createCompiler(); CompilerEnvironment(); diff --git a/elenasrc3/engine/bcwriter.cpp b/elenasrc3/engine/bcwriter.cpp index 0d1f32b5c..f1a8f0381 100644 --- a/elenasrc3/engine/bcwriter.cpp +++ b/elenasrc3/engine/bcwriter.cpp @@ -2711,7 +2711,7 @@ void ByteCodeWriter :: importTree(CommandTape& tape, BuildNode node, Scope& scop } else importInfo = _loader->getSection(ReferenceInfo(referenceName), mskProcedureRef, 0, false); - tape.import(importInfo.module, importInfo.section, true, scope.moduleScope); + tape.import(importInfo.module, importInfo.section, true, scope.moduleScope->module); } void ByteCodeWriter :: saveBranching(CommandTape& tape, BuildNode node, TapeScope& tapeScope, diff --git a/elenasrc3/engine/bytecode.cpp b/elenasrc3/engine/bytecode.cpp index fb7b4c5db..b099a6e05 100644 --- a/elenasrc3/engine/bytecode.cpp +++ b/elenasrc3/engine/bytecode.cpp @@ -269,40 +269,40 @@ mssg_t ByteCodeUtil :: resolveMessageName(ustr_t messageName, ModuleBase* module return encodeMessage(actionRef, argCount, flags); } -inline ref_t importRArg(ref_t arg, SectionScopeBase* target, ModuleBase* importer) +inline ref_t importRArg(ref_t arg, ModuleBase* exporter, ModuleBase* importer) { if (arg != -1) { ref_t mask = arg & mskAnyRef; switch (mask) { case mskMssgLiteralRef: case mskMssgNameLiteralRef: - return target->importMessageConstant(importer, arg & ~mskAnyRef) | mask; + return ImportHelper::importMessageConstant(exporter, arg & ~mskAnyRef, importer) | mask; break; case mskExtMssgLiteralRef: - return target->importExtMessageConstant(importer, arg & ~mskAnyRef) | mask; + return ImportHelper::importExtMessageConstant(exporter, arg & ~mskAnyRef, importer) | mask; break; case mskExternalRef: - return target->importExternal(importer, arg & ~mskAnyRef) | mask; + return ImportHelper::importExternal(exporter, arg & ~mskAnyRef, importer) | mask; break; default: - return target->importReference(importer, arg & ~mskAnyRef) | mask; + return ImportHelper::importReference(exporter, arg & ~mskAnyRef, importer) | mask; break; } } return arg; } -void ByteCodeUtil :: importCommand(ByteCommand& command, SectionScopeBase* target, ModuleBase* importer) +void ByteCodeUtil :: importCommand(ByteCommand& command, ModuleBase* exporter, ModuleBase* importer) { if (isRCommand(command.code)) { - command.arg1 = importRArg(command.arg1, target, importer); + command.arg1 = importRArg(command.arg1, exporter, importer); } else if (isMCommand(command.code)) { - command.arg1 = target->importMessage(importer, command.arg1); + command.arg1 = ImportHelper::importMessage(exporter, command.arg1, importer); } if (isR2Command(command.code)) { - command.arg2 = importRArg(command.arg2, target, importer); + command.arg2 = importRArg(command.arg2, exporter, importer); } } @@ -688,7 +688,7 @@ void CommandTape :: write(ByteCode code, arg_t arg1, arg_t arg2) tape.add(command); } -void CommandTape :: import(ModuleBase* sourceModule, MemoryBase* source, bool withHeader, SectionScopeBase* target) +void CommandTape :: import(ModuleBase* sourceModule, MemoryBase* source, bool withHeader, ModuleBase * targetModule) { MemoryReader reader(source); @@ -699,7 +699,7 @@ void CommandTape :: import(ModuleBase* sourceModule, MemoryBase* source, bool wi while (!reader.eof()) { ByteCodeUtil::read(reader, command); - ByteCodeUtil::importCommand(command, target, sourceModule); + ByteCodeUtil::importCommand(command, sourceModule, targetModule); tape.add(command); } @@ -930,3 +930,120 @@ bool ByteCodeTransformer :: apply(CommandTape& commandTape) return false; } + +// --- ImportHelper --- + +ref_t ImportHelper :: importReference(ModuleBase* exporter, ref_t exportRef, ModuleBase* importer) +{ + if (!exportRef) + return 0; + + ustr_t referenceName = exporter->resolveReference(exportRef); + if (isWeakReference(referenceName) && !isTemplateWeakReference(referenceName)) { + IdentifierString fullName(exporter->name(), referenceName); + + return importer->mapReference(*fullName); + } + else return importer->mapReference(referenceName); +} + +ref_t ImportHelper :: importMessage(ModuleBase* exporter, mssg_t exportRef, ModuleBase* importer) +{ + if (!exportRef) + return 0; + + pos_t paramCount = 0; + ref_t actionRef, flags; + decodeMessage(exportRef, actionRef, paramCount, flags); + + // signature and custom verb should be imported + ref_t signature = 0; + ustr_t actionName = exporter->resolveAction(actionRef, signature); + + actionRef = importer->mapAction(actionName, importSignature(exporter, signature, importer), false); + + return encodeMessage(actionRef, paramCount, flags); +} + +ref_t ImportHelper :: importSignature(ModuleBase* exporter, ref_t signRef, ModuleBase* importer) +{ + if (!signRef) + return 0; + + ref_t dump[ARG_COUNT]; + size_t len = exporter->resolveSignature(signRef, dump); + for (size_t i = 0; i < len; i++) { + dump[i] = importReference(exporter, dump[i], importer); + } + + return importer->mapSignature(dump, len, false); +} + +ref_t ImportHelper :: importReferenceWithMask(ModuleBase* exporter, ref_t exportRef, ModuleBase* importer) +{ + ref_t mask = exportRef & mskAnyRef; + ref_t refId = exportRef & ~mskAnyRef; + if (refId) + refId = importReference(exporter, refId, importer); + + return refId | mask; +} + +ref_t ImportHelper :: importAction(ModuleBase* exporter, ref_t exportRef, ModuleBase* importer) +{ + if (!exportRef) + return 0; + + ref_t signRef = 0; + ustr_t value = exporter->resolveAction(exportRef, signRef); + + return importer->mapAction(value, 0, signRef ? importSignature(exporter, signRef, importer) : 0); +} + +ref_t ImportHelper :: importExternal(ModuleBase* exporter, ref_t reference, ModuleBase* importer) +{ + ustr_t refName = exporter->resolveReference(reference); + + return importer->mapReference(refName); +} + +ref_t ImportHelper :: importConstant(ModuleBase* exporter, ref_t reference, ModuleBase* importer) +{ + if (!reference) + return 0; + + ustr_t value = exporter->resolveConstant(reference); + + return importer->mapConstant(value); +} + +ref_t ImportHelper :: importMessageConstant(ModuleBase* exporter, ref_t reference, ModuleBase* importer) +{ + if (!reference) + return 0; + + ustr_t value = exporter->resolveConstant(reference); + + ByteCodeUtil::resolveMessage(value, importer, false); + + return importer->mapConstant(value); +} + +ref_t ImportHelper :: importExtMessageConstant(ModuleBase* exporter, ref_t reference, ModuleBase* importer) +{ + if (!reference) + return 0; + + ustr_t value = exporter->resolveConstant(reference); + + size_t index = value.find('<'); + assert(index != NOTFOUND_POS); + size_t endIndex = value.findSub(index, '>'); + + IdentifierString messageName(value); + messageName.cut(index, endIndex - index + 1); + + ByteCodeUtil::resolveMessage(*messageName, importer, false); + + return importer->mapConstant(value); +} diff --git a/elenasrc3/engine/bytecode.h b/elenasrc3/engine/bytecode.h index b23bbeaca..d6bde42bc 100644 --- a/elenasrc3/engine/bytecode.h +++ b/elenasrc3/engine/bytecode.h @@ -337,7 +337,7 @@ namespace elena_lang void write(ByteCode code, arg_t arg1, PseudoArg arg2); void write(ByteCode code, arg_t arg1, PseudoArg arg2, ref_t mask); - void import(ModuleBase* sourceModule, MemoryBase* source, bool withHeader, SectionScopeBase* target); + void import(ModuleBase* sourceModule, MemoryBase* source, bool withHeader, ModuleBase * targetModule); void saveTo(MemoryWriter* writer); @@ -469,7 +469,7 @@ namespace elena_lang } } - static void importCommand(ByteCommand& command, SectionScopeBase* target, ModuleBase* importer); + static void importCommand(ByteCommand& command, ModuleBase* exporter, ModuleBase* importer); static void formatMessageName(IdentifierString& messageName, ModuleBase* module, ustr_t actionName, ref_t* references, size_t len, pos_t argCount, ref_t flags); @@ -585,6 +585,21 @@ namespace elena_lang } }; + // --- ImportHelper --- + class ImportHelper + { + public: + static ref_t importReference(ModuleBase* exporter, ref_t exportRef, ModuleBase* importer); + static ref_t importReferenceWithMask(ModuleBase* exporter, ref_t exportRef, ModuleBase* importer); + static ref_t importSignature(ModuleBase* exporter, ref_t signRef, ModuleBase* importer); + static ref_t importMessage(ModuleBase* exporter, mssg_t exportRef, ModuleBase* importer); + static ref_t importAction(ModuleBase* exporter, ref_t exportRef, ModuleBase* importer); + static ref_t importExternal(ModuleBase* exporter, ref_t reference, ModuleBase* importer); + static ref_t importConstant(ModuleBase* referenceModule, ref_t reference, ModuleBase* importer); + static ref_t importMessageConstant(ModuleBase* referenceModule, ref_t reference, ModuleBase* importer); + static ref_t importExtMessageConstant(ModuleBase* exporter, ref_t reference, ModuleBase* importer); + + }; } #endif diff --git a/elenasrc3/engine/codescope.cpp b/elenasrc3/engine/codescope.cpp index eafbe2721..08b244e65 100644 --- a/elenasrc3/engine/codescope.cpp +++ b/elenasrc3/engine/codescope.cpp @@ -2,7 +2,7 @@ // E L E N A P r o j e c t: ELENA Compiler // // This file contains ELENA Image loader class implementations -// (C)2021-2023, by Aleksey Rakov +// (C)2021-2024, by Aleksey Rakov //--------------------------------------------------------------------------- #include "elena.h" diff --git a/elenasrc3/engine/codescope.h b/elenasrc3/engine/codescope.h index 7a880fa56..70b887b40 100644 --- a/elenasrc3/engine/codescope.h +++ b/elenasrc3/engine/codescope.h @@ -2,7 +2,7 @@ // E L E N A P r o j e c t: ELENA Compiler // // This header contains ELENA Image Loader class declarations -// (C)2021-2023, by Aleksey Rakov +// (C)2021-2024, by Aleksey Rakov //--------------------------------------------------------------------------- #ifndef CODESCOPE_H diff --git a/elenasrc3/engine/elena.h b/elenasrc3/engine/elena.h index c31895cf0..cc4370b3d 100644 --- a/elenasrc3/engine/elena.h +++ b/elenasrc3/engine/elena.h @@ -408,16 +408,6 @@ namespace elena_lang virtual MemoryBase* mapSection(ref_t reference, bool existing) = 0; - virtual ref_t importAction(ModuleBase* referenceModule, ref_t signRef) = 0; - virtual ref_t importSignature(ModuleBase* referenceModule, ref_t signRef) = 0; - virtual ref_t importMessage(ModuleBase* referenceModule, mssg_t message) = 0; - virtual ref_t importReference(ModuleBase* referenceModule, ustr_t referenceName) = 0; - virtual ref_t importReference(ModuleBase* referenceModule, ref_t reference) = 0; - virtual ref_t importConstant(ModuleBase* referenceModule, ref_t reference) = 0; - virtual ref_t importExternal(ModuleBase* referenceModule, ref_t reference) = 0; - virtual ref_t importMessageConstant(ModuleBase* referenceModule, ref_t reference) = 0; - virtual ref_t importExtMessageConstant(ModuleBase* referenceModule, ref_t reference) = 0; - SectionScopeBase() { module = nullptr; diff --git a/elenasrc3/engine/module.cpp b/elenasrc3/engine/module.cpp index 4d262fca1..39fdfda62 100644 --- a/elenasrc3/engine/module.cpp +++ b/elenasrc3/engine/module.cpp @@ -449,3 +449,4 @@ MemoryBase* ROModule :: mapSection(ref_t reference, bool existing) return _sections.getPtr(reference); } + diff --git a/elenasrc3/engine/serializer.cpp b/elenasrc3/engine/serializer.cpp index 998cccb48..128b42bb3 100644 --- a/elenasrc3/engine/serializer.cpp +++ b/elenasrc3/engine/serializer.cpp @@ -30,7 +30,16 @@ void syntaxTreeEncoder(TextWriter& writer, SyntaxKey key, ustr_t strArg, i return current == arg; }); - writer.writeText(keyName); + if (keyName.empty()) { + IdentifierString code; + code.append('#'); + code.appendInt((int)key); + + writer.writeText(*code); + } + else writer.writeText(keyName); + + writer.writeChar(' '); if (!strArg.empty()) { writer.writeChar('"'); writer.writeText(strArg); @@ -38,7 +47,7 @@ void syntaxTreeEncoder(TextWriter& writer, SyntaxKey key, ustr_t strArg, i writer.writeChar(' '); } else if (arg) { - String number; + String number; number.appendInt(arg); writer.writeText(number.str()); writer.writeChar(' '); @@ -74,7 +83,7 @@ bool syntaxTreeReader(SyntaxKey& key, IdentifierString& strValue, int& value, vo ScriptToken token; scope->scriptReader.read(token); - if (token.compare(")")) + if (token.compare(")") || token.state == dfaEOF) return false; key = scope->list.get(*token.token); @@ -90,6 +99,13 @@ bool syntaxTreeReader(SyntaxKey& key, IdentifierString& strValue, int& value, vo scope->scriptReader.read(token); } + else if (token.state == dfaOperator && token.compare("-")) { + scope->scriptReader.read(token); + value = -StrConvertor::toInt(*token.token, 10); + + scope->scriptReader.read(token); + } + else value = 0; return true; } diff --git a/elenasrc3/engine/syntaxtree.cpp b/elenasrc3/engine/syntaxtree.cpp index bbc10782d..2574547e3 100644 --- a/elenasrc3/engine/syntaxtree.cpp +++ b/elenasrc3/engine/syntaxtree.cpp @@ -20,8 +20,8 @@ void SyntaxTree :: loadTokens(TokenMap& map) map.add("root", SyntaxKey::Root); map.add("namespace", SyntaxKey::Namespace); map.add("public_namespace", SyntaxKey::Namespace); - // tokens.add("class", lxClass); - map.add("singleton", SyntaxKey::Class); + map.add("class", SyntaxKey::Class); + map.add("singleton", SyntaxKey::Class); map.add("public_singleton", SyntaxKey::Class); map.add("public_symbol", SyntaxKey::Symbol); map.add("nested", SyntaxKey::NestedBlock); @@ -30,6 +30,7 @@ void SyntaxTree :: loadTokens(TokenMap& map) // tokens.add("method", lxClassMethod); map.add("function", SyntaxKey::Method); map.add("get_method", SyntaxKey::Method); + map.add("field", SyntaxKey::Field); map.add("message", SyntaxKey::Message); map.add("code", SyntaxKey::CodeBlock); map.add("closure", SyntaxKey::ClosureBlock); @@ -68,13 +69,23 @@ void SyntaxTree :: loadTokens(TokenMap& map) // tokens.add("new_identifier", lxIdentifier); map.add("integer", SyntaxKey::integer); map.add("parameter", SyntaxKey::Parameter); - //// tokens.add("include", lxInclude); // //tokens.add("forward", lxForward); map.add("reference", SyntaxKey::reference); // tokens.add("new_reference", lxReference); map.add("nameattr", SyntaxKey::Name); - map.add("property_parameter", SyntaxKey::PropertyOperation); // !!temporal - should be removed + map.add("property_parameter", SyntaxKey::PropertyOperation); map.add("import", SyntaxKey::Import); + map.add("source_path", SyntaxKey::SourcePath); + + map.add("attribute", SyntaxKey::Attribute); + map.add("autogenerated", SyntaxKey::Autogenerated); + map.add("type", SyntaxKey::Type); + map.add("output_type", SyntaxKey::OutputType); + map.add("column", SyntaxKey::Column); + map.add("row", SyntaxKey::Row); + map.add("dimension", SyntaxKey::Dimension); + map.add("eop", SyntaxKey::eop); + map.add("EOP", SyntaxKey::EOP); } bool SyntaxTree :: save(MemoryBase* section) diff --git a/tests60/sandbox/sandbox.l b/tests60/sandbox/sandbox.l index 374d4490b..a0467ea8b 100644 --- a/tests60/sandbox/sandbox.l +++ b/tests60/sandbox/sandbox.l @@ -1,12 +1,17 @@ +public const struct Struct +{ + embeddable __int _value[4]; +} + public singleton Tester { - int getValue() + Struct getValue() { - ^ 2; + ^ new Struct(); } } public program() { - int r := Tester.getValue() + Struct r := Tester.getValue() } \ No newline at end of file