expressir 2.4.29-arm-linux

data/lib/expressir/express/builders/domain_rule_builder.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds domain_rule nodes.
+      class DomainRuleBuilder
+        def call(ast_data)
+          inner_data = ast_data[:domain_rule] || ast_data
+
+          id = Builder.build_optional(inner_data[:rule_label_id])
+          expression = if inner_data[:expression]
+                         Builder.build({ expression: inner_data[:expression] })
+                       end
+          Expressir::Model::Declarations::WhereRule.new(id: id,
+                                                        expression: expression)
+        end
+      end
+    end
+  end
+end

data/lib/expressir/express/builders/entity_decl_builder.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds entity_decl nodes into Entity objects.
+      class EntityDeclBuilder
+        def call(ast_data)
+          entity_head = ast_data[:entity_head]
+          entity_body = ast_data[:entity_body]
+
+          return nil unless entity_head
+
+          id = Builder.build_optional(entity_head[:entity_id])
+          subsuper = entity_head[:subsuper]
+
+          abstract = false
+          supertype_expression = nil
+          subtype_of = []
+
+          if subsuper.is_a?(Hash)
+            supertype_constraint = subsuper[:supertype_constraint]
+            subtype_declaration = subsuper[:subtype_declaration]
+
+            if supertype_constraint.is_a?(Hash)
+              abstract_entity = supertype_constraint[:abstract_entity_declaration]
+              abstract_supertype = supertype_constraint[:abstract_supertype_declaration]
+              supertype_rule = supertype_constraint[:supertype_rule]
+
+              abstract = !abstract_entity.nil? || !abstract_supertype.nil?
+
+              if supertype_rule.is_a?(Hash)
+                supertype_expression = Builder.build({ supertype_rule: supertype_rule })
+              elsif abstract_supertype.is_a?(Hash) && abstract_supertype[:subtype_constraint]
+                subtype_constraint = abstract_supertype[:subtype_constraint]
+                if subtype_constraint[:supertype_expression]
+                  supertype_expression = Builder.build({ supertype_expression: subtype_constraint[:supertype_expression] })
+                elsif subtype_constraint[:list_of_entity_ref]
+                  entity_refs = Builder.build_children(Builder.ensure_array(subtype_constraint[:list_of_entity_ref][:entity_ref]).map do |d|
+                    { entity_ref: d }
+                  end)
+                  supertype_expression = entity_refs.first if entity_refs.length == 1
+                end
+              end
+            end
+
+            if subtype_declaration.is_a?(Hash)
+              list_ref = subtype_declaration[:list_of_entity_ref]
+              # SUBTYPE OF (a) flattens to a Hash; SUBTYPE OF (a, b) to an
+              # Array of single-key fragments (entity_ref possibly merged
+              # with its op_comma). Collect entity_ref from either shape
+              # (lutaml/expressir#341).
+              raw_entity_refs =
+                if list_ref.is_a?(Hash)
+                  ref = list_ref[:entity_ref]
+                  ref.is_a?(Array) ? ref : [ref]
+                elsif list_ref.is_a?(Array)
+                  list_ref.filter_map { |el| el[:entity_ref] if el.is_a?(Hash) }
+                    .flat_map { |d| d.is_a?(Array) ? d : [d] }
+                end
+              if raw_entity_refs && !raw_entity_refs.empty?
+                subtype_of = Builder.build_children(raw_entity_refs.map do |d|
+                  { entity_ref: d }
+                end)
+              end
+            end
+          end
+
+          attributes = []
+          unique_rules = []
+          where_rules = []
+
+          if entity_body.is_a?(Hash)
+            if entity_body[:explicit_attr]
+              explicit_attrs = Builder.build_children(entity_body[:explicit_attr])
+              attributes.concat(explicit_attrs)
+            end
+
+            if entity_body[:derive_clause]
+              derived = Builder.build({ derive_clause: entity_body[:derive_clause] })
+              attributes.push(derived) if derived
+            end
+
+            if entity_body[:inverse_clause]
+              inverse = Builder.build({ inverse_clause: entity_body[:inverse_clause] })
+              attributes.push(inverse) if inverse
+            end
+
+            if entity_body[:unique_clause]
+              built = Builder.build({ unique_clause: entity_body[:unique_clause] })
+              unique_rules = Array(built).compact
+            end
+            unique_rules ||= []
+
+            if entity_body[:where_clause]
+              where_rules = Builder.build({ where_clause: entity_body[:where_clause] })
+            end
+            where_rules ||= []
+          end
+
+          entity_params = {
+            id: id,
+            supertype_expression: supertype_expression,
+            subtype_of: subtype_of,
+            attributes: attributes,
+            unique_rules: [unique_rules].flatten,
+            where_rules: [where_rules].flatten,
+          }
+          entity_params[:abstract] = true if abstract
+
+          Expressir::Model::Declarations::Entity.new(**entity_params)
+        end
+      end
+    end
+  end
+end

