diff --git a/ast/coretypes.yaml b/ast/coretypes.yaml index 678ef7e..38f9773 100644 --- a/ast/coretypes.yaml +++ b/ast/coretypes.yaml @@ -17,6 +17,8 @@ structs: init: -1 classes: + - AssocData: + data: [] - Scope: super: ScopeChild data: @@ -45,6 +47,9 @@ classes: type: int32_t is_ctor: false init: -1 + - assocData: + type: UP + is_ctor: false - ScopeChildRef: super: ScopeChild diff --git a/ast/expr.yaml b/ast/expr.yaml index 17639da..d4dcffb 100644 --- a/ast/expr.yaml +++ b/ast/expr.yaml @@ -96,9 +96,13 @@ classes: - params: "UP" - subscript: "UP" - target: + type: int32_t is_ctor: false - type: UP - visit: false +# visit: false +# - target: +# is_ctor: false +# type: UP +# visit: false - ExprNull: - super: Expr @@ -120,6 +124,11 @@ classes: - super: Expr - data: - target: +# doc: | +# `target` points to the root, or first element, of this +# path. The balance of the reference expression may +# contain further relative references relative to this +# initial base is_ctor: false type: UP init: 0 @@ -225,4 +234,4 @@ classes: - id: UP - params: UP - \ No newline at end of file + diff --git a/ast/functions.yaml b/ast/functions.yaml index 7e7cf3f..28420ad 100644 --- a/ast/functions.yaml +++ b/ast/functions.yaml @@ -30,6 +30,7 @@ classes: is_ctor: False - proto: UP - body: UP + - plat: PlatQual - FunctionParamDecl: - super: ScopeChild - data: @@ -52,6 +53,11 @@ classes: - is_pure: type: bool is_ctor: false + init: false + - is_target: + type: bool + - is_solve: + type: bool - FunctionImport: - super: ScopeChild diff --git a/ast/linking.yaml b/ast/linking.yaml index 0951cfe..3d0850b 100644 --- a/ast/linking.yaml +++ b/ast/linking.yaml @@ -37,7 +37,7 @@ classes: - type: map - is_ctor: false - target: - - type: P + - type: P - is_ctor: false - init: 0 - visit: true @@ -95,6 +95,7 @@ classes: - definition: - type: P - is_ctor: false + - init: 0 - plist: - type: UP - is_ctor: false diff --git a/ivpm.yaml b/ivpm.yaml index 9d6a900..2dfa7d9 100644 --- a/ivpm.yaml +++ b/ivpm.yaml @@ -65,7 +65,7 @@ package: - name: default deps: - name: ciostream - src: pypi + url: https://github.com/mballance-utils/ciostream.git - name: pyastbuilder url: https://github.com/mballance/pyastbuilder.git - name: antlr4-tools.jar diff --git a/python/core.pyx b/python/core.pyx index 8321018..77e48b3 100644 --- a/python/core.pyx +++ b/python/core.pyx @@ -9,6 +9,7 @@ cimport zsp_parser.decl as decl cimport ciostream from libc.stdint cimport intptr_t from libcpp.vector cimport vector as std_vector +from libcpp.cast cimport dynamic_cast cdef Factory _inst = None cdef class Factory(object): @@ -127,6 +128,37 @@ class MarkerSeverityE(IntEnum): Hint = decl.MarkerSeverityE.Severity_Hint NumLevels = decl.MarkerSeverityE.Severity_NumLevels +cdef class Location(object): + + def __init__(self, file, line, pos): + self._file = file + self._line = line + self._pos = pos + + @property + def file(self): + return self._file + +cdef class Marker(object): + + def __dealloc__(self): + if self._owned: + del self._hndl + + cpdef str msg(self): + return self._hndl.msg().decode() + + cpdef Location loc(self): + cdef const ast_decl.Location *lp = &self._hndl.loc() + return Location(lp.fileid, lp.lineno, lp.linepos) + + @staticmethod + cdef Marker mk(decl.IMarker *hndl, bool owned=True): + ret = Marker() + ret._hndl = hndl + ret._owned = owned + return ret + cdef class MarkerListener(object): def __dealloc__(self): if self._owned: @@ -139,6 +171,18 @@ cdef class MarkerListener(object): cdef class MarkerCollector(MarkerListener): + cpdef markers(self): + ret = [] + for i in range(self.asCollector().markers().size()): + ret.append(Marker.mk( + self.asCollector().markers().at(i).get(), + False + )) + return ret + + cdef decl.IMarkerCollector *asCollector(self): + return dynamic_cast[decl.IMarkerCollectorP](self._hndl) + @staticmethod cdef MarkerCollector mk(decl.IMarkerCollector *hndl, bool owned=True): ret = MarkerCollector() diff --git a/python/zsp_parser/__init__.py b/python/zsp_parser/__init__.py index e69de29..f2d6bb1 100644 --- a/python/zsp_parser/__init__.py +++ b/python/zsp_parser/__init__.py @@ -0,0 +1,20 @@ + +import os + +def get_deps(): + return [] + +def get_libs(): + return ["zsp-parser"] + +def get_libdirs(): + pkg_dir = os.path.dirname(os.path.abspath(__file__)) + return [pkg_dir] + +def get_incdirs(): + pkg_dir = os.path.dirname(os.path.abspath(__file__)) + if os.path.isdir(os.path.join(pkg_dir, "include")): + return [os.path.join(pkg_dir, "include")] + else: + root_dir = os.path.abspath(os.path.join(pkg_dir, "../..")) + return [os.path.join(root_dir, "src", "include")] diff --git a/python/zsp_parser/core.pxd b/python/zsp_parser/core.pxd index 8ce426c..db5bf99 100644 --- a/python/zsp_parser/core.pxd +++ b/python/zsp_parser/core.pxd @@ -5,6 +5,7 @@ cimport zsp_parser.decl as decl cimport debug_mgr.core as dm_core cimport zsp_parser.ast as ast cimport ciostream +from libc.stdint cimport int32_t from libcpp cimport bool cdef class Factory(object): @@ -53,6 +54,21 @@ cdef class Linker(object): @staticmethod cdef Linker mk(decl.ILinker *hndl, bool owned=*) +cdef class Location(object): + cdef int32_t _file + cdef int32_t _line + cdef int32_t _pos + +cdef class Marker(object): + cdef decl.IMarker *_hndl + cdef bool _owned + + cpdef str msg(self) + + cpdef Location loc(self) + + @staticmethod + cdef Marker mk(decl.IMarker *hndl, bool owned=*) cdef class MarkerListener(object): cdef decl.IMarkerListener *_hndl @@ -62,6 +78,10 @@ cdef class MarkerListener(object): cdef class MarkerCollector(MarkerListener): + cpdef markers(self) + + cdef decl.IMarkerCollector *asCollector(self) + @staticmethod cdef MarkerCollector mk(decl.IMarkerCollector *hndl, bool owned=*) diff --git a/python/zsp_parser/decl.pxd b/python/zsp_parser/decl.pxd index 4829f62..29fa8df 100644 --- a/python/zsp_parser/decl.pxd +++ b/python/zsp_parser/decl.pxd @@ -17,6 +17,9 @@ from zsp_parser cimport ast_decl as ast cimport ciostream ctypedef IFactory *IFactoryP +ctypedef IMarker *IMarkerP +ctypedef IMarkerCollector *IMarkerCollectorP +ctypedef unique_ptr[IMarker] IMarkerUP cdef extern from "zsp/parser/IFactory.h" namespace "zsp::parser": @@ -66,15 +69,10 @@ cdef extern from "zsp/parser/IMarker.h" namespace "zsp::parser": Severity_Hint "zsp::parser::MarkerSeverityE::Hint" Severity_NumLevels "zsp::parser::MarkerSeverityE::NumLevels" - cdef cppclass Location: - int32_t file; - int32_t line; - int32_t pos; - cdef cppclass IMarker: const cpp_string &msg() const MarkerSeverityE severity() const - const Location &loc() const; + const ast.Location &loc() const; IMarker *clone() const cdef extern from "zsp/parser/IMarkerListener.h" namespace "zsp::parser": @@ -84,7 +82,7 @@ cdef extern from "zsp/parser/IMarkerListener.h" namespace "zsp::parser": cdef extern from "zsp/parser/IMarkerCollector.h" namespace "zsp::parser": cdef cppclass IMarkerCollector(IMarkerListener): - pass + const cpp_vector[IMarkerUP] &markers() const cdef extern from "zsp/parser/ISymbolTableIterator.h" namespace "zsp::parser": cdef cppclass ISymbolTableIterator: diff --git a/setup.py b/setup.py index bec168d..9df119e 100644 --- a/setup.py +++ b/setup.py @@ -24,7 +24,7 @@ sys.argv.remove("-DDEBUG") CMAKE_BUILD_TYPE="Debug" _DEBUG = True -elif "DEBUG" in os.environ.keys() and os.environ["DEBUG"] != "": +elif "DEBUG" in os.environ.keys() and os.environ["DEBUG"]: CMAKE_BUILD_TYPE="Debug" _DEBUG = True else: diff --git a/src/.antlr/PSSLexer.java b/src/.antlr/PSSLexer.java index e72c800..bfa0e42 100644 --- a/src/.antlr/PSSLexer.java +++ b/src/.antlr/PSSLexer.java @@ -1,4 +1,4 @@ -// Generated from /project/fun/zuspec/zuspec-parser/src/PSSLexer.g4 by ANTLR 4.9.2 +// Generated from /project/fun/zuspec/zuspec-fe-parser/packages/zuspec-parser/src/PSSLexer.g4 by ANTLR 4.9.2 import org.antlr.v4.runtime.Lexer; import org.antlr.v4.runtime.CharStream; import org.antlr.v4.runtime.Token; diff --git a/src/AstBuilderInt.cpp b/src/AstBuilderInt.cpp index c41c974..c1104ce 100644 --- a/src/AstBuilderInt.cpp +++ b/src/AstBuilderInt.cpp @@ -30,7 +30,7 @@ AstBuilderInt::AstBuilderInt( dmgr::IDebugMgr *dmgr, ast::IFactory *factory, IMarkerListener *marker_l) : m_factory(factory), m_marker_l(marker_l) { - DEBUG_INIT("AstBuilderInt", dmgr); + DEBUG_INIT("zsp::parser::AstBuilderInt", dmgr); m_collectDocStrings = false; m_enableProfile = false; m_field_depth = 0; @@ -532,12 +532,31 @@ antlrcpp::Any AstBuilderInt::visitProcedural_function(PSSParser::Procedural_func } m_exec_scope_s.pop_back(); + ast::PlatQual platqual = ast::PlatQual::PlatQual_None; + + if (ctx->platform_qualifier()) { + if (ctx->platform_qualifier()->TOK_TARGET()) { + platqual = ast::PlatQual::PlatQual_Target; + } else { + platqual = ast::PlatQual::PlatQual_Solve; + } + } + ast::IFunctionDefinition *func = m_factory->mkFunctionDefinition( mkFunctionPrototype(ctx->function_prototype()), - body + body, + platqual ); - addChild(func, ctx->start, ctx->TOK_RCBRACE()->getSymbol()); + if (ctx->platform_qualifier()) { + if (ctx->platform_qualifier()->TOK_TARGET()) { + func->getProto()->setIs_target(true); + } else { + func->getProto()->setIs_solve(true); + } + } + + addChild(func, ctx->start); DEBUG_LEAVE("visitProcedural_function"); return 0; } @@ -545,7 +564,7 @@ antlrcpp::Any AstBuilderInt::visitProcedural_function(PSSParser::Procedural_func antlrcpp::Any AstBuilderInt::visitFunction_decl(PSSParser::Function_declContext *ctx) { DEBUG_ENTER("visitFunction_decl"); ast::IFunctionPrototype *proto = mkFunctionPrototype(ctx->function_prototype()); - DEBUG("TODO: visitFunction_decl"); + addChild(proto, ctx->start); DEBUG_LEAVE("visitFunction_decl"); return 0; } @@ -557,6 +576,35 @@ antlrcpp::Any AstBuilderInt::visitFunction_prototype(PSSParser::Function_prototy return 0; } +antlrcpp::Any AstBuilderInt::visitImport_function(PSSParser::Import_functionContext *ctx) { + DEBUG_ENTER("visitImport_function"); + if (ctx->type_identifier()) { + // Two-step import specification + } else { + // One-step import specification + ast::PlatQual platqual = ast::PlatQual::PlatQual_None; + + if (ctx->platform_qualifier()) { + if (ctx->platform_qualifier()->TOK_TARGET()) { + platqual = ast::PlatQual::PlatQual_Target; + } else { + platqual = ast::PlatQual::PlatQual_Solve; + } + } + + ast::IFunctionImportProto *func = m_factory->mkFunctionImportProto( + platqual, + "", + mkFunctionPrototype(ctx->function_prototype()) + ); + + + addChild(func, ctx->start); + } + DEBUG_LEAVE("visitImport_function"); + return 0; +} + // B.7 Procedural Statements antlrcpp::Any AstBuilderInt::visitProcedural_sequence_block_stmt(PSSParser::Procedural_sequence_block_stmtContext *ctx) { DEBUG_ENTER("visitProcedural_sequence_block_stmt"); @@ -1274,7 +1322,7 @@ antlrcpp::Any AstBuilderInt::visitForeach_constraint_item(PSSParser::Foreach_con m_constraint = c; if (m_constraint_s.size() > 0) { - m_constraint_s.back()->getConstraints().push_back(ast::IConstraintScopeUP(c)); + m_constraint_s.back()->getConstraints().push_back(ast::IConstraintStmtUP(c)); } DEBUG_LEAVE("visitForeach_constraint_item"); return 0; @@ -1552,9 +1600,132 @@ antlrcpp::Any AstBuilderInt::visitType_identifier(PSSParser::Type_identifierCont // B.19 Numbers antlrcpp::Any AstBuilderInt::visitNumber(PSSParser::NumberContext *ctx) { - DEBUG_ENTER("visitNumber"); - DEBUG("TODO: Number"); - m_expr = m_factory->mkExprSignedNumber("0", 0, 0); + DEBUG_ENTER("visitNumber %s", ctx->getText().c_str()); + uint64_t value; + bool is_signed = false; + int32_t width = 32; + std::string img; + if (ctx->based_hex_number()) { + DEBUG("Based hex number"); + if (ctx->based_hex_number()->DEC_LITERAL()) { + // Explicit width + width = strtoul( + ctx->based_hex_number()->DEC_LITERAL()->getSymbol()->getText().c_str(), 0, 10); + } + img = ctx->based_hex_number()->BASED_HEX_LITERAL()->getSymbol()->getText(); + std::string val_t; + is_signed = (img[1] == 's' || img[1] == 'S'); + + for (uint32_t i=2+is_signed; ibased_oct_number()) { + DEBUG("Based oct number"); + if (ctx->based_oct_number()->DEC_LITERAL()) { + // Explicit width + width = strtoul( + ctx->based_oct_number()->DEC_LITERAL()->getSymbol()->getText().c_str(), 0, 10); + } + img = ctx->based_oct_number()->BASED_OCT_LITERAL()->getSymbol()->getText(); + std::string val_t; + is_signed = (img[1] == 's' || img[1] == 'S'); + + for (uint32_t i=2+is_signed; ibased_dec_number()) { + DEBUG("Based dec number"); + if (ctx->based_dec_number()->DEC_LITERAL()) { + // Explicit width + width = strtoul( + ctx->based_dec_number()->DEC_LITERAL()->getSymbol()->getText().c_str(), 0, 10); + } + img = ctx->based_dec_number()->BASED_DEC_LITERAL()->getSymbol()->getText(); + std::string val_t; + is_signed = (img[1] == 's' || img[1] == 'S'); + + for (uint32_t i=2+is_signed; ibased_bin_number()) { + DEBUG("Based bin number"); + if (ctx->based_bin_number()->DEC_LITERAL()) { + // Explicit width + width = strtoul( + ctx->based_bin_number()->DEC_LITERAL()->getSymbol()->getText().c_str(), 0, 10); + } + img = ctx->based_bin_number()->BASED_BIN_LITERAL()->getSymbol()->getText(); + std::string val_t; + is_signed = (img[1] == 's' || img[1] == 'S'); + + for (uint32_t i=2+is_signed; ihex_number()) { + DEBUG("Unbased hex number"); + img = ctx->hex_number()->HEX_LITERAL()->getSymbol()->getText(); + std::string val_t; + + for (uint32_t i=2; idec_number()) { + DEBUG("Unbased dec number"); + img = ctx->dec_number()->DEC_LITERAL()->getSymbol()->getText(); + std::string val_t; + + for (uint32_t i=0; ioct_number()) { + DEBUG("Unbased oct number"); + img = ctx->oct_number()->OCT_LITERAL()->getSymbol()->getText(); + std::string val_t; + + if (img.size() > 1) { + for (uint32_t i=1; imkExprSignedNumber(img, width, value); + } else { + m_expr = m_factory->mkExprUnsignedNumber(img, width, value); + } DEBUG_LEAVE("visitNumber"); @@ -1623,6 +1794,7 @@ void AstBuilderInt::addChild(ast::IConstraintScope *c, Token *start, Token *end) (int32_t)end->getLine(), (int32_t)end->getCharPositionInLine()+1 }); + c->setParent(scope()); scope()->getChildren().push_back(ast::IScopeChildUP(c)); if (m_collectDocStrings && start) { @@ -1641,6 +1813,7 @@ void AstBuilderInt::addChild(ast::IExecScope *c, Token *start, Token *end) { (int32_t)end->getLine(), (int32_t)end->getCharPositionInLine()+1 }); + c->setParent(scope()); scope()->getChildren().push_back(ast::IScopeChildUP(c)); if (m_collectDocStrings && start) { @@ -1659,6 +1832,7 @@ void AstBuilderInt::addChild(ast::IFunctionDefinition *c, Token *start, Token *e (int32_t)end->getLine(), (int32_t)end->getCharPositionInLine()+1 }); + c->setParent(scope()); scope()->getChildren().push_back(ast::IScopeChildUP(c)); if (m_collectDocStrings && start) { @@ -1677,6 +1851,7 @@ void AstBuilderInt::addChild(ast::INamedScope *c, Token *start, Token *end) { (int32_t)end->getLine(), (int32_t)end->getCharPositionInLine()+1 }); + c->setParent(scope()); scope()->getChildren().push_back(ast::IScopeChildUP(c)); if (m_collectDocStrings && start) { @@ -1695,6 +1870,7 @@ void AstBuilderInt::addChild(ast::IScope *c, Token *start, Token *end) { (int32_t)end->getLine(), (int32_t)end->getCharPositionInLine() }); + c->setParent(scope()); scope()->getChildren().push_back(ast::IScopeChildUP(c)); if (m_collectDocStrings && start) { @@ -1994,9 +2170,14 @@ ast::IFunctionPrototype *AstBuilderInt::mkFunctionPrototype( rtype = mkDataType(ctx->function_return_type()->data_type()); } + bool is_target = false; + bool is_solve = false; + ast::IFunctionPrototype *proto = m_factory->mkFunctionPrototype( mkId(ctx->function_identifier()->identifier()), - rtype); + rtype, + is_target, + is_solve); std::vector items = ctx->function_parameter_list_prototype()->function_parameter(); diff --git a/src/AstBuilderInt.h b/src/AstBuilderInt.h index e6511d5..cfadfcd 100644 --- a/src/AstBuilderInt.h +++ b/src/AstBuilderInt.h @@ -105,6 +105,8 @@ class AstBuilderInt : virtual antlrcpp::Any visitFunction_prototype(PSSParser::Function_prototypeContext *ctx) override; + virtual antlrcpp::Any visitImport_function(PSSParser::Import_functionContext *ctx) override; + // B.7 Procedural Statements virtual antlrcpp::Any visitProcedural_sequence_block_stmt(PSSParser::Procedural_sequence_block_stmtContext *ctx) override; diff --git a/src/AstSymbolTableIterator.cpp b/src/AstSymbolTableIterator.cpp index 6851612..462b578 100644 --- a/src/AstSymbolTableIterator.cpp +++ b/src/AstSymbolTableIterator.cpp @@ -84,7 +84,11 @@ ast::ISymbolRefPath *AstSymbolTableIterator::getScopeSymbolPath(int32_t off) con ast::ISymbolRefPath *ret = m_factory->mkSymbolRefPath(); for (int32_t i=0; i<(m_path.size()-off); i++) { - ret->getPath().push_back(m_path.at(i)); + if (m_path.at(i).idx >= 0) { + ret->getPath().push_back(m_path.at(i)); + } else { + DEBUG("NOTE: skip index %d with idx %d", i, m_path.at(i).idx); + } } return ret; diff --git a/src/MarkerCollector.cpp b/src/MarkerCollector.cpp index 2b9cf86..6f9e93d 100644 --- a/src/MarkerCollector.cpp +++ b/src/MarkerCollector.cpp @@ -22,6 +22,7 @@ MarkerCollector::~MarkerCollector() { } void MarkerCollector::marker(const IMarker *m) { + fprintf(stderr, "NOTE: Add marker \"%s\" with level %d\n", m->msg().c_str(), m->severity()); m_markers.push_back(IMarkerUP(m->clone())); m_count[static_cast(m->severity())]++; } diff --git a/src/RefExprUtil.cpp b/src/RefExprUtil.cpp index 9f74965..61e1fb9 100644 --- a/src/RefExprUtil.cpp +++ b/src/RefExprUtil.cpp @@ -20,6 +20,7 @@ RefExprUtil::~RefExprUtil() { // TODO Auto-generated destructor stub } +#ifdef UNDEFINED ast::IRefExprTypeScopeGlobalSP RefExprUtil::mkTypeScopeGlobal(int32_t fileid) { /* return ast::IRefExprTypeScopeGlobalSP(new ast::IRefExprTypeScopeGlobal(fileid)); @@ -31,6 +32,7 @@ ast::IRefExprScopeIndexSP RefExprUtil::mkScopeIndex(ast::IRefExprSP base, int32_ // return ast::IRefExprScopeIndexSP(new ast::IRefExprScopeIndex(base, index)); return ast::IRefExprScopeIndexSP(0); } +#endif } } /* namespace zsp */ diff --git a/src/RefExprUtil.h b/src/RefExprUtil.h index 1b5441c..848c185 100644 --- a/src/RefExprUtil.h +++ b/src/RefExprUtil.h @@ -20,9 +20,9 @@ class RefExprUtil { virtual ~RefExprUtil(); - static ast::IRefExprTypeScopeGlobalSP mkTypeScopeGlobal(int32_t fileid); +// static ast::IRefExprTypeScopeGlobalSP mkTypeScopeGlobal(int32_t fileid); - static ast::IRefExprScopeIndexSP mkScopeIndex(ast::IRefExprSP base, int32_t index); +// static ast::IRefExprScopeIndexSP mkScopeIndex(ast::IRefExprSP base, int32_t index); }; } diff --git a/src/TaskBuildParamValList.cpp b/src/TaskBuildParamValList.cpp index 16e3533..b23bd5c 100644 --- a/src/TaskBuildParamValList.cpp +++ b/src/TaskBuildParamValList.cpp @@ -47,7 +47,7 @@ ast::ITemplateParamDeclList *TaskBuildParamValList::build( DEBUG_ENTER("build plist=%d n_pvals=%d", plist->getChildren().size(), pvals->getValues().size()); - TaskCopyAst copier(m_factory->getAstFactory()); + TaskCopyAst copier(m_factory); m_ret = 0; if (pvals->getValues().size() > plist->getChildren().size()) { @@ -141,6 +141,7 @@ ast::ITemplateParamDeclList *TaskBuildParamValList::build( m_ptype_generic_type = 0; m_ptype_category_type = 0; + // Get the default value plist->getChildren().at(plist_idx)->accept(m_this); ast::IExprId *name = 0; diff --git a/src/TaskBuildSymbolTree.cpp b/src/TaskBuildSymbolTree.cpp index 5ad8433..8dee064 100644 --- a/src/TaskBuildSymbolTree.cpp +++ b/src/TaskBuildSymbolTree.cpp @@ -89,6 +89,18 @@ ast::ISymbolTypeScope *TaskBuildSymbolTree::build(ast::ITypeScope *ts) { return ret; } +void TaskBuildSymbolTree::visitConstraintBlock(ast::IConstraintBlock *i) { + DEBUG_ENTER("visitConstraintBlock"); + m_scope_s.back()->getChildren().push_back(i); + DEBUG_LEAVE("visitConstraintBlock"); +} + +void TaskBuildSymbolTree::visitConstraintStmt(ast::IConstraintStmt *i) { + DEBUG_ENTER("visitConstraintStmt"); + m_scope_s.back()->getChildren().push_back(i); + DEBUG_LEAVE("visitConstraintStmt"); +} + void TaskBuildSymbolTree::visitPackageScope(ast::IPackageScope *i) { DEBUG_ENTER("visitPackageScope"); for (std::vector::const_iterator @@ -110,11 +122,13 @@ void TaskBuildSymbolTree::visitPackageScope(ast::IPackageScope *i) { scope->getSymtab().insert({(*id_it)->getId(), id}); scope->getChildren().push_back(pkg); scope->getOwned().push_back(ast::IScopeChildUP(pkg)); + pkg->setUpper(m_scope_s.back()); m_scope_s.push_back(pkg); scope = pkg; } else { ast::ISymbolScope *new_scope = dynamic_cast(scope->getChildren().at(p_it->second)); + new_scope->setUpper(m_scope_s.back()); m_scope_s.push_back(new_scope); scope = new_scope; } @@ -157,6 +171,7 @@ void TaskBuildSymbolTree::visitEnumDecl(ast::IEnumDecl *i) { scope->getChildren().push_back(ts); scope->getOwned().push_back(ast::IScopeChildUP(ts)); + ts->setUpper(m_scope_s.back()); m_scope_s.push_back(ts); for (std::vector::const_iterator it=i->getItems().begin(); @@ -194,13 +209,21 @@ void TaskBuildSymbolTree::visitExecStmt(ast::IExecStmt *i) { DEBUG_LEAVE("visitExecStmt"); } +void TaskBuildSymbolTree::visitExecBlock(ast::IExecBlock *i) { + DEBUG_ENTER("visitExecBlock"); + visitExecScope(i); + DEBUG_LEAVE("visitExecBlock"); +} + void TaskBuildSymbolTree::visitExecScope(ast::IExecScope *i) { DEBUG_ENTER("visitExecScope"); int32_t id = m_scope_s.back()->getChildren().size(); ast::ISymbolScope *scope = m_factory->mkSymbolExecScope(id, ""); scope->setLocation(i->getLocation()); + scope->setTarget(i); m_scope_s.back()->getChildren().push_back(scope); m_scope_s.back()->getOwned().push_back(ast::IScopeChildUP(scope)); + scope->setUpper(m_scope_s.back()); m_scope_s.push_back(scope); for (std::vector::const_iterator it=i->getChildren().begin(); @@ -222,6 +245,7 @@ void TaskBuildSymbolTree::visitExtendType(ast::IExtendType *i) { m_scope_s.back()->getOwned().push_back(ast::IScopeChildUP(ext)); m_scope_s.back()->getChildren().push_back(ext); + ext->setUpper(m_scope_s.back()); m_scope_s.push_back(ext); for (std::vector::const_iterator it=i->getChildren().begin(); @@ -292,6 +316,7 @@ void TaskBuildSymbolTree::visitFunctionDefinition(ast::IFunctionDefinition *i) { id, i->getProto()->getName()->getId()); func_sym->setLocation(i->getLocation()); + func_sym->setUpper(m_scope_s.back()); m_scope_s.back()->getSymtab().insert({func_sym->getName(), id}); m_scope_s.back()->getChildren().push_back(func_sym); @@ -324,6 +349,7 @@ void TaskBuildSymbolTree::visitFunctionDefinition(ast::IFunctionDefinition *i) { int32_t id = func_sym->getChildren().size(); ast::ISymbolScope *body = m_factory->mkSymbolScope(id, ""); body->setLocation(i->getLocation()); + body->setUpper(m_scope_s.back()); m_scope_s.push_back(body); func_sym->setBody(body); func_sym->getChildren().push_back(body); @@ -340,11 +366,69 @@ void TaskBuildSymbolTree::visitFunctionDefinition(ast::IFunctionDefinition *i) { } void TaskBuildSymbolTree::visitFunctionImportProto(ast::IFunctionImportProto *i) { + DEBUG_ENTER("visitFunctionImportProto %s", i->getProto()->getName()->getId().c_str()); + ast::IScopeChild *ex_func_b = findSymbol(i->getProto()->getName()->getId()); + ast::ISymbolFunctionScope *func_sym = dynamic_cast(ex_func_b); + + // If the existing symbol isn't a FunctionScope, then we have + // a duplicate symbol + if (ex_func_b && !func_sym) { + reportDuplicateSymbol(m_scope_s.back(), ex_func_b, i); + return; + } + + // Otherwise, we need to create + if (!func_sym) { + int32_t id = m_scope_s.back()->getChildren().size(); + func_sym = m_factory->mkSymbolFunctionScope( + id, + i->getProto()->getName()->getId()); + func_sym->setLocation(i->getLocation()); + m_scope_s.back()->getSymtab().insert({func_sym->getName(), id}); + m_scope_s.back()->getChildren().push_back(func_sym); + + // Add parameters to the function symbol scope + for (std::vector::const_iterator + it=i->getProto()->getParameters().begin(); + it!=i->getProto()->getParameters().end(); it++) { + id = func_sym->getChildren().size(); + std::map::const_iterator sym_it = + func_sym->getSymtab().find((*it)->getName()->getId()); + + if (sym_it != func_sym->getSymtab().end()) { + // Duplicate + reportDuplicateSymbol( + func_sym, + func_sym->getChildren().at(sym_it->second), + it->get()); + } else { + func_sym->getSymtab().insert({(*it)->getName()->getId(), id}); + func_sym->getChildren().push_back(it->get()); + } + } + } + + if (func_sym->getDefinition()) { + // TODO: Cannot both define and import an implementation + } + + i->getProto()->accept(m_this); + + if (i->getPlat() == ast::PlatQual::PlatQual_Solve) { + i->getProto()->setIs_solve(true); + } + if (i->getPlat() == ast::PlatQual::PlatQual_Target) { + i->getProto()->setIs_target(true); + } + + DEBUG_LEAVE("visitFunctionImportProto %s", i->getProto()->getName()->getId().c_str()); } void TaskBuildSymbolTree::visitFunctionImportType(ast::IFunctionImportType *i) { - + DEBUG_ENTER("visitFunctionImportType"); + DEBUG("TODO: visitFunctionImportType"); + DEBUG_LEAVE("visitFunctionImportType"); } void TaskBuildSymbolTree::visitFunctionPrototype(ast::IFunctionPrototype *i) { @@ -366,6 +450,7 @@ void TaskBuildSymbolTree::visitFunctionPrototype(ast::IFunctionPrototype *i) { id, i->getName()->getId()); func_sym->setLocation(i->getLocation()); + func_sym->setUpper(m_scope_s.back()); m_scope_s.back()->getSymtab().insert({func_sym->getName(), id}); m_scope_s.back()->getChildren().push_back(func_sym); } @@ -474,6 +559,7 @@ void TaskBuildSymbolTree::visitTypeScope(ast::ITypeScope *i) { scope->getChildren().push_back(ts); scope->getOwned().push_back(ast::IScopeChildUP(ts)); + ts->setUpper(m_scope_s.back()); m_scope_s.push_back(ts); for (std::vector::const_iterator it=i->getChildren().begin(); diff --git a/src/TaskBuildSymbolTree.h b/src/TaskBuildSymbolTree.h index 7aad94a..18a4e07 100644 --- a/src/TaskBuildSymbolTree.h +++ b/src/TaskBuildSymbolTree.h @@ -44,12 +44,18 @@ class TaskBuildSymbolTree : public virtual ast::VisitorBase { virtual void visitActivityDecl(ast::IActivityDecl *i) override; + virtual void visitConstraintBlock(ast::IConstraintBlock *i) override; + + virtual void visitConstraintStmt(ast::IConstraintStmt *i) override; + virtual void visitPackageScope(ast::IPackageScope *i) override; virtual void visitEnumDecl(ast::IEnumDecl *i) override; virtual void visitEnumItem(ast::IEnumItem *i) override; + virtual void visitExecBlock(ast::IExecBlock *i) override; + virtual void visitExecStmt(ast::IExecStmt *i) override; virtual void visitExecScope(ast::IExecScope *i) override; diff --git a/src/TaskExpr2DataType.cpp b/src/TaskExpr2DataType.cpp index b1c73ee..74a4a6f 100644 --- a/src/TaskExpr2DataType.cpp +++ b/src/TaskExpr2DataType.cpp @@ -73,7 +73,7 @@ void TaskExpr2DataType::visitExprRefPathContext(ast::IExprRefPathContext *i) { ast::ITypeIdentifier *tid = m_factory->getAstFactory()->mkTypeIdentifier(); tid->getElems().push_back(ast::ITypeIdentifierElemUP( m_factory->getAstFactory()->mkTypeIdentifierElem( - TaskCopyAst(m_factory->getAstFactory()).copyT( + TaskCopyAst(m_factory).copyT( i->getHier_id()->getElems().at(0)->getId() ), 0 @@ -91,7 +91,7 @@ void TaskExpr2DataType::visitExprRefPathId(ast::IExprRefPathId *i) { ast::ITypeIdentifier *tid = m_factory->getAstFactory()->mkTypeIdentifier(); tid->getElems().push_back(ast::ITypeIdentifierElemUP( m_factory->getAstFactory()->mkTypeIdentifierElem( - TaskCopyAst(m_factory->getAstFactory()).copyT(i->getId()), + TaskCopyAst(m_factory).copyT(i->getId()), 0 ))); m_ret = m_factory->getAstFactory()->mkDataTypeUserDefined( diff --git a/src/TaskGetSpecializedTemplateType.cpp b/src/TaskGetSpecializedTemplateType.cpp index 7ef88bf..5a087a2 100644 --- a/src/TaskGetSpecializedTemplateType.cpp +++ b/src/TaskGetSpecializedTemplateType.cpp @@ -64,6 +64,7 @@ ast::ISymbolRefPath *TaskGetSpecializedTemplateType::find( if (p_comp.equal(params, type_s_t->getParams())) { // Have a match! + DEBUG("Found plist match"); ret = m_factory->getAstFactory()->mkSymbolRefPath(); // Copy over initial path @@ -94,7 +95,7 @@ ast::ISymbolRefPath *TaskGetSpecializedTemplateType::mk( DEBUG("type_up=%s", type_up->getName().c_str()); fflush(stdout); - TaskCopyAst copier(m_factory->getAstFactory()); + TaskCopyAst copier(m_factory); ast::ITypeScope *type_s = copier.copyT(type_up->getTarget()); diff --git a/src/TaskResolveRef.cpp b/src/TaskResolveRef.cpp index 9991545..0cbfa01 100644 --- a/src/TaskResolveRef.cpp +++ b/src/TaskResolveRef.cpp @@ -82,6 +82,22 @@ ast::ISymbolRefPath *TaskResolveRef::resolve( return m_ref; } +void TaskResolveRef::visitExprId(ast::IExprId *i) { + DEBUG_ENTER("visitExprId %s", i->getId().c_str()); + ISymbolTableIterator *it = m_symtab_it_s.back().get(); + + ast::ISymbolRefPath *root = findRoot(it, i); + + m_ref = root; + DEBUG_LEAVE("visitExprId %s (%p)", i->getId().c_str(), m_ref); +} + +void TaskResolveRef::visitExprMemberPathElem(ast::IExprMemberPathElem *i) { + DEBUG_ENTER("visitExprMemberPathElem"); + DEBUG("TODO: visitExprMemberPathElem"); + DEBUG_LEAVE("visitExprMemberPathElem"); +} + void TaskResolveRef::visitExprRefPathStaticRooted(ast::IExprRefPathStaticRooted *i) { DEBUG_ENTER("visitExprRefPathStaticRooted"); DEBUG("TODO: visitExprRefPathStaticRooted"); diff --git a/src/TaskResolveRef.h b/src/TaskResolveRef.h index 5222403..b4fd941 100644 --- a/src/TaskResolveRef.h +++ b/src/TaskResolveRef.h @@ -47,6 +47,10 @@ class TaskResolveRef : public ast::VisitorBase { const ISymbolTableIterator *scope, ast::IExpr *ref); + virtual void visitExprId(ast::IExprId *i) override; + + virtual void visitExprMemberPathElem(ast::IExprMemberPathElem *i) override; + virtual void visitExprRefPathStaticRooted(ast::IExprRefPathStaticRooted *i) override; virtual void visitExprRefPathId(ast::IExprRefPathId *i) override; diff --git a/src/TaskResolveRefs.cpp b/src/TaskResolveRefs.cpp index 8b0f65a..2446f68 100644 --- a/src/TaskResolveRefs.cpp +++ b/src/TaskResolveRefs.cpp @@ -23,6 +23,8 @@ #include "TaskResolveImports.h" #include "TaskResolveRef.h" #include "TaskResolveRefs.h" +#include "zsp/parser/impl/TaskResolveSymbolPathRef.h" +#include "zsp/parser/impl/TaskGetElemSymbolScope.h" namespace zsp { namespace parser { @@ -126,22 +128,65 @@ void TaskResolveRefs::visitActivityActionHandleTraversal(ast::IActivityActionHan void TaskResolveRefs::visitActivityActionTypeTraversal(ast::IActivityActionTypeTraversal *i) { DEBUG_ENTER("visitActivityActionTypeTraversal"); - DEBUG("TODO: visitActivityActionTypeTraversal"); + i->getTarget()->accept(m_this); DEBUG_LEAVE("visitActivityActionTypeTraversal"); } void TaskResolveRefs::visitExprRefPathContext(ast::IExprRefPathContext *i) { - DEBUG_ENTER("visitExprRefPathContext"); + DEBUG_ENTER("visitExprRefPathContext %s", i->getHier_id()->getElems().at(0)->getId()->getId().c_str()); // Find the first path element ast::ISymbolRefPath *target = TaskResolveRef(m_root, m_factory, m_marker_l).resolve( m_symtab_it.get(), i->getHier_id()->getElems().at(0)->getId()); - + + if (!target) { + char tmp[1024]; + sprintf(tmp, "failed to find root ref-path element %s", + i->getHier_id()->getElems().at(0)->getId()->getId().c_str()); + IMarkerUP marker(m_factory->mkMarker( + tmp, + MarkerSeverityE::Error, + i->getHier_id()->getElems().at(0)->getId()->getLocation() + )); + m_marker_l->marker(marker.get()); + + DEBUG_LEAVE("visitExprRefPathContext -- fail"); + return; + } + + // Set root reference i->setTarget(target); - if (i->getHier_id()->getElems().at(0)->getParams()) { - i->getHier_id()->getElems().at(0)->getParams()->accept(m_this); + ast::IScopeChild *target_c = TaskResolveSymbolPathRef(m_dmgr, m_root).resolve(target); + ast::ISymbolScope *target_s = TaskGetElemSymbolScope(m_dmgr, m_root).resolve(target_c); + + // Target already points to the first elem + i->getHier_id()->getElems().at(0)->setTarget(-1); + + for (uint32_t ii=1; iigetHier_id()->getElems().size(); ii++) { + ast::IExprMemberPathElem *elem = i->getHier_id()->getElems().at(ii).get(); + std::map::const_iterator it = + target_s->getSymtab().find(elem->getId()->getId()); + + if (it == target_s->getSymtab().end()) { + DEBUG("ERROR: Failed to find elem %s", elem->getId()->getId().c_str()); + break; + } else { + DEBUG("NOTE: Found sub-element %s", elem->getId()->getId().c_str()); + elem->setTarget(it->second); + + // Resolve name references for parameter values + if (elem->getParams()) { + elem->getParams()->accept(m_this); + } + + if (ii+1 < i->getHier_id()->getElems().size()) { + target_c = target_s->getChildren().at(it->second); + target_s = TaskGetElemSymbolScope(m_dmgr, m_root).resolve(target_c); + } + } } + DEBUG_LEAVE("visitExprRefPathContext"); } @@ -183,6 +228,21 @@ void TaskResolveRefs::visitFieldCompRef(ast::IFieldCompRef *i) { DEBUG_LEAVE("visitFieldCompRef"); } +void TaskResolveRefs::visitFunctionPrototype(ast::IFunctionPrototype *i) { + DEBUG_ENTER("visitFunctionPrototype"); + + if (i->getRtype()) { + i->getRtype()->accept(m_this); + } + + for (std::vector::const_iterator + it=i->getParameters().begin(); + it!=i->getParameters().end(); it++) { + (*it)->getType()->accept(m_this); + } + DEBUG_LEAVE("visitFunctionPrototype"); +} + void TaskResolveRefs::visitSymbolScope(ast::ISymbolScope *i) { DEBUG_ENTER("visitSymbolScope \"%s\"", i->getName().c_str()); if (i->getName() != "") { @@ -248,16 +308,30 @@ void TaskResolveRefs::visitSymbolExecScope(ast::ISymbolExecScope *i) { } void TaskResolveRefs::visitSymbolFunctionScope(ast::ISymbolFunctionScope *i) { - DEBUG_ENTER("visitSymbolFunctionScope %s", i->getName().c_str()); - m_symtab_it->pushScope(i); - m_symtab_it->pushScope(i->getBody()); - for (std::vector::const_iterator - it=i->getBody()->getChildren().begin(); - it!=i->getBody()->getChildren().end(); it++) { + DEBUG_ENTER("visitSymbolFunctionScope %s (%d)", + i->getName().c_str(), + i->getPrototypes().size()); + + + for (std::vector::const_iterator + it=i->getPrototypes().begin(); + it!=i->getPrototypes().end(); it++) { (*it)->accept(m_this); } - m_symtab_it->popScope(); - m_symtab_it->popScope(); + + if (i->getBody()) { + m_symtab_it->pushScope(i); + m_symtab_it->pushScope(i->getBody()); + for (std::vector::const_iterator + it=i->getBody()->getChildren().begin(); + it!=i->getBody()->getChildren().end(); it++) { + (*it)->accept(m_this); + } + m_symtab_it->popScope(); + m_symtab_it->popScope(); + } + + DEBUG_LEAVE("visitSymbolFunctionScope %s", i->getName().c_str()); } diff --git a/src/TaskResolveRefs.h b/src/TaskResolveRefs.h index 17a93fd..f371fb2 100644 --- a/src/TaskResolveRefs.h +++ b/src/TaskResolveRefs.h @@ -62,6 +62,8 @@ class TaskResolveRefs : public ast::VisitorBase { virtual void visitFieldCompRef(ast::IFieldCompRef *i) override; + virtual void visitFunctionPrototype(ast::IFunctionPrototype *i) override; + virtual void visitSymbolScope(ast::ISymbolScope *i) override; virtual void visitSymbolExtendScope(ast::ISymbolExtendScope *i) override; diff --git a/src/include/zsp/parser/impl/TaskCopyAst.h b/src/include/zsp/parser/impl/TaskCopyAst.h index ee1dd18..6fa9029 100644 --- a/src/include/zsp/parser/impl/TaskCopyAst.h +++ b/src/include/zsp/parser/impl/TaskCopyAst.h @@ -19,20 +19,28 @@ * Author: */ #pragma once +#include "dmgr/IDebugMgr.h" +#include "dmgr/impl/DebugMacros.h" #include "zsp/ast/impl/VisitorBase.h" #include "zsp/ast/IExprRefPathStatic.h" #include "zsp/ast/IFactory.h" +#include "zsp/ast/IFunctionPrototype.h" +#include "zsp/parser/IFactory.h" namespace zsp { namespace parser { class TaskCopyAst : public ast::VisitorBase { public: - TaskCopyAst(ast::IFactory *factory) : m_factory(factory) { } + TaskCopyAst(IFactory *factory) : + m_factory(factory->getAstFactory()), m_dbg(0) { + DEBUG_INIT("zsp::parser::TaskCopyAst", factory->getDebugMgr()); + } virtual ~TaskCopyAst() { } ast::IConstraintStmt *copy(ast::IConstraintStmt *i) { + DEBUG_ENTER("copy(IConstraintStmt)"); m_constraint = 0; i->accept(m_this); @@ -40,6 +48,7 @@ class TaskCopyAst : public ast::VisitorBase { fprintf(stdout, "Error: copy(constraint) failed\n"); fflush(stdout); } + DEBUG_LEAVE("copy(IConstraintStmt)"); return m_constraint; } @@ -53,12 +62,14 @@ class TaskCopyAst : public ast::VisitorBase { } ast::IScopeChild *copy(ast::IScopeChild *i) { + DEBUG_ENTER("copy(IScopeChild)"); m_sc = 0; i->accept(m_this); if (!m_sc) { fprintf(stdout, "Error: copy(ScopeChild) failed\n"); fflush(stdout); } + DEBUG_LEAVE("copy(IScopeChild)"); return m_sc; }; @@ -72,12 +83,14 @@ class TaskCopyAst : public ast::VisitorBase { } ast::IExpr *copy(ast::IExpr *i) { + DEBUG_ENTER("copy(IExpr)"); m_expr = 0; i->accept(m_this); if (!m_expr) { fprintf(stdout, "Error: copy(Expr) failed\n"); fflush(stdout); } + DEBUG_LEAVE("copy(IExpr)"); return m_expr; }; @@ -91,12 +104,14 @@ class TaskCopyAst : public ast::VisitorBase { } ast::IDataType *copy(ast::IDataType *i) { + DEBUG_ENTER("copy(IDataType)"); m_dt = 0; i->accept(m_this); if (!m_dt) { fprintf(stdout, "Error: copy(DataType) failed\n"); fflush(stdout); } + DEBUG_LEAVE("copy(IDataType)"); return m_dt; } @@ -197,7 +212,17 @@ class TaskCopyAst : public ast::VisitorBase { virtual void visitPackageImportStmt(ast::IPackageImportStmt *i) { } - virtual void visitFunctionParamDecl(ast::IFunctionParamDecl *i) { } + virtual void visitFunctionParamDecl(ast::IFunctionParamDecl *i) override { + ast::IFunctionParamDecl *ic = m_factory->mkFunctionParamDecl( + i->getKind(), + copyT(i->getName()), + copy(i->getType()), + i->getDir(), + (i->getDflt())?copy(i->getDflt()):0 + ); + ic->setIs_varargs(i->getIs_varargs()); + m_sc = ic; + } virtual void visitFunctionImport(ast::IFunctionImport *i) { } @@ -394,7 +419,22 @@ class TaskCopyAst : public ast::VisitorBase { virtual void visitPackageScope(ast::IPackageScope *i) { } - virtual void visitFunctionPrototype(ast::IFunctionPrototype *i) { } + virtual void visitFunctionPrototype(ast::IFunctionPrototype *i) override { + ast::IFunctionPrototype *ic = m_factory->mkFunctionPrototype( + copyT(i->getName()), + (i->getRtype())?copy(i->getRtype()):0, + i->getIs_target(), + i->getIs_solve()); + ic->setIs_pure(i->getIs_pure()); + for (std::vector::const_iterator + it=i->getParameters().begin(); + it!=i->getParameters().end(); it++) { + ic->getParameters().push_back( + ast::IFunctionParamDeclUP(copyT(it->get()))); + } + + m_sc = ic; + } virtual void visitFunctionImportType(ast::IFunctionImportType *i) { } @@ -631,8 +671,12 @@ class TaskCopyAst : public ast::VisitorBase { m_sc = ic; } + + + private: ast::IFactory *m_factory; + dmgr::IDebug *m_dbg; ast::IConstraintStmt *m_constraint; ast::IDataType *m_dt; diff --git a/src/include/zsp/parser/impl/TaskGetElemSymbolScope.h b/src/include/zsp/parser/impl/TaskGetElemSymbolScope.h new file mode 100644 index 0000000..280ded8 --- /dev/null +++ b/src/include/zsp/parser/impl/TaskGetElemSymbolScope.h @@ -0,0 +1,77 @@ +/** + * TaskGetElemSymbolScope.h + * + * Copyright 2023 Matthew Ballance and Contributors + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * Created on: + * Author: + */ +#pragma once +#include "dmgr/IDebugMgr.h" +#include "dmgr/impl/DebugMacros.h" +#include "zsp/ast/impl/VisitorBase.h" +#include "TaskResolveSymbolPathRef.h" + +namespace zsp { +namespace parser { + +class TaskGetElemSymbolScope : public virtual ast::VisitorBase { +public: + TaskGetElemSymbolScope( + dmgr::IDebugMgr *dmgr, + ast::ISymbolScope *root) : + m_dbg(0), m_path_resolver(dmgr, root) { + DEBUG_INIT("zsp::parser::TaskGetElemSymbolScope", dmgr); + } + + virtual ~TaskGetElemSymbolScope() { } + + ast::ISymbolScope *resolve(ast::IScopeChild *c) { + m_ret = 0; + c->accept(m_this); + return m_ret; + } + + virtual void visitField(ast::IField *i) override { + DEBUG_ENTER("visitField %s", i->getName()->getId().c_str()); + i->getType()->accept(m_this); + DEBUG_LEAVE("visitField %s", i->getName()->getId().c_str()); + } + + virtual void visitDataTypeUserDefined(ast::IDataTypeUserDefined *i) override { + DEBUG_ENTER("visitDataTypeUserDefined"); + ast::IScopeChild *c = m_path_resolver.resolve(i->getType_id()->getTarget()); + m_ret = dynamic_cast(c); + DEBUG_LEAVE("visitDataTypeUserDefined"); + } + + virtual void visitTypeIdentifier(ast::ITypeIdentifier *i) override { + DEBUG_ENTER("visitTypeIdentifier"); + ast::IScopeChild *c = m_path_resolver.resolve(i->getTarget()); + m_ret = dynamic_cast(c); + DEBUG_LEAVE("visitTypeIdentifier"); + } + +protected: + dmgr::IDebug *m_dbg; + TaskResolveSymbolPathRef m_path_resolver; + ast::ISymbolScope *m_ret; + +}; + +} +} + + diff --git a/src/include/zsp/parser/impl/TaskGetName.h b/src/include/zsp/parser/impl/TaskGetName.h index fc8f3af..649e758 100644 --- a/src/include/zsp/parser/impl/TaskGetName.h +++ b/src/include/zsp/parser/impl/TaskGetName.h @@ -31,9 +31,48 @@ class TaskGetName : public virtual ast::VisitorBase { virtual ~TaskGetName() { } - const std::string &get(ast::IScopeChild *c) { + const std::string &get(ast::IScopeChild *c, bool bottom_up=false) { m_ret = ""; - c->accept(m_this); + if (bottom_up) { + + m_sym_s = 0; + c->accept(m_this); + std::string full_path; + + if (m_sym_s) { + // This is a symbol scope + ast::ISymbolScope *ss = m_sym_s; + + full_path = m_ret; + + while ((ss=ss->getUpper())) { + m_ret = ""; + ss->accept(m_this); + + if (full_path.size() && m_ret.size()) { + full_path = "::" + full_path; + } + full_path = m_ret + full_path; + } + + m_ret = full_path; + } else { + ast::IScopeChild *ci = c; + do { + m_ret = ""; + ci->accept(m_this); + + if (full_path.size() && m_ret.size()) { + full_path = "::" + full_path; + } + full_path = m_ret + full_path; + } while ((ci=ci->getParent())); + + m_ret = full_path; + } + } else { + c->accept(m_this); + } return m_ret; } @@ -47,14 +86,17 @@ class TaskGetName : public virtual ast::VisitorBase { virtual void visitSymbolScope(ast::ISymbolScope *i) override { m_ret = i->getName(); + m_sym_s = i; } virtual void visitSymbolTypeScope(ast::ISymbolTypeScope *i) override { m_ret = i->getName(); + m_sym_s = i; } private: std::string m_ret; + ast::ISymbolScope *m_sym_s; }; } diff --git a/src/stdlib/addr_reg_pkg.pss b/src/stdlib/addr_reg_pkg.pss index 7591f5c..1c3c347 100644 --- a/src/stdlib/addr_reg_pkg.pss +++ b/src/stdlib/addr_reg_pkg.pss @@ -93,47 +93,56 @@ function void write8 (addr_handle_t hndl, bit[8] data); function void write16(addr_handle_t hndl, bit[16] data); function void write32(addr_handle_t hndl, bit[32] data); function void write64(addr_handle_t hndl, bit[64] data); +/* TODO: generic type function void read_bytes (addr_handle_t hndl, list data, int size); function void write_bytes(addr_handle_t hndl, list data); function void read_struct (addr_handle_t hndl, struct packed_struct); function void write_struct(addr_handle_t hndl, struct packed_struct); + */ extend component executor_base_c { - function bit[8] read8(addr_handle_t hndl); - function bit[16] read16(addr_handle_t hndl); - function bit[32] read32(addr_handle_t hndl); - function bit[64] read64(addr_handle_t hndl); - function void write8 (addr_handle_t hndl, bit[8] data); - function void write16(addr_handle_t hndl, bit[16] data); - function void write32(addr_handle_t hndl, bit[32] data); - function void write64(addr_handle_t hndl, bit[64] data); + function bit[8] read8(addr_handle_t hndl); + function bit[16] read16(addr_handle_t hndl); + function bit[32] read32(addr_handle_t hndl); + function bit[64] read64(addr_handle_t hndl); + function void write8 (addr_handle_t hndl, bit[8] data); + function void write16(addr_handle_t hndl, bit[16] data); + function void write32(addr_handle_t hndl, bit[32] data); + function void write64(addr_handle_t hndl, bit[64] data); + /** TODO: list function void read_bytes (addr_handle_t hndl, list data, int size); function void write_bytes(addr_handle_t hndl, list data); + */ }; + enum reg_access {READWRITE, READONLY, WRITEONLY}; -pure component reg_c < type R, - reg_access ACC = READWRITE, -int SZ = (8*sizeof_s::nbytes)> { -function R read(); - import target function read; - function void write(R r); - import target function write; - function bit[SZ] read_val(); - import target function read_val; - function void write_val(bit[SZ] r); -import target function write_val; + +pure component reg_c < type R, reg_access ACC = READWRITE, int SZ = (8*sizeof_s::nbytes)> { + function R read(); + import target function read; + function void write(R r); + import target function write; + function bit[SZ] read_val(); + import target function read_val; + function void write_val(bit[SZ] r); + import target function write_val; }; + +/* struct node_s { string name; int index; }; + */ pure component reg_group_c { - pure function bit[64] get_offset_of_instance(string name); - pure function bit[64] get_offset_of_instance_array(string name, - int index); - pure function bit[64] get_offset_of_path(list path); - function void set_handle(addr_handle_t addr); - import solve function set_handle; + pure function bit[64] get_offset_of_instance(string name); + pure function bit[64] get_offset_of_instance_array(string name, int index); + /** TODO: list + pure function bit[64] get_offset_of_path(list path); + */ + function void set_handle(addr_handle_t addr); + import solve function set_handle; }; + } diff --git a/src/stdlib/executor_pkg.pss b/src/stdlib/executor_pkg.pss index 0e9de99..1a86ea1 100644 --- a/src/stdlib/executor_pkg.pss +++ b/src/stdlib/executor_pkg.pss @@ -1,5 +1,7 @@ package executor_pkg { + import addr_reg_pkg::*; + struct executor_trait_s {}; struct empty_executor_trait_s : executor_trait_s {};