expressir 0.2.7-x86-linux → 0.2.12-x86-linux

data/lib/expressir/express_exp/hyperlink_formatter.rb

@@ -0,0 +1,25 @@
+require "expressir/express_exp/formatter"
+
+module Expressir
+  module ExpressExp
+    class HyperlinkFormatter < Formatter
+      def format_expressions_simple_reference(node)
+        return node.id if node.parent.is_a? Model::Expressions::AttributeReference
+
+        # skip hyperlink if target node can't be found
+        target_node = node.find(node.id)
+        return node.id unless target_node
+
+        # skip hyperlink for implicit scopes
+        return node.id if target_node.is_a? Model::Statements::Alias or target_node.is_a? Model::Statements::Repeat or target_node.is_a? Model::Expressions::QueryExpression
+
+        # skip hyperlink if this node and target node are in the same main item
+        node_path_parts = node.path.split(".")
+        target_node_path_parts = target_node.path.split(".")
+        return node.id if node_path_parts[0..1] == target_node_path_parts[0..1]
+
+        "{{{<<express:#{target_node.path},#{node.id}>>}}}"
+      end
+    end
+  end
+end

data/lib/expressir/express_exp/parser.rb

@@ -9,7 +9,7 @@ require 'expressir/express_exp/visitor'
 module Expressir
   module ExpressExp
     class Parser
-      def self.from_exp(file)
+      def self.from_file(file)
         input = File.read(file)
 
 =begin
@@ -36,6 +36,19 @@ module Expressir
 
         repo
       end
+
+      def self.from_files(files)
+        schemas = files.map{|file| self.from_file(file).schemas}.flatten
+
+        Model::Repository.new({
+          schemas: schemas
+        })
+      end
+
+      # deprecated
+      def self.from_exp(file)
+        self.from_file(file)
+      end
     end
   end
 end

data/lib/expressir/express_exp/schema_head_formatter.rb

@@ -0,0 +1,14 @@
+require "expressir/express_exp/formatter"
+
+module Expressir
+  module ExpressExp
+    class SchemaHeadFormatter < Formatter
+      def format_schema(node)
+        [
+          "SCHEMA #{node.id}#{node.version ? " #{format(node.version)}" : ""};",
+          *node.interfaces.map{|x| format(x)}
+        ].join("\n")
+      end
+    end
+  end
+end

data/lib/expressir/express_exp/visitor.rb

@@ -5,10 +5,8 @@ rescue LoadError
   require_relative "express_parser"
 end
 require "expressir/model"
+require "set"
 
-# static shorthands are unwrapped
-# - entity attributes, function/procedure parameters, local variables
-#
 # reference type is not recognized
 # see note in A.1.5 Interpreted identifiers
 # > It is expected that identifiers matching these syntax rules are known to an implementation.
@@ -16,7 +14,7 @@ require "expressir/model"
 # > method of gaining this information is multi-pass parsing: the first pass collects the identifiers from their
 # > declarations, so that subsequent passes are then able to distinguish a veriable_ref from a function_ref,
 # > for example.
-#
+# - such multi-pass parsing is not implemented yet
 # - xxxRef - merged to SimpleReference
 # - entityConstructor, functionCall - merged to Call
 # 
@@ -25,6 +23,13 @@ require "expressir/model"
 # > A syntactic construct such as ARRAY[1:3] OF REAL satisfies two syntactic productions —
 # > aggregation_type and general_aggregation_type. It is considered to be instantiable no matter which
 # > production it is required to satisfy in the syntax.
+#
+# static shorthands are unwrapped
+# - entity attributes, function/procedure parameters, local variables
+#
+# all access to ctx members must happen before calling other visitor code
+# - prevents segfault in ANTLR4 C++ runtime, not sure why they are caused
+# - e.g. see visit_schema_decl
 
 module Expressir
   module ExpressExp
@@ -33,99 +38,148 @@ module Expressir
 
       def initialize(tokens)
         @tokens = tokens
-        @attached_remarks = Set.new
+        @attached_remark_tokens = ::Set.new
 
         super()
       end
 
       def visit(ctx)