data/lib/expressir/express/builders/explicit_attr_builder.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds explicit_attr nodes.
+      class ExplicitAttrBuilder
+        def call(ast_data)
+          list_data = ast_data[:list_of_attribute_decl]
+          attr_decl_data = if list_data.is_a?(Hash)
+                             list_data[:attribute_decl]
+                           elsif list_data.is_a?(Array)
+                             list_data.filter_map do |item|
+                               item[:attribute_decl] if item.is_a?(Hash)
+                             end
+                           else
+                             ast_data[:attribute_decl]
+                           end
+          attr_decls = Builder.ensure_array(attr_decl_data)
+          optional = !ast_data[:t_optional].nil?
+          type = Builder.build_optional(ast_data[:parameter_type])
+
+          attrs = attr_decls.map do |attr_data|
+            Builder.build({ attribute_decl: attr_data })
+          end
+
+          attrs.map do |attr|
+            next attr unless attr.is_a?(Expressir::Model::Declarations::Attribute)
+
+            attr_params = {
+              id: attr.id,
+              kind: Expressir::Model::Declarations::Attribute::EXPLICIT,
+              supertype_attribute: attr.supertype_attribute,
+              type: type,
+            }
+            attr_params[:optional] = true if optional
+            # Preserve source information from the intermediate object
+            attr_params[:source] = attr.source if attr.source
+            if attr.source_offset
+              attr_params[:source_offset] =
+                attr.source_offset
+            end
+            Expressir::Model::Declarations::Attribute.new(**attr_params)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/expressir/express/builders/expression_builder.rb

