open_ehr 0.9.4 → 0.9.5

data/lib/open_ehr/parser/cadl_grammar.tt

@@ -1,6 +1,7 @@
 require 'shared_token_grammar'
 require 'open_ehr/assumed_library_types'
 require 'open_ehr/am/archetype/constraint_model'
+require 'open_ehr/am/openehr_profile/data_types/text'
 require 'cadl_node'
 
 module OpenEHR
@@ -22,7 +23,7 @@ module OpenEHR
       end
 
       rule c_complex_object
-        head:c_complex_object_head SYM_MATCHES SYM_START_CBLOCK body:c_complex_object_body SYM_END_CBLOCK {
+        head:c_complex_object_head SYM_MATCHES SYM_START_CBLOCK body:c_complex_object_body SYM_END_CBLOCK space {
           def value(node = ArchetypeNode.new)
             args = head.value
             args[:occurrences] ||= OpenEHR::AssumedLibraryTypes::Interval.new(
@@ -101,6 +102,11 @@ module OpenEHR
             c_complex_object.value(node)
           end
         }
+      / vtc:V_TERM_CODE_CONSTRAINT '' {
+          def value(node)
+            vtc.value(node)
+          end
+        }
       / constraint_ref '' {
           def value(node = nil)
             constraint_ref.value
@@ -147,28 +153,25 @@ module OpenEHR
       end
 
       rule archetype_slot
-        c_archetype_slot_head SYM_MATCHES SYM_START_CBLOCK c_includes c_excludes SYM_END_CBLOCK {
-          def value(node = nil)
-            args = c_archetype_slot_head.value
+        c_archetype_slot_head SYM_MATCHES SYM_START_CBLOCK c_includes c_excludes SYM_END_CBLOCK space {
+          def value(node)
+            args = c_archetype_slot_head.value(node)
             args[:includes] = c_includes.value
             args[:excludes] = c_excludes.value
-            args[:path] = node.path
             OpenEHR::AM::Archetype::ConstraintModel::ArchetypeSlot.new(args)
           end
         }
-      / c_archetype_slot_head SYM_MATCHES SYM_START_CBLOCK c_includes SYM_END_CBLOCK {
-          def value(node = nil)
-            args = c_archetype_slot_head.value
+      / c_archetype_slot_head SYM_MATCHES SYM_START_CBLOCK c_includes SYM_END_CBLOCK space {
+          def value(node)
+            args = c_archetype_slot_head.value(node)
             args[:includes] = c_includes.value
-            args[:path] = node.path
             OpenEHR::AM::Archetype::ConstraintModel::ArchetypeSlot.new(args)
           end
         }
-      / c_archetype_slot_head SYM_MATCHES SYM_START_CBLOCK c_excludes SYM_END_CBLOCK {
-          def value(node = nil)
-            args = c_archetype_slot_head.value
+      / c_archetype_slot_head SYM_MATCHES SYM_START_CBLOCK c_excludes SYM_END_CBLOCK space {
+          def value(node)
+            args = c_archetype_slot_head.value(node)
             args[:excludes] = c_excludes.value
-            args[:path] = node.path
             OpenEHR::AM::Archetype::ConstraintModel::ArchetypeSlot.new(args)
           end
         }
@@ -176,29 +179,31 @@ module OpenEHR
 
       rule c_archetype_slot_head
         c_archetype_slot_id white_space c_occurrences {
-          def value
-            args = c_archetype_slot_id.value
+          def value(node)
+            args = c_archetype_slot_id.value(node)
             args[:occurrences] = c_occurrences.value
             args
           end
         }
       / c_archetype_slot_id white_space {
-          def value
+          def value(node)
             c_archetype_slot_id.value
           end
         }
       end
 
       rule c_archetype_slot_id
-        SYM_ALLOW_ARCHETYPE type_identifier V_LOCAL_TERM_CODE_REF {
-          def value
+        SYM_ALLOW_ARCHETYPE type_identifier lt:V_LOCAL_TERM_CODE_REF {
+          def value(node)
             {:rm_type_name => type_identifier.value,
-             :node_id => V_LOCAL_TERM_CODE_REF.value}
+             :node_id => lt.value,
+             :path => node.path + "[#{lt.value}]"}
           end
         }
       / SYM_ALLOW_ARCHETYPE type_identifier {
-          def value
-            {:rm_type_name => type_identifier.value}
+          def value(node)
+            {:rm_type_name => type_identifier.value,
+             :path => node.path}
           end
         }
       end
@@ -212,19 +217,14 @@ module OpenEHR
       end
 
       rule c_primitive
-        c_integer '' {
-          def value
-            c_integer.value
-          end
-        }	
-      / c_real '' {
+        c_duration '' {
           def value
-            c_real.value
+            c_duration.value
           end
         }
-      / c_date '' {
+      / c_date_time '' {
           def value
-            c_date.value
+            c_date_time.value
           end
         }
       / c_time '' {
@@ -232,26 +232,31 @@ module OpenEHR
             c_time.value
           end
         }
-      / c_date_time '' {
+      / c_date '' {
           def value
-            c_date_time.value
+            c_date.value
           end
         }
-      / c_duration '' {
+      / c_real '' {
           def value
-            c_duration.value
+            c_real.value
           end
         }
-      / c_string '' {
+      / c_integer '' {
           def value
-            c_string.value
+            c_integer.value
           end
-        }
+        }	
       / c_boolean '' {
           def value
             c_boolean.value
           end
         }
+      / c_string '' {
+          def value
+            c_string.value
+          end
+        }
       end
 
       rule c_any
@@ -352,7 +357,7 @@ module OpenEHR
       end
 
       rule c_attr_body
-        SYM_MATCHES SYM_START_CBLOCK c_attr_values SYM_END_CBLOCK {
+        SYM_MATCHES SYM_START_CBLOCK c_attr_values SYM_END_CBLOCK space {
           def value(node)
             c_attr_values.value(node)
           end
@@ -393,7 +398,7 @@ module OpenEHR
       end
 
       rule c_existence
-        SYM_EXISTENCE SYM_MATCHES SYM_START_CBLOCK existence_spec SYM_END_CBLOCK {
+        SYM_EXISTENCE SYM_MATCHES SYM_START_CBLOCK existence_spec SYM_END_CBLOCK space {
           def value
             existence_spec.value
           end
@@ -414,7 +419,7 @@ module OpenEHR
       end
 
       rule c_cardinality
-        SYM_CARDINALITY SYM_MATCHES SYM_START_CBLOCK cardinality_spec SYM_END_CBLOCK {
+        SYM_CARDINALITY SYM_MATCHES SYM_START_CBLOCK cardinality_spec SYM_END_CBLOCK space {
           def value
             cardinality_spec.value
           end
@@ -475,10 +480,16 @@ module OpenEHR
               :is_unique => true)
           end
         }
+      / occurrence_spec space {
+          def value
+            OpenEHR::AM::Archetype::ConstraintModel::Cardinality.new(
+              :interval => occurrence_spec.value)
+          end
+        }
       end
 
       rule c_occurrences
-        SYM_OCCURRENCES SYM_MATCHES SYM_START_CBLOCK occurrence_spec SYM_END_CBLOCK {
+        SYM_OCCURRENCES SYM_MATCHES SYM_START_CBLOCK occurrence_spec SYM_END_CBLOCK space {
           def value
             occurrence_spec.value
           end
@@ -486,7 +497,7 @@ module OpenEHR
       end
 
       rule occurrence_spec
-        st:(V_INTEGER) SYM_ELLIPSIS ed:cardinality_limit_value {
+        st:integer_value SYM_ELLIPSIS ed:cardinality_limit_value {
           def value
             if ed.value == '*'
               interval = OpenEHR::AssumedLibraryTypes::Interval.new(
@@ -509,7 +520,7 @@ module OpenEHR
       end
 
       rule cardinality_limit_value
-        integer_value {
+        integer_value '' {
           def value
             text_value.to_i
           end
@@ -521,274 +532,312 @@ module OpenEHR
         }
       end
 
-      rule c_integer_spec
-        cardinality_limit_value '' {
+      rule c_integer
+        c_integer_spec ';' white_space integer_value {
           def value
-            cardinality_limit_value.value
+            args = c_integer_spec.value
+            args[:assumed_value] = integer_value.value
+            OpenEHR::AM::Archetype::ConstraintModel::Primitive::CInteger.new(args)
           end
         }
-      / integer_list_value '' {
+      / c_integer_spec '' {
           def value
-            integer_list_value.value
+            OpenEHR::AM::Archetype::ConstraintModel::Primitive::CInteger.new(
+              c_integer_spec.value)
           end
         }
-      / integer_interval_value '' {
+      end
+
+      rule c_integer_spec
+        integer_list_value '' {
           def value
-            integer_interval_value.value
+            {:list => integer_list_value.value}
           end
         }
-      / occurrence_spec '' {
+      / integer_interval_value '' {
           def value
-            occurrence_spec.value
+            {:range => integer_interval_value.value}
           end
         }
-      end
-
-      rule c_integer
-        c_integer_spec '' {
+      / integer_value !'..' '' {
           def value
-            c_integer_spec.value
+            {:list => [integer_value.value]}
           end
         }
-      / c_integer_spec ';' integer_value {
+      / occurrence_spec '' {
           def value
-            c_integer_spec.value
+            {:range => occurrence_spec.value}
           end
         }
       end
 
       rule c_real_spec
-        real_value '' {
+        real_list_value '' {
           def value
-            real_value.value
+            {:list => real_list_value.value}
           end
         }
-      / real_list_value '' {
+      / real_interval_value '' {
           def value
-            real_list_value.value
+            {:range => real_interval_value.value}
           end
         }
-      / real_interval_value '' {
+      / real_value '' {
           def value
-            real_interval_value.value
+            {:list => [real_value.value]}
           end
         }
       end
 
       rule c_real
-        c_real_spec '' {
+        c_real_spec ';' white_space real_value {
           def value
-            c_real_spec.value
+            args = c_real_spec.value
+            args[:assumed_value] = real_value.value
+            OpenEHR::AM::Archetype::ConstraintModel::Primitive::CReal.new(args)
           end
         }
-      / c_real_spec ';' real_value {
+      / c_real_spec '' {
           def value
-           c_real_spec.assumed_value = real_value.value
+            OpenEHR::AM::Archetype::ConstraintModel::Primitive::CReal.new(
+              c_real_spec.value)
           end
         }
       end
 
       rule c_date_constraint
-        V_ISO8601_DATE_CONSTRAINT_PATTERN '' {
+        date_interval_value '' {
+          def value
+            {:range => date_interval_value.value}
+          end
+        }
+      / date_list_value '' {
           def value
-            V_ISO8601_DATE_CONSTRAINT_PATTERN.value
+            {:list => date_list_value.value}
           end
         }
       / date_value '' {
           def value
-            date_value.value
+            {:list => [date_value.value]}
           end
         }
-      / date_interval_value '' {
+      / con:V_ISO8601_DATE_CONSTRAINT_PATTERN '' {
           def value
-            date_interval_value.value
+            {:pattern => con.text_value}
           end
         }
       end
 
       rule c_date
-        c_date_constraint '' {
+        c_date_constraint ';' white_space date_value {
           def value
-            c_date_constraint.value
+            args = c_date_constraint.value
+            args[:assumed_value] = date_value.value
+            OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDate.new(
+              args)
           end
         }
-      / c_date_constraint ';' date_value {
+      / c_date_constraint '' {
           def value
-            c_date_constraint.value
+            OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDate.new(
+              c_date_constraint.value)
           end
         }
       end
 
       rule c_time_constraint
-        V_ISO8601_TIME_CONSTRAINT_PATTERN '' {
+        time_interval_value '' {
           def value
-            V_ISO8601_TIME_CONSTRAINT_PATTERN.value
+            {:range => time_interval_value.value}
+          end
+        }
+      / time_list_value '' {
+          def value
+            {:list => time_list_value.value}
           end
         }
       / time_value '' {
           def value
-            time_value.value
+            {:list => [time_value.value]}
           end
         }
-      / time_interval_value {
+      / tc:V_ISO8601_TIME_CONSTRAINT_PATTERN '' {
           def value
-            time_interval_value.value
+            {:pattern => tc.text_value}
           end
         }
       end
 
       rule c_time
-        c_time_constraint '' {
+        c_time_constraint ';' white_space time_value {
           def value
-            c_time_constraint.value
+            args = c_time_constraint.value
+            args[:assumed_value] = time_value.value
+            OpenEHR::AM::Archetype::ConstraintModel::Primitive::CTime.new(
+              args)
           end
-        }
-      / c_time_constraint ';' time_value {
+        }    
+      / c_time_constraint '' {
           def value
-            c_time_constraint.value
+            OpenEHR::AM::Archetype::ConstraintModel::Primitive::CTime.new(
+              c_time_constraint.value)
           end
-        }    
+        }
       end
 
       rule c_date_time_constraint
-        V_ISO8601_DATE_TIME_CONSTRAINT_PATTERN '' {
+        date_time_interval_value '' {
           def value
-            V_ISO8601_DATE_TIME_CONSTRAINT_PATTERN.value
+            {:range => date_time_interval_value.value}
           end
         }
       / date_time_value '' {
           def value
-            date_time_value.value
+            {:list => [date_time_value.value]}
           end
         }
-      / date_time_interval_value '' {
+      / dtc:V_ISO8601_DATE_TIME_CONSTRAINT_PATTERN '' {
           def value
-            date_time_interval_value.value
+            {:pattern => dtc.text_value}
           end
         }
       end
 
       rule c_date_time
-        c_date_time_constraint '' {
+        c_date_time_constraint ';' white_space date_time_value {
           def value
-            c_date_time_constraint.value
+            args = c_date_time_constraint.value
+            args[:assumed_value] = date_time_value.value
+            OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDateTime.new(
+              args)
           end
         }
-      / c_date_time_constraint ';' date_time_value {
+      / c_date_time_constraint '' {
           def value
-            c_date_time_constraint.value
+            OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDateTime.new(
+              c_date_time_constraint.value)
           end
         }
       end
 
       rule c_duration_constraint
-        duration_pattern '' {
+        duration_pattern '/' duration_interval_value '' {
           def value
-            duration_pattern.value
+            {:pattern => duration_pattern.value}
           end
         }
-      / duration_pattern '/' duration_interval_pattern {
+      / duration_pattern '' {
           def value
-            duration_interval_patternl.value
+            {:pattern => duration_pattern.value}
           end
         }
-      / duration_value {
+      / duration_interval_value '' {
           def value
-            duration_value.value
+            {:range => duration_interval_value.value}
           end
         }
-      / duration_interval_value {
+      / duration_value '' {
           def value
-            duration_interval_value.value
+            {:list => [duration_value.value]}
           end
         }
       end
 
       rule duration_pattern
-        V_ISO8601_TIME_CONSTRAINT_PATTERN '' {
+        dp:V_ISO8601_DURATION_CONSTRAINT_PATTERN '' {
           def value
-            V_ISO8601_TIME_CONSTRAINT_PATTERN.value
+            dp.text_value
           end
         }
       end
 
       rule c_duration
-        c_duration_constraint '' {
+        c_duration_constraint ';' white_space duration_value '' {
           def value
-            c_duration_constraint.value
+            args = c_duration_constraint.value
+            args[:assumed_value] = duration_value.value
+            OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDuration.new(
+              args)
           end
         }
-      / c_duration_constraint ';' duration_value {
+      / c_duration_constraint !';' '' {
           def value
-            c_duration_constraint.value
+            OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDuration.new(
+              c_duration_constraint.value)
           end
         }
       end
 
       rule c_string_spec
-        string_list_value ',' SYM_LIST_CONTINUE {
+        string_list_value ',' white_space SYM_LIST_CONTINUE {
           def value
-            OpenEHR::AM::Archetype::ConstraintModel::Primitive::CString.new(
-              :list => string_list_value.value)
+            {:list => string_list_value.value}
           end
         }
       / string_list_value '' {
           def value
-            OpenEHR::AM::Archetype::ConstraintModel::Primitive::CString.new(
-              :list => string_list_value.value, :type => 'Boolean')
+            {:list => string_list_value.value}
           end
         }
       / pat:V_REGEXP '' {
           def value
-            OpenEHR::AM::Archetype::ConstraintModel::Primitive::CString.new(
-              :pattern => pat.value, :type => 'Boolean')
+            {:pattern => pat.value}
           end
         }
       / str:V_STRING '' {
           def value
-            OpenEHR::AM::Archetype::ConstraintModel::Primitive::CString.new(
-              :list => [str.value])
+            {:list => [str.value]}
           end
         }
       end
 
       rule c_string
-        c_string_spec (';' string_value)? {
+        c_string_spec white_space ';' white_space string_value {
+          def value
+            args = c_string_spec.value
+            args[:assumed_value] = string_value.value
+            OpenEHR::AM::Archetype::ConstraintModel::Primitive::CString.new(
+              args)
+          end
+        }
+      / c_string_spec '' {
           def value
-            c_string_spec.value
+            OpenEHR::AM::Archetype::ConstraintModel::Primitive::CString.new(
+              c_string_spec.value)
           end
         }
       end
 
       rule c_boolean_spec
-        SYM_TRUE '' {
+        SYM_TRUE ',' white_space SYM_FALSE {
           def value
-            {:true_valid => true, :false_valid => false}
+            {:true_valid => true, :false_valid => true}
           end
         }
-      / SYM_TRUE ',' SYM_FALSE {
+      / SYM_TRUE white_space '' {
           def value
-            {:true_valid => true, :false_valid => true}
+            {:true_valid => true, :false_valid => false}
           end
         }
-      / SYM_FALSE '' {
+      / SYM_FALSE white_space ',' white_space SYM_TRUE {
           def value
-            {:true_valid => false, :false_valid => true}
+            {:true_valid => true, :false_valid => true}
           end
         }
-      / SYM_FALSE ',' SYM_TRUE {
+      / SYM_FALSE white_space '' {
           def value
-            {:true_valid => true, :false_valid => true}
+            {:false_valid => true, :true_valid => false}
           end
         }
       end
 
       rule c_boolean
-        c_boolean_spec ';' boolean_value {
+        c_boolean_spec ';' white_space boolean_value {
           def value
-            c_boolean_spec.value[:assumed_value] = boolean_value.value
+            args = c_boolean_spec.value
+            args[:assumed_value] = boolean_value.value
             OpenEHR::AM::Archetype::ConstraintModel::Primitive::CBoolean.new(
-              c_boolean_spec.value)
+              args)
           end
         }
       / c_boolean_spec '' {
@@ -815,6 +864,72 @@ module OpenEHR
         }      
       end
 
+      rule code_string
+        NAMECHAR+ '' {
+          def value
+            text_value
+          end
+        }
+      end
+
+      rule code_string_list
+        first:code_string more:(',' space code_string)+ space {
+          def value
+            codes.map {|c| c.value}
+          end
+
+          def codes
+            [first] + more.elements.map {|e| e.code_string}
+          end
+        }
+      end
+
+      rule code_string_spec
+        code_string_list '' {
+          def value
+            code_string_list.value
+          end
+        }
+      / code_string '' {
+          def value
+            [code_string.value]
+          end
+          }
+      end
+
+      rule V_TERM_CODE_CONSTRAINT
+        ti:V_TERM_CODE code_string_spec ';' space code_string ']' space {
+          def value(node)
+            ::OpenEHR::AM::OpenEHRProfile::DataTypes::Text::CCodePhrase.new(
+              :rm_type_name => 'CodePhrase',
+              :occurrences => OpenEHR::AssumedLibraryTypes::Interval.new(
+                                :upper => 1, :lower => 1),
+              :terminology_id => ti.value, :code_list => code_string_spec.value,
+              :assumed_value => code_string.value,
+              :path => node.path)
+          end
+        }
+      / ti:V_TERM_CODE code_string_spec ']' space {
+          def value(node)
+            ::OpenEHR::AM::OpenEHRProfile::DataTypes::Text::CCodePhrase.new(
+              :rm_type_name => 'CodePhrase',
+              :occurrences => OpenEHR::AssumedLibraryTypes::Interval.new(
+                                :upper => 1, :lower => 1),
+              :terminology_id => ti.value, :code_list => code_string_spec.value,
+              :path => node.path)
+          end
+        }
+      / ti:V_TERM_CODE ']' space {
+          def value(node)
+            ::OpenEHR::AM::OpenEHRProfile::DataTypes::Text::CCodePhrase.new(
+              :rm_type_name => 'CodePhrase',
+              :occurrences => OpenEHR::AssumedLibraryTypes::Interval.new(
+                                :upper => 1, :lower => 1),
+              :terminology_id => ti.value, :code_list => [], :path => node.path)
+          end
+        }
+      end
+
       rule V_C_DOMAIN_TYPE
         '('? [A-Z] IDCHAR* ')'? [ \n]* '<' [^>]* '>'
       end
@@ -846,10 +961,12 @@ module OpenEHR
           def value
             if (id && !id.empty?)
               OpenEHR::AM::Archetype::Assertion::Assertion.new(
-                :tag => id.value, :expression => boolean_expression.value)
+                :tag => id.value, :expression => boolean_expression.value,
+                :string_expression => id.text_value + boolean_expression.text_value)
             else
               OpenEHR::AM::Archetype::Assertion::Assertion.new(
-                :expression => boolean_expression.value)
+                :expression => boolean_expression.value,
+                :string_expression => boolean_expression.text_value)
             end
           end
         }
@@ -861,36 +978,153 @@ module OpenEHR
             boolean_node.value
           end
         }
+      / boolean_leaf '' {
+          def value
+            boolean_leaf.value
+          end
+        }
       end
 
       rule boolean_node
         SYM_EXISTS absolute_path {
           def value
-            {:operator => OpenEHR::AM::Archetype::Assertion::OperatorKind::OP_EXISTS,
-             :path => absolute_path.value }
+            item = OpenEHR::AM::Archetype::Assertion::ExprLeaf.new(
+              :type => 'String',
+              :item => absolute_path.value,
+              :reference_type => 'CONSTANT')
+            OpenEHR::AM::Archetype::Assertion::ExprUnaryOperator.new(
+              :type => 'Boolean',
+              :operator => OpenEHR::AM::Archetype::Assertion::OperatorKind::OP_EXISTS,
+              :operand => item,
+              :precedence_overridden => false)
           end
         }
       / relative_path white_space SYM_MATCHES SYM_START_CBLOCK c_primitive SYM_END_CBLOCK {
           def value
-            OpenEHR::AM::Archetype::Assertion::ExprLeaf.new(
-              :item => c_primitive.value,
-              :type => c_primitive.value.type,
-              :path => relative_path.value,
-              :reference_type => 'constraint')
+            left_op = OpenEHR::AM::Archetype::Assertion::ExprLeaf.new(
+                        :type => 'String',
+                        :item => relative_path.value,
+                        :reference_type => 'Constant')
+            right_op = OpenEHR::AM::Archetype::Assertion::ExprLeaf.new(
+                        :item => c_primitive.value,
+                        :type => c_primitive.value.type,
+                        :reference_type => 'Constant')
+            op = OpenEHR::AM::Archetype::Assertion::OperatorKind::OP_MATCHES
+            OpenEHR::AM::Archetype::Assertion::ExprBinaryOperator.new(
+              :type => 'Boolean',
+              :operator => op,
+              :right_operand => right_op,
+              :left_operand => left_op,
+              :reference_type => 'Constraint')
           end
         }
       / SYM_NOT boolean_leaf {
           def value
-            boolean_leaf.value
+            OpenEHR::AM::Archetype::Assertion::ExprUnaryOperator.new(
+              :type => 'Boolean',
+              :operator => OpenEHR::AM::Archetype::Assertion::OperatorKind::OP_NOT,
+              :operand => boolean_leaf.value,
+              :precedence_overridden => false)
+          end
+        }
+      / arithmetic_leaf SYM_EQ arithmetic_expression {
+          def value
+            OpenEHR::AM::Archetype::Assertion::ExprBinaryOperator.new(
+              :type => 'Boolean',
+              :operator => OpenEHR::AM::Archetype::Assertion::OperatorKind::OP_EQ,
+              :left_operand => arithmetic_leaf.value,
+              :right_operand => arithmetic_expression.value,
+              :reference_type => 'Constraint')
+          end
+        }
+      / arithmetic_leaf SYM_NE arithmetic_expression {
+          def value
+            OpenEHR::AM::Archetype::Assertion::ExprBinaryOperator.new(
+              :type => 'Boolean',
+              :operator => OpenEHR::AM::Archetype::Assertion::OperatorKind::OP_NE,
+              :left_operand => arithmetic_leaf.value,
+              :right_operand => arithmetic_expression.value,
+              :reference_type => 'Constraint')
+          end
+        }
+      / arithmetic_leaf SYM_LT arithmetic_expression {
+          def value
+            OpenEHR::AM::Archetype::Assertion::ExprBinaryOperator.new(
+              :type => 'Boolean',
+              :operator => OpenEHR::AM::Archetype::Assertion::OperatorKind::OP_LT,
+              :left_operand => arithmetic_leaf.value,
+              :right_operand => arithmetic_expression.value,
+              :reference_type => 'Constraint')
           end
         }
-      / arithmetic_expression (SYM_EQ / SYM_NE / SYM_LT / SYM_GT / SYM_LE / SYM_GE) arithmetic_expression {          def value
-            p elements
+      / arithmetic_leaf SYM_GT arithmetic_expression {
+          def value
+            OpenEHR::AM::Archetype::Assertion::ExprBinaryOperator.new(
+              :type => 'Boolean',
+              :operator => OpenEHR::AM::Archetype::Assertion::OperatorKind::OP_GT,
+              :left_operand => arithmetic_leaf.value,
+              :right_operand => arithmetic_expression.value,
+              :reference_type => 'Constraint')
+          end
+        }
+      / arithmetic_leaf SYM_LE arithmetic_expression {
+          def value
+            OpenEHR::AM::Archetype::Assertion::ExprBinaryOperator.new(
+              :type => 'Boolean',
+              :operator => OpenEHR::AM::Archetype::Assertion::OperatorKind::OP_LE,
+              :left_operand => arithmetic_leaf.value,
+              :right_operand => arithmetic_expression.value,
+              :reference_type => 'Constraint')
+          end
+        }
+      / arithmetic_leaf SYM_GE arithmetic_expression {
+          def value
+            OpenEHR::AM::Archetype::Assertion::ExprBinaryOperator.new(
+              :type => 'Boolean',
+              :operator => OpenEHR::AM::Archetype::Assertion::OperatorKind::OP_GE,
+              :left_operand => arithmetic_leaf.value,
+              :right_operand => arithmetic_expression.value,
+              :reference_type => 'Constraint')
+          end
+        }
+      / boolean_leaf SYM_AND boolean_expression {
+          def value
+            OpenEHR::AM::Archetype::Assertion::ExprBinaryOperator.new(
+              :type => 'Boolean',
+              :operator => OpenEHR::AM::Archetype::Assertion::OperatorKind::OP_AND,
+              :left_operand => boolean_leaf.value,
+              :right_operand => boolean_expression.value,
+              :reference_type => 'Constraint')
+          end
+        }
+      / boolean_leaf SYM_OR boolean_expression {
+          def value
+            OpenEHR::AM::Archetype::Assertion::ExprBinaryOperator.new(
+              :type => 'Boolean',
+              :operator => OpenEHR::AM::Archetype::Assertion::OperatorKind::OP_OR,
+              :left_operand => boolean_leaf.value,
+              :right_operand => boolean_expression.value,
+              :reference_type => 'Constraint')
+          end
+        }
+      / boolean_leaf SYM_XOR boolean_expression {
+          def value
+            OpenEHR::AM::Archetype::Assertion::ExprBinaryOperator.new(
+              :type => 'Boolean',
+              :operator => OpenEHR::AM::Archetype::Assertion::OperatorKind::OP_XOR,
+              :left_operand => boolean_leaf.value,
+              :right_operand => boolean_expression.value,
+              :reference_type => 'Constraint')
           end
         }
-      / boolean_leaf ((SYM_AND / SYM_OR / SYM_XOR / SYM_IMPLIES) boolean_leaf)? {
+      / boolean_leaf SYM_IMPLIES boolean_expression {
           def value
-            p elements
+            OpenEHR::AM::Archetype::Assertion::ExprBinaryOperator.new(
+              :type => 'Boolean',
+              :operator => OpenEHR::AM::Archetype::Assertion::OperatorKind::OP_IMPLIES,
+              :left_operand => boolean_leaf.value,
+              :right_operand => boolean_expression.value,
+              :reference_type => 'Constraint')
           end
         }
       end
@@ -903,12 +1137,18 @@ module OpenEHR
         }
       / SYM_TRUE {
           def value
-            true
+            OpenEHR::AM::Archetype::Assertion::ExprLeaf.new(
+              :type => 'Boolean',
+              :item => true,
+              :reference_type => 'CONSTANT')
           end
         }
       / SYM_FALSE {
           def value
-            false
+            OpenEHR::AM::Archetype::Assertion::ExprLeaf.new(
+              :type => 'Boolean',
+              :item => false,
+              :reference_type => 'CONSTANT')
           end
         }
       end
@@ -919,44 +1159,120 @@ module OpenEHR
             arithmetic_node.value
           end
         }
+      / arithmetic_leaf '' {
+          def value
+            arithmetic_leaf.value
+          end
+        }
       end
 
       rule arithmetic_node
-        arithmetic_leaf (('+' / '-' / '*' / '/' / '^') arithmetic_leaf)*
+        arithmetic_leaf '+' arithmetic_expression {
+          def value
+            OpenEHR::AM::Archetype::Assertion::ExprBinaryOperator.new(
+              :type => 'Boolean',
+              :operator => OpenEHR::AM::Archetype::Assertion::OperatorKind::OP_PLUS,
+              :left_operand => arithmetic_leaf.value,
+              :right_operand => arithmetic_expression.value,
+              :reference_type => 'Constraint')
+          end
+        }
+      / arithmetic_leaf '-' arithmetic_expression {
+          def value
+            OpenEHR::AM::Archetype::Assertion::ExprBinaryOperator.new(
+              :type => 'Boolean',
+              :operator => OpenEHR::AM::Archetype::Assertion::OperatorKind::OP_MINUS,
+              :left_operand => arithmetic_leaf.value,
+              :right_operand => arithmetic_expression.value,
+              :reference_type => 'Constraint')
+          end
+        }
+      / arithmetic_leaf '*' arithmetic_expression {
+          def value
+            OpenEHR::AM::Archetype::Assertion::ExprBinaryOperator.new(
+              :type => 'Boolean',
+              :operator => OpenEHR::AM::Archetype::Assertion::OperatorKind::OP_MULTIPLY,
+              :left_operand => arithmetic_leaf.value,
+              :right_operand => arithmetic_expression.value,
+              :reference_type => 'Constraint')
+          end
+        }
+      / arithmetic_leaf '/' arithmetic_expression {
+          def value
+            OpenEHR::AM::Archetype::Assertion::ExprBinaryOperator.new(
+              :type => 'Boolean',
+              :operator => OpenEHR::AM::Archetype::Assertion::OperatorKind::OP_DIVIDE,
+              :left_operand => arithmetic_leaf.value,
+              :right_operand => arithmetic_expression.value,
+              :reference_type => 'Constraint')
+          end
+        }
+      / arithmetic_leaf '^' arithmetic_expression {
+          def value
+            OpenEHR::AM::Archetype::Assertion::ExprBinaryOperator.new(
+              :type => 'Boolean',
+              :operator => OpenEHR::AM::Archetype::Assertion::OperatorKind::OP_EXP,
+              :left_operand => arithmetic_leaf.value,
+              :right_operand => arithmetic_expression.value,
+              :reference_type => 'Constraint')
+          end
+        }
       end
 
       rule arithmetic_leaf
-       '(' arithmetic_expression ')' {
+       '(' arithmetic_expression ')' space {
           def value
             arithmetic_expression.value
           end
         }
       / integer_value '' {
           def value
-            integer_value.value
+            OpenEHR::AM::Archetype::ConstraintModel::ExprLeaf.new(
+              :type => 'Integer',
+              :item => integer_value.value,
+              :reference_type => 'CONSTANT')
           end
         }
       / real_value '' {
           def value
-            real_value.value
+            OpenEHR::AM::Archetype::ConstraintModel::ExprLeaf.new(
+              :type => 'Real',
+              :item => real_value.value,
+              :reference_type => 'CONSTANT')
           end
         }
-      / absolute_path '' {
+      / absolute_path space {
           def value
-            absolute_path.value
+            OpenEHR::AM::Archetype::ConstraintModel::ExprLeaf.new(
+              :type => 'String',
+              :item => absolute_path.value,
+              :reference_type => 'CONSTANT')
+            
           end
         }
       end
 
 # path block
       rule object_path
-        movable_path
-      / absolute_path
-      / relative_path
+        movable_path '' {
+          def value
+            movable_path.value
+          end
+	}
+      / absolute_path '' {
+          def value
+            absolute_path.value
+          end
+        }
+      / relative_path '' {
+          def value
+            relative_path.value
+          end
+        }
       end
 
       rule movable_path
-         SYM_MOVABLE_LEADER relative_path {
+         SYM_MOVABLE_LEADER relative_path '' {
            def value
              text_value
            end
@@ -964,7 +1280,7 @@ module OpenEHR
       end
 
       rule absolute_path
-        '/' relative_path? {
+        '/' relative_path? '' {
            def value
              text_value
            end
@@ -972,7 +1288,7 @@ module OpenEHR
       end
 
       rule relative_path
-        path_segment ('/' path_segment)* {
+        path_segment ('/' path_segment)* '' {
           def value
             text_value
           end
@@ -980,7 +1296,7 @@ module OpenEHR
       end
 
       rule path_segment
-        V_ATTRIBUTE_IDENTIFIER V_LOCAL_TERM_CODE_REF? {
+        V_ATTRIBUTE_IDENTIFIER V_LOCAL_TERM_CODE_REF? '' {
           def value
             text_value
           end