-        result = super(ctx)
-        attach_source(ctx, result)
-        attach_parent(ctx, result)
-        attach_remarks(ctx, result)
-        result
+        node = super(ctx)
+        attach_source(ctx, node)
+        attach_remarks(ctx, node)
+        node
       end
 
-      def visit_if(ctx)
-        visit(ctx) if ctx
+      def visit_if(ctx, default = nil)
+        if ctx
+          visit(ctx)
+        else
+          default
+        end
       end
     
       def visit_if_map(ctx)
-        ctx.map{|ctx2| visit(ctx2)} if ctx
+        if ctx
+          ctx.map{|ctx2| visit(ctx2)}
+        else
+          []
+        end
       end
     
       def visit_if_map_flatten(ctx)
-        ctx.map{|ctx2| visit(ctx2)}.flatten if ctx
-      end
-
-      def attach_source(ctx, node)
-        if node.class.method_defined? :source
-          start_index, stop_index = [ctx.start.token_index, ctx.stop.token_index]
-          node.source = @tokens[start_index..stop_index].map{|x| x.text}.join('').force_encoding('UTF-8')
+        if ctx
+          ctx.map{|ctx2| visit(ctx2)}.flatten
+        else
+          []
         end
       end
 
-      def attach_parent(ctx, node)
-        if node.class.method_defined? :children
-          node.children.each do |child_node|
-            if child_node.class.method_defined? :parent
-              child_node.parent = node
-            end
-          end
+      def get_tokens_source(tokens)
+        if tokens.last.text == '<EOF>'
+          tokens.pop
         end
+
+        tokens.map{|x| x.text}.join('').force_encoding('UTF-8')
       end
 
-      def attach_remarks(ctx, node)
-        # get remark tokens
-        start_index, stop_index = if ctx.instance_of? ::ExpressParser::SyntaxContext
+      def get_tokens(ctx)
+        start_index, stop_index = if ctx.is_a? ::ExpressParser::SyntaxContext
           [0, @tokens.size - 1]
         else
           [ctx.start.token_index, ctx.stop.token_index]
         end
-        # puts [start_index, stop_index, ctx.class].inspect
-
-        remark_tokens = @tokens[start_index..stop_index].select{|x| x.channel == REMARK_CHANNEL}
-        if remark_tokens
-          remark_tokens.each do |remark_token|
-            remark_text = remark_token.text
-
-            # check if it is tagged remark
-            match = if remark_text.start_with?('--')
-              remark_text[2..-1].match(/^"([^"]*)"(.*)$/)
-            elsif remark_text.start_with?('(*') and remark_text.end_with?('*)')
-              remark_text[2..-3].match(/^"([^"]*)"(.*)$/m)
-            end
-            if !match
-              next
-            end
 
-            # don't attach already attached tagged remark
-            if @attached_remarks.include? remark_token
-              next
-            end
+        @tokens[start_index..stop_index]
+      end
 
-            # attach tagged remark
-            remark_tag = match[1]
-            remark_content = match[2].strip.force_encoding('UTF-8')
+      def get_head_tokens(ctx)
+        start_index, stop_index = if ctx.is_a? ::ExpressParser::SchemaDeclContext
+          start_index = ctx.start.token_index
+          stop_index = if ctx.schema_body.interface_specification.length > 0
+            ctx.schema_body.interface_specification.last.stop.token_index
+          elsif ctx.schema_version_id
+            ctx.schema_version_id.stop.token_index + 1
+          else
+            ctx.schema_id.stop.token_index + 1
+          end
 
-            target_node = nil
-            current_node = node
-            if current_node.class.method_defined? :find
-              target_node = current_node.find(remark_tag)
-            end
-            while !target_node and current_node.class.method_defined? :parent and current_node.parent.class.method_defined? :find
-              current_node = current_node.parent
-              target_node = current_node.find(remark_tag)
-            end
+          [start_index, stop_index]
+        end
 
-            if target_node
-              target_node.remarks ||= []
-              target_node.remarks << remark_content
+        if start_index and stop_index
+          @tokens[start_index..stop_index]
+        end
+      end
 