@@ -0,0 +1,416 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds expression nodes (binary, unary, query, interval, etc.).
+      class ExpressionBuilder
+        include ::Expressir::Express::Builders::Helpers
+
+        # Expression
+        def build_expression(ast_data)
+          left = if ast_data[:simple_expression]
+                   Builder.build_node(:simple_expression, ast_data[:simple_expression])
+                 elsif ast_data[:logical_expression]
+                   Builder.build_node(:simple_expression, ast_data[:logical_expression][:simple_expression])
+                 end
+
+          if ast_data[:rel_op_extended] && ast_data[:rhs]
+            op = build_rel_op_extended(ast_data[:rel_op_extended])
+            right = Builder.build(ast_data[:rhs])
+            Expressir::Model::Expressions::BinaryExpression.new(
+              operator: op,
+              operand1: left,
+              operand2: right,
+            )
+          else
+            left
+          end
+        end
+
+        def build_logical_expression(ast_data)
+          Builder.build_node(:simple_expression, ast_data[:simple_expression])
+        end
+
+        def build_numeric_expression(ast_data)
+          Builder.build_node(:simple_expression, ast_data[:simple_expression])
+        end
+
+        # Simple expression (addition/subtraction chain)
+        def build_simple_expression(ast_data)
+          return nil unless ast_data[:term]
+
+          term = Builder.build_node(:term, ast_data[:term])
+          rhs = ast_data[:rhs]
+
+          return term if rhs.nil? || (rhs.is_a?(Array) && rhs.empty?)
+
+          rhs_array = rhs.is_a?(Array) ? rhs : [rhs]
+
+          operands = [term]
+          operators = []
+
+          rhs_array.each do |r|
+            # Handle Hash.each yielding [key, value] arrays
+            r = r.last if r.is_a?(Array) && r.length == 2
+
+            next unless r.is_a?(Hash)
+
+            item = r[:item] || r
+            op_data = item[:operator]
+            operators << extract_operator(op_data[:add_like_op]) if op_data
+            if item[:term]
+              operands << Builder.build_node(:term, item[:term])
+            end
+          end
+
+          build_binary_expression(operands, operators)
+        end
+
+        # Term (multiplication/division chain)
+        def build_term(ast_data)
+          return nil unless ast_data[:factor]
+
+          factor = Builder.build_node(:factor, ast_data[:factor])
+          rhs = ast_data[:rhs]
+
+          return factor if rhs.nil? || (rhs.is_a?(Array) && rhs.empty?)
+
+          rhs_array = rhs.is_a?(Array) ? rhs : [rhs]
+
+          operands = [factor]
+          operators = []
+
+          rhs_array.each do |r|
+            # Handle Hash.each yielding [key, value] arrays
+            r = r.last if r.is_a?(Array) && r.length == 2
+
+            next unless r.is_a?(Hash)
+
+            item = r[:item] || r
+            op_data = item[:multiplication_like_op] || item[:mul_like_op]
+            operators << extract_operator(op_data) if op_data
+            operands << Builder.build_node(:factor, item[:factor]) if item[:factor]
+          end
+
+          build_binary_expression(operands, operators)
+        end
+
+        def build_factor(ast_data)
+          return nil unless ast_data[:simple_factor]
+
+          Builder.build_node(:simple_factor, ast_data[:simple_factor])
+        end
+
+        def build_simple_factor(ast_data)
+          return nil unless ast_data
+
+          if ast_data[:primary]
+            Builder.build_node(:primary, ast_data[:primary])
+          elsif ast_data[:simple_factor_expression]
+            Builder.build_node(:simple_factor_expression,
+                               ast_data[:simple_factor_expression])
+          elsif ast_data[:simple_factor_unary_expression]
+            Builder.build_node(:simple_factor_unary_expression,
+                               ast_data[:simple_factor_unary_expression])
+          elsif ast_data[:constant_factor]
+            Builder.build_node(:constant_factor, ast_data[:constant_factor])
+          elsif ast_data[:expression]
+            Builder.build_node(:expression, ast_data[:expression])
+          elsif ast_data[:aggregate_initializer]
+            Builder.build_node(:aggregate_initializer,
+                               ast_data[:aggregate_initializer])
+          elsif ast_data[:query_expression]
+            Builder.build_node(:query_expression, ast_data[:query_expression])
+          elsif ast_data[:entity_constructor]
+            Builder.build_node(:entity_constructor,
+                               ast_data[:entity_constructor])
+          elsif ast_data[:interval]
+            Builder.build_node(:interval, ast_data[:interval])
+          elsif ast_data[:string_literal]
+            Builder.build_node(:string_literal, ast_data[:string_literal])
+          elsif ast_data[:enumeration_reference]
+            Builder.build_node(:enumeration_reference,
+                               ast_data[:enumeration_reference])
+          end
+        end
+
+        def build_simple_factor_expression(ast_data)
+          if ast_data[:primary]
+            Builder.build_node(:primary, ast_data[:primary])
+          elsif ast_data[:expression]
+            Builder.build_node(:expression, ast_data[:expression])
+          end
+        end
+
+        def build_simple_factor_unary_expression(ast_data)
+          op = extract_unary_op(ast_data[:unary_op])
+          operand = if ast_data[:simple_factor]
+                      Builder.build_node(:simple_factor, ast_data[:simple_factor])
+                    elsif ast_data[:simple_factor_expression]
+                      Builder.build_node(:simple_factor_expression,
+                                         ast_data[:simple_factor_expression])
+                    elsif ast_data[:primary]
+                      Builder.build_node(:primary, ast_data[:primary])
+                    end
+
+          if op
+            Expressir::Model::Expressions::UnaryExpression.new(
+              operator: op,
+              operand: operand,
+            )
+          else
+            operand
+          end
+        end
+
+        def build_constant_factor(ast_data)
+          if ast_data[:built_in_constant]
+            Builder.build_node(:built_in_constant, ast_data[:built_in_constant])
+          elsif ast_data[:constant_ref]
+            Builder.build_node(:constant_ref, ast_data[:constant_ref])
+          end
+        end
+
+        def build_primary(ast_data)
+          if ast_data[:literal]
+            Builder.build_node(:literal, ast_data[:literal])
+          elsif ast_data[:qualifiable_factor]
+            build_qualifiable_factor(ast_data[:qualifiable_factor],
+                                     ast_data[:qualifier])
+          elsif ast_data[:population]
+            build_population(ast_data[:population], ast_data[:qualifier])
+          elsif ast_data[:expression]
+            Builder.build_node(:expression, ast_data[:expression])
+          end
+        end
+
+        def build_qualifiable_factor(ast_data, qualifiers = nil)
+          ref = nil
+          if ast_data[:constant_factor]
+            ref = Builder.build_node(:constant_factor,
+                                     ast_data[:constant_factor])
+          elsif ast_data[:function_call]
+            ref = Builder.build_node(:function_call, ast_data[:function_call])
+          else
+            %i[constant_ref function_ref general_ref parameter_ref type_label_ref
+               variable_ref attribute_ref entity_ref type_ref enumeration_ref].each do |key|
+              if ast_data[key]
+                ref = Builder.build_node(key, ast_data[key])
+                break
+              end
+            end
+          end
+
+          return ref unless qualifiers
+
+          Builder.ensure_array(qualifiers).each do |qual|
+            qual_result = Builder.build_node(:qualifier, qual)
+            ref = apply_qualifier(ref, qual_result)
+          end
+          ref
+        end
+
+        def build_population(ast_data, qualifiers = nil)
+          ref = Builder.build_node(:entity_ref, ast_data[:entity_ref])
+          return ref unless qualifiers
+
+          Builder.ensure_array(qualifiers).each do |qual|
+            qual_result = Builder.build_node(:qualifier, qual)
+            ref = apply_qualifier(ref, qual_result)
+          end
+          ref
+        end
+
+        def build_qualifier(ast_data)
+          data = ast_data[:qualifier] || ast_data
+          if data[:attribute_qualifier]
+            Builder.build_node(:attribute_qualifier,
+                               data[:attribute_qualifier])
+          elsif data[:group_qualifier]
+            Builder.build_node(:group_qualifier, data[:group_qualifier])
+          elsif data[:index_qualifier]
+            Builder.build_node(:index_qualifier, data[:index_qualifier])
+          end
+        end
+
+        def build_rel_op_extended(ast_data)
+          extract_rel_op(ast_data[:rel_op] || ast_data)
+        end
+
+        def build_binary_expression(operands, operators)
+          return operands.first if operands.length == 1
+          return nil if operands.empty? || operators.empty?
+
+          result = Expressir::Model::Expressions::BinaryExpression.new(
+            operator: operators.first,
+            operand1: operands.first,
+            operand2: operands[1],
+          )
+
+          (2...operands.length).each do |i|
+            result = Expressir::Model::Expressions::BinaryExpression.new(
+              operator: operators[i - 1],
+              operand1: result,
+              operand2: operands[i],
+            )
+          end
+          result
+        end
+
+        # Function call
+        def build_function_call(ast_data)
+          func_ref = if ast_data[:built_in_function]
+                       Builder.build_node(:built_in_function,
+                                          ast_data[:built_in_function])
+                     elsif ast_data[:function_ref]
+                       Builder.build_node(:function_ref,
+                                          ast_data[:function_ref])
+                     end
+
+          params = if ast_data[:actual_parameter_list]
+                     Builder.build_node(:actual_parameter_list,
+                                        ast_data[:actual_parameter_list])
+                   else
+                     []
+                   end
+
+          if params.empty?
+            func_ref
+          else
+            Expressir::Model::Expressions::FunctionCall.new(
+              function: func_ref,
+              parameters: params,
+            )
+          end
+        end
+
+        def build_actual_parameter_list(ast_data)
+          list_data = ast_data[:list_of_parameter] || ast_data[:parameter]
+
+          case list_data
+          when Hash
+            Builder.build_children(list_data[:parameter])
+          when Array
+            list_data.flat_map do |item|
+              if item.is_a?(Hash) && item[:parameter]
+                Builder.build_children(item[:parameter])
+              else
+                []
+              end
+            end
+          else
+            []
+          end
+        end
+
+        def build_parameter(ast_data)
+          if ast_data[:expression]
+            Builder.build({ expression: ast_data[:expression] })
+          end
+        end
+
+        # Entity constructor
+        def build_entity_constructor(ast_data)
+          entity_ref = Builder.build_optional(ast_data[:entity_ref])
+          params = if ast_data[:actual_parameter_list]
+                     Builder.build_node(:actual_parameter_list,
+                                        ast_data[:actual_parameter_list])
+                   else
+                     []
+                   end
+
+          Expressir::Model::Expressions::FunctionCall.new(
+            function: entity_ref,
+            parameters: params,
+          )
+        end
+
+        # Query expression
+        def build_query_expression(ast_data)
+          var_id = Builder.build_optional(ast_data[:variable_id])
+          aggregate_source = Builder.build_optional(ast_data[:aggregate_source])
+          logical_expr = Builder.build_optional(ast_data[:logical_expression])
+
+          Expressir::Model::Expressions::QueryExpression.new(
+            id: var_id,
+            aggregate_source: aggregate_source,
+            expression: logical_expr,
+          )
+        end
+
+        def build_aggregate_source(ast_data)
+          Builder.build_optional(ast_data[:simple_expression])
+        end
+
+        # Aggregate initializer
+        def build_aggregate_initializer(ast_data)
+          list_data = ast_data[:list_of_element] || ast_data
+          elements = if list_data.is_a?(Array)
+                       list_data
+                     else
+                       list_data[:element]
+                     end
+
+          items = elements ? Builder.build_children(elements) : []
+          Expressir::Model::Expressions::AggregateInitializer.new(items: items.compact)
+        end
+
+        def build_element(ast_data)
+          expression = if ast_data[:expression]
+                         Builder.build({ expression: ast_data[:expression] })
+                       end
+          repetition = Builder.build_optional(ast_data[:repetition])
+
+          if repetition
+            Expressir::Model::Expressions::AggregateInitializerItem.new(
+              expression: expression,
+              repetition: repetition,
+            )
+          else
+            expression
+          end
+        end
+
+        def build_repetition(ast_data)
+          Builder.build_optional(ast_data[:numeric_expression])
+        end
+
+        # Interval
+        def build_interval(ast_data)
+          low = Builder.build_optional(ast_data[:interval_low])
+          item = Builder.build_optional(ast_data[:interval_item])
+          high = Builder.build_optional(ast_data[:interval_high])
+
+          op1 = extract_interval_op(ast_data[:interval_op])
+          op2_data = ast_data[:interval_op2]
+          op2 = if op2_data.is_a?(Hash) && op2_data[:interval_op]
+                  extract_interval_op(op2_data[:interval_op])
+                else
+                  extract_interval_op(op2_data)
+                end
+
+          Expressir::Model::Expressions::Interval.new(
+            low: low,
+            operator1: op1,
+            item: item,
+            operator2: op2,
+            high: high,
+          )
+        end
+
+        def build_interval_low(ast_data)
+          Builder.build_optional(ast_data[:simple_expression])
+        end
+
+        def build_interval_high(ast_data)
+          Builder.build_optional(ast_data[:simple_expression])
+        end
+
+        def build_interval_item(ast_data)
+          Builder.build_optional(ast_data[:simple_expression])
+        end
+      end
+    end
+  end
+end