-              # mark remark as attached, so that it is not attached again at higher nesting level
-              @attached_remarks << remark_token
-            end
+      def attach_source(ctx, node)
+        if node.class.method_defined? :source
+          tokens = get_tokens(ctx)
+          node.source = get_tokens_source(tokens)
+        end
+
+        if node.class.method_defined? :head_source
+          tokens = get_head_tokens(ctx)
+          node.head_source = get_tokens_source(tokens)
+        end
+      end
+
+      def find_remark_target(node, path)
+        target_node = node.find(path)
+        return target_node if target_node
+
+        # check if path should create implicit informal proposal
+        # see https://github.com/lutaml/expressir/issues/50
+        rest, _, current_path = path.rpartition(".") # get last path part
+        _, _, current_path = current_path.rpartition(":") # ignore prefix
+
+        # match informal proposition id
+        informal_proposition_id = current_path.match(/^IP\d+$/).to_a[0]
+        return unless informal_proposition_id
+
+        # find informal proposition target
+        target_node = node.find(rest)
+        return unless target_node and target_node.class.method_defined? :informal_propositions
+
+        # create implicit informal proposition
+        informal_proposition = Model::InformalProposition.new({
+          id: informal_proposition_id
+        })
+        target_node.informal_propositions << informal_proposition
+        informal_proposition.parent = target_node
+        informal_proposition
+      end
+
+      def attach_remarks(ctx, node)
+        remark_tokens = get_tokens(ctx).select{|x| x.channel == REMARK_CHANNEL}
+
+        # skip already attached remarks
+        remark_tokens = remark_tokens.select{|x| !@attached_remark_tokens.include?(x)}
+
+        # parse remarks, find remark targets
+        tagged_remark_tokens = remark_tokens.map do |remark_token|
+          _, remark_tag, remark_text = if remark_token.text.start_with?('--')
+            remark_token.text.match(/^--"([^"]*)"(.*)$/).to_a
+          else
+            remark_token.text.match(/^\(\*"([^"]*)"(.*)\*\)$/m).to_a
+          end
+
+          if remark_tag
+            remark_target = find_remark_target(node, remark_tag)
+          end
+          if remark_text
+            remark_text = remark_text.strip.force_encoding('UTF-8')
           end
+
+          [remark_token, remark_target, remark_text]
+        end.select{|x| x[1]}
+
+        tagged_remark_tokens.each do |remark_token, remark_target, remark_text|
+          # attach remark
+          remark_target.remarks ||= []
+          remark_target.remarks << remark_text
+
+          # mark remark as attached, so that it is not attached again at higher nesting level
+          @attached_remark_tokens << remark_token
         end
       end
 
@@ -378,8 +432,8 @@ module Expressir
 
         bound1 = visit_if(ctx__bound_spec__bound1)
         bound2 = visit_if(ctx__bound_spec__bound2)
-        optional = !!ctx__OPTIONAL
-        unique = !!ctx__UNIQUE
+        optional = ctx__OPTIONAL && true
+        unique = ctx__UNIQUE && true
         base_type = visit_if(ctx__instantiable_type)
         
         Model::Types::Array.new({
@@ -463,7 +517,7 @@ module Expressir
         ctx__width_spec__FIXED = ctx__width_spec&.FIXED
 
         width = visit_if(ctx__width_spec__width)
-        fixed = !!ctx__width_spec__FIXED
+        fixed = ctx__width_spec__FIXED && true
 
         Model::Types::Binary.new({
           width: width,
@@ -715,16 +769,16 @@ module Expressir
         ctx__entity_body__where_clause = ctx__entity_body&.where_clause
 
         id = visit_if(ctx__entity_head__entity_id)
-        abstract = !!(ctx__entity_head__subsuper__supertype_constraint__abstract_entity_declaration || ctx__entity_head__subsuper__supertype_constraint__abstract_supertype_declaration)
+        abstract = (ctx__entity_head__subsuper__supertype_constraint__abstract_entity_declaration || ctx__entity_head__subsuper__supertype_constraint__abstract_supertype_declaration) && true
         supertype_expression = visit_if(ctx__entity_head__subsuper__supertype_constraint__abstract_supertype_declaration || ctx__entity_head__subsuper__supertype_constraint__supertype_rule)
-        subtype_of = visit_if(ctx__entity_head__subsuper__subtype_declaration)
+        subtype_of = visit_if(ctx__entity_head__subsuper__subtype_declaration, [])
         attributes = [
           *visit_if_map_flatten(ctx__entity_body__explicit_attr),
           *visit_if(ctx__entity_body__derive_clause),
           *visit_if(ctx__entity_body__inverse_clause)
         ]
-        unique = visit_if(ctx__entity_body__unique_clause)
-        where = visit_if(ctx__entity_body__where_clause)
+        unique = visit_if(ctx__entity_body__unique_clause, [])
+        where = visit_if(ctx__entity_body__where_clause, [])
 
         Model::Entity.new({
           id: id,
@@ -797,10 +851,10 @@ module Expressir
         ctx__enumeration_extension__type_ref = ctx__enumeration_extension&.type_ref
         ctx__enumeration_extension__enumeration_items = ctx__enumeration_extension&.enumeration_items
 
-        extensible = !!ctx__EXTENSIBLE
-        items = visit_if(ctx__enumeration_items)
+        extensible = ctx__EXTENSIBLE && true
+        items = visit_if(ctx__enumeration_items, [])
         extension_type = visit_if(ctx__enumeration_extension__type_ref)
-        extension_items = visit_if(ctx__enumeration_extension__enumeration_items)
+        extension_items = visit_if(ctx__enumeration_extension__enumeration_items, [])
 
         Model::Types::Enumeration.new({
           extensible: extensible,
@@ -820,7 +874,7 @@ module Expressir
         ctx__parameter_type = ctx.parameter_type
 
         attributes = visit_if_map(ctx__attribute_decl)
-        optional = !!ctx__OPTIONAL
+        optional = ctx__OPTIONAL && true
         type = visit_if(ctx__parameter_type)
 
         attributes.map do |attribute|
@@ -894,7 +948,7 @@ module Expressir
         ctx__actual_parameter_list = ctx.actual_parameter_list
 
         ref = visit_if(ctx__built_in_function || ctx__function_ref)
-        parameters = visit_if(ctx__actual_parameter_list)
+        parameters = visit_if(ctx__actual_parameter_list, [])
 
         Model::Expressions::Call.new({
           ref: ref,
@@ -917,15 +971,24 @@ module Expressir
         parameters = visit_if_map_flatten(ctx__function_head__formal_parameter)
         return_type = visit_if(ctx__function_head__parameter_type)
         declarations = visit_if_map(ctx__algorithm_head__declaration)
-        constants = visit_if(ctx__algorithm_head__constant_decl)
-        variables = visit_if(ctx__algorithm_head__local_decl)
+        types = declarations.select{|x| x.is_a? Model::Type}
+        entities = declarations.select{|x| x.is_a? Model::Entity}
+        subtype_constraints = declarations.select{|x| x.is_a? Model::SubtypeConstraint}
+        functions = declarations.select{|x| x.is_a? Model::Function}
+        procedures = declarations.select{|x| x.is_a? Model::Procedure}
+        constants = visit_if(ctx__algorithm_head__constant_decl, [])
+        variables = visit_if(ctx__algorithm_head__local_decl, [])
         statements = visit_if_map(ctx__stmt)
 
         Model::Function.new({
           id: id,
           parameters: parameters,
           return_type: return_type,
-          declarations: declarations,
+          types: types,
+          entities: entities,
+          subtype_constraints: subtype_constraints,
+          functions: functions,
+          procedures: procedures,
           constants: constants,
           variables: variables,
           statements: statements
@@ -970,8 +1033,8 @@ module Expressir
 
         bound1 = visit_if(ctx__bound_spec__bound1)
         bound2 = visit_if(ctx__bound_spec__bound2)
-        optional = !!ctx__OPTIONAL
-        unique = !!ctx__UNIQUE
+        optional = ctx__OPTIONAL && true
+        unique = ctx__UNIQUE && true
         base_type = visit_if(ctx__parameter_type)
         
         Model::Types::Array.new({
@@ -1009,7 +1072,7 @@ module Expressir
 
         bound1 = visit_if(ctx__bound_spec__bound1)
         bound2 = visit_if(ctx__bound_spec__bound2)
-        unique = !!ctx__UNIQUE
+        unique = ctx__UNIQUE && true
         base_type = visit_if(ctx__parameter_type)
         
         Model::Types::List.new({
@@ -1084,8 +1147,8 @@ module Expressir
         ctx__if_stmt_else_statements = ctx.if_stmt_else_statements
 
         expression = visit_if(ctx__logical_expression)
-        statements = visit_if(ctx__if_stmt_statements)
-        else_statements = visit_if(ctx__if_stmt_else_statements)
+        statements = visit_if(ctx__if_stmt_statements, [])
+        else_statements = visit_if(ctx__if_stmt_else_statements, [])
 
         Model::Statements::If.new({
           expression: expression,
@@ -1299,7 +1362,7 @@ module Expressir
 
         bound1 = visit_if(ctx__bound_spec__bound1)
         bound2 = visit_if(ctx__bound_spec__bound2)
-        unique = !!ctx__UNIQUE
+        unique = ctx__UNIQUE && true
         base_type = visit_if(ctx__instantiable_type)
         
         Model::Types::List.new({
@@ -1515,7 +1578,7 @@ module Expressir
         ctx__actual_parameter_list = ctx.actual_parameter_list
 
         ref = visit_if(ctx__built_in_procedure || ctx__procedure_ref)
-        parameters = visit_if(ctx__actual_parameter_list)
+        parameters = visit_if(ctx__actual_parameter_list, [])
 
         Model::Statements::Call.new({
           ref: ref,
@@ -1536,14 +1599,23 @@ module Expressir
         id = visit_if(ctx__procedure_head__procedure_id)
         parameters = visit_if_map_flatten(ctx__procedure_head__procedure_head_parameter)
         declarations = visit_if_map(ctx__algorithm_head__declaration)
-        constants = visit_if(ctx__algorithm_head__constant_decl)
-        variables = visit_if(ctx__algorithm_head__local_decl)
+        types = declarations.select{|x| x.is_a? Model::Type}
+        entities = declarations.select{|x| x.is_a? Model::Entity}
+        subtype_constraints = declarations.select{|x| x.is_a? Model::SubtypeConstraint}
+        functions = declarations.select{|x| x.is_a? Model::Function}
+        procedures = declarations.select{|x| x.is_a? Model::Procedure}
+        constants = visit_if(ctx__algorithm_head__constant_decl, [])
+        variables = visit_if(ctx__algorithm_head__local_decl, [])
         statements = visit_if_map(ctx__stmt)
 
         Model::Procedure.new({
           id: id,
           parameters: parameters,
-          declarations: declarations,
+          types: types,
+          entities: entities,
+          subtype_constraints: subtype_constraints,
+          functions: functions,
+          procedures: procedures,
           constants: constants,
           variables: variables,
           statements: statements
@@ -1769,20 +1841,16 @@ module Expressir
         ctx__resource_ref = ctx.resource_ref
         ctx__rename_id = ctx.rename_id
 
-        if ctx__resource_ref
-          if ctx__rename_id
-            ref = visit(ctx__resource_ref)
-            id = visit(ctx__rename_id)
+        ref = visit_if(ctx__resource_ref)
+        id = visit_if(ctx__rename_id)
 
-            Model::RenamedRef.new({
-              ref: ref,
-              id: id
-            })
-          else
-            visit(ctx__resource_ref)
-          end
+        if id
+          Model::RenamedRef.new({
+            ref: ref,
+            id: id
+          })
         else
-          raise 'Invalid state'
+          ref
         end
       end
 
@@ -1820,15 +1888,24 @@ module Expressir
         id = visit_if(ctx__rule_head__rule_id)
         applies_to = visit_if_map(ctx__rule_head__entity_ref)
         declarations = visit_if_map(ctx__algorithm_head__declaration)
-        constants = visit_if(ctx__algorithm_head__constant_decl)
-        variables = visit_if(ctx__algorithm_head__local_decl)
+        types = declarations.select{|x| x.is_a? Model::Type}
+        entities = declarations.select{|x| x.is_a? Model::Entity}
+        subtype_constraints = declarations.select{|x| x.is_a? Model::SubtypeConstraint}
+        functions = declarations.select{|x| x.is_a? Model::Function}
+        procedures = declarations.select{|x| x.is_a? Model::Procedure}
+        constants = visit_if(ctx__algorithm_head__constant_decl, [])
+        variables = visit_if(ctx__algorithm_head__local_decl, [])
         statements = visit_if_map(ctx__stmt)
-        where = visit_if(ctx__where_clause)
+        where = visit_if(ctx__where_clause, [])
 
         Model::Rule.new({
           id: id,
           applies_to: applies_to,
-          declarations: declarations,
+          types: types,
+          entities: entities,
+          subtype_constraints: subtype_constraints,
+          functions: functions,
+          procedures: procedures,
           constants: constants,
           variables: variables,
           statements: statements,
@@ -1874,15 +1951,26 @@ module Expressir
         id = visit_if(ctx__schema_id)
         version = visit_if(ctx__schema_version_id)
         interfaces = visit_if_map(ctx__schema_body__interface_specification)
-        constants = visit_if(ctx__schema_body__constant_decl)
+        constants = visit_if(ctx__schema_body__constant_decl, [])
         declarations = visit_if_map(ctx__schema_body__schema_body_declaration)
+        types = declarations.select{|x| x.is_a? Model::Type}
+        entities = declarations.select{|x| x.is_a? Model::Entity}
+        subtype_constraints = declarations.select{|x| x.is_a? Model::SubtypeConstraint}
+        functions = declarations.select{|x| x.is_a? Model::Function}
+        procedures = declarations.select{|x| x.is_a? Model::Procedure}
+        rules = declarations.select{|x| x.is_a? Model::Rule}
 
         Model::Schema.new({
           id: id,
           version: version,
           interfaces: interfaces,
           constants: constants,
-          declarations: declarations
+          types: types,
+          entities: entities,
+          subtype_constraints: subtype_constraints,
+          functions: functions,
+          procedures: procedures,
+          rules: rules
         })
       end
 
@@ -1922,11 +2010,11 @@ module Expressir
         ctx__select_extension__type_ref = ctx.select_extension&.type_ref
         ctx__select_extension__select_list = ctx__select_extension&.select_list
 
-        extensible = !!ctx__EXTENSIBLE
-        generic_entity = !!ctx__GENERIC_ENTITY
-        items = visit_if(ctx__select_list)
+        extensible = ctx__EXTENSIBLE && true
+        generic_entity = ctx__GENERIC_ENTITY && true
+        items = visit_if(ctx__select_list, [])
         extension_type = visit_if(ctx__select_extension__type_ref)
-        extension_items = visit_if(ctx__select_extension__select_list)
+        extension_items = visit_if(ctx__select_extension__select_list, [])
 
         Model::Types::Select.new({
           extensible: extensible,
@@ -2059,7 +2147,7 @@ module Expressir
         ctx__width_spec__FIXED = ctx__width_spec&.FIXED
 
         width = visit_if(ctx__width_spec__width)
-        fixed = !!ctx__width_spec__FIXED
+        fixed = ctx__width_spec__FIXED && true
 
         Model::Types::String.new({
           width: width,
@@ -2092,7 +2180,7 @@ module Expressir
 
         id = visit_if(ctx__subtype_constraint_head__subtype_constraint_id)
         applies_to = visit_if(ctx__subtype_constraint_head__entity_ref)
-        abstract = !!ctx__subtype_constraint_body__abstract_supertype
+        abstract = ctx__subtype_constraint_body__abstract_supertype && true
         total_over = visit_if(ctx__subtype_constraint_body__total_over)
         supertype_expression = visit_if(ctx__subtype_constraint_body__supertype_expression)
 
@@ -2228,7 +2316,7 @@ module Expressir
 
         id = visit_if(ctx__type_id)
         type = visit_if(ctx__underlying_type)
-        where = visit_if(ctx__where_clause)
+        where = visit_if(ctx__where_clause, [])
 
         Model::Type.new({
           id: id,