data/lib/expressir/express/builders/function_decl_builder.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    module Builders
+      # Builds function declaration nodes.
+      class FunctionDeclBuilder
+        def call(ast_data)
+          head = ast_data[:function_head]
+          algorithm_head = ast_data[:algorithm_head]
+          stmts = ast_data[:stmt]
+
+          id = Builder.build_optional(head[:function_id]) if head
+          parameters = build_parameters(head)
+          return_type = Builder.build_optional(head[:parameter_type]) if head
+
+          declarations = []
+          if algorithm_head.is_a?(Hash)
+            declarations = Builder.build_children(algorithm_head[:declaration])
+          end
+
+          types = declarations.grep(Expressir::Model::Declarations::Type)
+          entities = declarations.grep(Expressir::Model::Declarations::Entity)
+          subtype_constraints = declarations.grep(Expressir::Model::Declarations::SubtypeConstraint)
+          functions = declarations.grep(Expressir::Model::Declarations::Function)
+          procedures = declarations.grep(Expressir::Model::Declarations::Procedure)
+          constants = if algorithm_head.is_a?(Hash) && algorithm_head[:constant_decl]
+                        build_constant_decl(algorithm_head[:constant_decl])
+                      else
+                        []
+                      end
+          variables = if algorithm_head.is_a?(Hash) && algorithm_head[:local_decl]
+                        build_local_decl(algorithm_head[:local_decl])
+                      else
+                        []
+                      end
+          statements = Builder.build_children(stmts)
+
+          Expressir::Model::Declarations::Function.new(
+            id: id,
+            parameters: parameters,
+            return_type: return_type,
+            types: types,
+            entities: entities,
+            subtype_constraints: subtype_constraints,
+            functions: functions,
+            procedures: procedures,
+            constants: constants,
+            variables: variables,
+            statements: statements.compact,
+          )
+        end
+
+        private
+
+        def build_parameters(head)
+          return [] unless head && head[:list_of_formal_parameter]
+
+          params_data = head[:list_of_formal_parameter]
+          if params_data.is_a?(Hash) && params_data[:formal_parameter]
+            params_data = [params_data[:formal_parameter]]
+          elsif params_data.is_a?(Array)
+            params_data = params_data.filter_map do |p|
+              p[:formal_parameter] if p.is_a?(Hash)
+            end
+          end
+
+          parameters = []
+          Builder.ensure_array(params_data).each do |param|
+            result = Builder.build({ formal_parameter: param })
+            parameters.concat(Builder.ensure_array(result)) if result
+          end
+          parameters
+        end
+
+        def build_constant_decl(data)
+          Builder.build_children(data[:constant_body])
+        end
+
+        def build_local_decl(data)
+          Builder.build_children(data[:local_variable])
+        end
+      end
+    end
+  end
+end