Ignore:
Timestamp:
Oct 19, 2009, 5:10:43 PM (15 years ago)
Author:
Tatsukawa, Akimichi
Message:

commit at the timing of leaving Pittsburgh

File:
1 edited

Legend:

Unmodified
Added
Removed

  • ruby/trunk/lib/adl_parser/lib/adl_scanner.rb

    r321 r323  
    8989              when /\A(\w+)-(\w+)-(\w+)\.(\w+)((?:-\w+)*)\.(v\w+)/   #V_ARCHETYPE_ID
    9090                object_id, rm_originator, rm_name, rm_entity, concept_name, specialisation, version_id = $&, $1, $2, $3, $4, $5, $6
    91                 #archetype_id = OpenEhr::RM::Support::Identification::ArchetypeID.new(object_id, concept_name, rm_name, rm_entity, rm_originator, specialisation, version_id)
    92                 archetype_id = OpenEhr::RM::Support::Identification::ArchetypeID.new(:concept_name => concept_name, :rm_name => rm_name, :rm_entity => rm_entity, :rm_originator => :rm_originator, :specialisation => specialisation, :version_id => version_id)
     91                archetype_id = OpenEhr::RM::Support::Identification::ArchetypeID.new(:concept_name => concept_name, :rm_name => rm_name, :rm_entity => rm_entity, :rm_originator => rm_originator, :specialisation => specialisation, :version_id => version_id)
    9392                yield :V_ARCHETYPE_ID, archetype_id
    9493              when /\A[a-z][a-zA-Z0-9_]*/
    … …  
    848847
    849848
    850 #       module Common
    851 #         class START_TERM_CODE_CONSTRAINT
    852 #           include Yaparc::Parsable
    853 #           def initialize
    854 #             @parser = lambda do |input|
    855 #               Yaparc::Apply.new(Yaparc::Regex.new(/[ \t\n]*\[([a-zA-Z0-9\(\)\._\-]+)::[ \t\n]*/)) do |match|
    856 #                 OpenEhr::LOG.info("START_TERM_CODE_CONSTRAINT: #{match}")
    857 #                 [:START_TERM_CODE_CONSTRAINT, match]
    858 #               end
    859 #             end
    860 #           end
    861 #         end
    862 
    863 #         # /\A\[[a-zA-Z0-9()\._-]+::[a-zA-Z0-9\._-]+\]/  #V_QUALIFIED_TERM_CODE_REF form [ICD10AM(1998)::F23]
    864 #         class V_QUALIFIED_TERM_CODE_REF
    865 #           include Yaparc::Parsable
    866 #           def initialize
    867 #             @parser = lambda do |input|
    868 #               Yaparc::Apply.new(Yaparc::Regex.new(/\A\[[a-zA-Z0-9()\._-]+::[a-zA-Z0-9\._-]+\]/)) do |match|
    869 #                 OpenEhr::LOG.info("V_QUALIFIED_TERM_CODE_REF: #{match}")
    870 #                 [:V_QUALIFIED_TERM_CODE_REF, match]
    871 #               end
    872 #             end
    873 #           end
    874 #         end
    875        
    876 #         class V_LOCAL_TERM_CODE_REF
    877 #           include Yaparc::Parsable
    878 #           def initialize
    879 #             @parser = lambda do |input|
    880 #               Yaparc::Apply.new(Yaparc::Regex.new(/\A\[[a-zA-Z0-9][a-zA-Z0-9._\-]*\]/)) do |match|
    881 #                 OpenEhr::LOG.info("V_TERM_CODE_REF: #{match}")
    882 #                 [:V_LOCAL_TERM_CODE_REF, match]
    883 #               end
    884 #             end
    885 #           end
    886 #         end
    887 
    888 #         class ERR_V_QUALIFIED_TERM_CODE_REF
    889 #           include Yaparc::Parsable
    890 #           def initialize
    891 #             @parser = lambda do |input|
    892 #               Yaparc::Apply.new(Yaparc::Regex.new(/\A\[[a-zA-Z0-9._\- ]+::[a-zA-Z0-9._\- ]+\]/)) do |match|
    893 #                 OpenEhr::LOG.info("ERR_V_QUALIFIED_TERM_CODE_REF: #{match}")
    894 #                 [:ERR_V_QUALIFIED_TERM_CODE_REF, match]
    895 #               end
    896 #             end
    897 #           end
    898 #         end
    899 
    900 #         class V_TYPE_IDENTIFIER
    901 #           include Yaparc::Parsable
    902 #           def initialize
    903 #             @parser = lambda do |input|
    904 #               Yaparc::Apply.new(Yaparc::Regex.new(/\A[A-Z][a-zA-Z0-9_]*/)) do |match|
    905 #                 OpenEhr::LOG.info("V_TYPE_IDENTIFIER: #{match}")
    906 #                 [:V_TYPE_IDENTIFIER, match]
    907 #               end
    908 #             end
    909 #           end
    910 #         end
    911 
    912 #         class V_GENERIC_TYPE_IDENTIFIER
    913 #           include Yaparc::Parsable
    914 #           def initialize
    915 #             @parser = lambda do |input|
    916 #               Yaparc::Apply.new(Yaparc::Regex.new(/\A[A-Z][a-zA-Z0-9_]*<[a-zA-Z0-9,_<>]+>/)) do |match|
    917 #                 OpenEhr::LOG.info("V_GENERIC_TYPE_IDENTIFIER: #{match}")
    918 #                 [:V_GENERIC_TYPE_IDENTIFIER, match]
    919 #               end
    920 #             end
    921 #           end
    922 #         end
    923 
    924 
    925 #         class V_LOCAL_CODE
    926 #           include Yaparc::Parsable
    927 #           def initialize
    928 #             @parser = lambda do |input|
    929 #               Yaparc::Apply.new(Yaparc::Regex.new(/\Aa[ct][0-9.]+/)) do |match|
    930 #                 OpenEhr::LOG.info("V_LOCAL_CODE: #{match}")
    931 #                 [:V_LOCAL_CODE, match]
    932 #               end
    933 #             end
    934 #           end
    935 #         end
    936 
    937 #         class V_STRING
    938 #           include Yaparc::Parsable
    939 #           def initialize
    940 #             @parser = lambda do |input|
    941 #               Yaparc::Apply.new(Yaparc::Regex.new(/\A"([^"]*)"/m)) do |match|
    942 #                 OpenEhr::LOG.info("V_STRING: #{match}")
    943 #                 [:V_STRING, match]
    944 #               end
    945 #             end
    946 #           end
    947 #         end
    948 
    949 #         class V_REAL
    950 #           include Yaparc::Parsable
    951 #           def initialize
    952 #             @parser = lambda do |input|
    953 #               Yaparc::Apply.new(Yaparc::Regex.new(/\A[0-9]+\.[0-9]+|[0-9]+\.[0-9]+[eE][+-]?[0-9]+/)) do |match|
    954 #                 OpenEhr::LOG.info("V_REAL: #{match}")
    955 #                 [:V_REAL, match]
    956 #               end
    957 #             end
    958 #           end
    959 #         end
    960 
    961 #         #V_ISO8601_DURATION PnYnMnWnDTnnHnnMnnS
    962 #         class V_ISO8601_DURATION
    963 #           include Yaparc::Parsable
    964 #           def initialize
    965 #             @parser = lambda do |input|
    966 #               Yaparc::Apply.new(
    967 #                                 Yaparc::Alt.new(Yaparc::Regex.new(/\AP([0-9]+|[yY])?([0-9]+|[mM])?([0-9]+|[wW])?([0-9]+|[dD])?T([0-9]+|[hH])?([0-9]+|[mM])?([0-9]+|[sS])?/),
    968 #                                                 Yaparc::Regex.new(/\AP([0-9]+|[yY])?([0-9]+|[mM])?([0-9]+|[wW])?([0-9]+|[dD])?/))) do |match|
    969 #                 OpenEhr::LOG.info("V_ISO8601_DURATION: #{match}")
    970 #                 [:V_ISO8601_DURATION, match]
    971 #               end
    972 #             end
    973 #           end
    974 #         end
    975 
    976 #       end # of Common
    977 
    978 #       module DADL
    979 #         # c.f. http://www.openehr.org/svn/ref_impl_eiffel/TRUNK/components/adl_parser/src/syntax/adl/parser/adl_scanner.l
    980 #         RESERVED = {
    981 #           'true' => :SYM_TRUE, #[Tt][Rr][Uu][Ee] -- -> SYM_TRUE
    982 #           'false' => :SYM_FALSE, # [Ff][Aa][Ll][Ss][Ee] -- -> SYM_FALSE
    983 #           'infinity' => :SYM_INFINITY # [Ii][Nn][Ff][Ii][Nn][Ii][Tt][Yy] -- -> SYM_INFINITY
    984 #         }
    985 #         #
    986 #         # DADL::RootScanner
    987 #         #
    988 #         class RootScanner
    989 #           include Yaparc::Parsable
    990 #           def initialize
    991 #             @parser = lambda do |input|
    992 #               Yaparc::Alt.new(Reserved.new,
    993 #                               OpenEhr::ADL::Scanner::Common::V_QUALIFIED_TERM_CODE_REF.new,
    994 #                               OpenEhr::ADL::Scanner::Common::V_LOCAL_TERM_CODE_REF.new,
    995 #                               OpenEhr::ADL::Scanner::Common::ERR_V_QUALIFIED_TERM_CODE_REF.new,
    996 #                               OpenEhr::ADL::Scanner::Common::V_TYPE_IDENTIFIER.new,
    997 #                               OpenEhr::ADL::Scanner::Common::V_GENERIC_TYPE_IDENTIFIER.new,
    998 #                               OpenEhr::ADL::Scanner::Common::V_STRING.new,
    999 #                               OpenEhr::ADL::Scanner::Common::V_LOCAL_CODE.new,
    1000 #                               OpenEhr::ADL::Scanner::Common::V_REAL.new,
    1001 #                               OpenEhr::ADL::Scanner::Common::V_ISO8601_DURATION.new#,
    1002 #                               #OpenEhr::ADL::Scanner::Common::START_TERM_CODE_CONSTRAINT.new
    1003 #                               )
    1004 #             end
    1005 #           end
    1006 #         end
    1007 
    1008 #         #  <DADL::Reserved class>
    1009 #         class Reserved
    1010 #           include Yaparc::Parsable
    1011          
    1012 #           def initialize
    1013 #             @parser = lambda do |input|
    1014 #               reserved_parsers = OpenEhr::ADL::Scanner::DADL::RESERVED.map do |keyword|
    1015 #                 Yaparc::Tokenize.new(
    1016 #                                      Yaparc::Literal.new(keyword[0],false)
    1017 #                                      )
    1018 #               end
    1019 #               Yaparc::Alt.new(Yaparc::Apply.new(Yaparc::Alt.new(*reserved_parsers)) do |match|
    1020 #                                 OpenEhr::LOG.info("Reserved: #{match}")
    1021 #                                 [OpenEhr::ADL::Scanner::DADL::RESERVED[match], OpenEhr::ADL::Scanner::DADL::RESERVED[match]]
    1022 #                               end,
    1023 #                               Yaparc::Apply.new(Yaparc::Regex.new(/\A[a-z][a-zA-Z0-9_]*/)) do |match|
    1024 #                                 OpenEhr::LOG.info("V_ATTRIBUTE_IDENTIFIER: #{match}")
    1025 #                                 [:V_ATTRIBUTE_IDENTIFIER, match]
    1026 #                               end)
    1027 #             end
    1028 #           end
    1029 #         end
    1030 #       end # of DADL
    1031 
    1032 #       module CADL
    1033 #         # c.f. http://www.openehr.org/svn/ref_impl_eiffel/TRUNK/components/adl_parser/src/syntax/cadl/parser/cadl_scanner.l
    1034 #         RESERVED = {
    1035 #           'ordered' => :SYM_ORDERED, # [Oo][Rr][Dd][Ee][Rr][Ee][Dd]
    1036 #           'unordered' => :SYM_UNORDERED, # [Uu][Nn][Oo][Rr][Dd][Ee][Rr][Ee][Dd]
    1037 #           'then' => :SYM_THEN, # [Tt][Hh][Ee][Nn]
    1038 #           'else' => :SYM_ELSE, # [Ee][Ll][Ss][Ee]
    1039 #           'and' => :SYM_AND, # [Aa][Nn][Dd]
    1040 #           'or' => :SYM_OR, # [Oo][Rr]
    1041 #           'xor' => :SYM_XOR, # [Xx][Oo][Rr]
    1042 #           'not' => :SYM_NOT, # [Nn][Oo][Tt]
    1043 #           'implies' => :SYM_IMPLIES, # [Ii][Mm][Pp][Ll][Ii][Ee][Ss]
    1044 #           'true' => :SYM_TRUE, #[Tt][Rr][Uu][Ee] -- -> SYM_TRUE
    1045 #           'false' => :SYM_FALSE, # [Ff][Aa][Ll][Ss][Ee] -- -> SYM_FALSE
    1046 #           'forall' => :SYM_FORALL, # [Ff][Oo][Rr][_][Aa][Ll][Ll]
    1047 #           'exists' => :SYM_EXISTS, # [Ee][Xx][Ii][Ss][Tt][Ss]
    1048 #           'existence' => :SYM_EXISTENCE, # [Ee][Xx][Iu][Ss][Tt][Ee][Nn][Cc][Ee]
    1049 #           'occurrences' => :SYM_OCCURRENCES, # [Oo][Cc][Cc][Uu][Rr][Rr][Ee][Nn][Cc][Ee][Ss]
    1050 #           'cardinality' => :SYM_CARDINALITY, # [Cc][Aa][Rr][Dd][Ii][Nn][Aa][Ll][Ii][Tt][Yy]
    1051 #           'unique' => :SYM_UNIQUE, # [Uu][Nn][Ii][Qq][Uu][Ee]
    1052 #           'matches' => :SYM_MATCHES, # [Mm][Aa][Tt][Cc][Hh][Ee][Ss]
    1053 #           'is_in' => :SYM_MATCHES, # [Ii][Ss][_][Ii][Nn]
    1054 #           'invariant' => :SYM_INVARIANT, # [Ii][Nn][Vv][Aa][Rr][Ii][Aa][Nn][Tt]
    1055 #           'infinity' => :SYM_INFINITY, # [Ii][Nn][Ff][Ii][Nn][Ii][Tt][Yy] -- -> SYM_INFINITY
    1056 #           'use_node' => :SYM_USE_NODE, # [Uu][Ss][Ee][_][Nn][Oo][Dd][Ee]
    1057 #           'use_archetype' => :SYM_ALLOW_ARCHETYPE, # [Uu][Ss][Ee][_][Aa][Rr][Cc][Hh][Ee][Tt][Yy][Pp][Ee]
    1058 #           'allow_archetype' => :SYM_ALLOW_ARCHETYPE, # [Aa][Ll][Ll][Oo][Ww][_][Aa][Rr][Cc][Hh][Ee][Tt][Yy][Pp][Ee]
    1059 #           'include' => :SYM_INCLUDE, # [Ii][Nn][Cc][Ll][Uu][Dd][Ee]
    1060 #           'exclude' => :SYM_EXCLUDE # [Ee][Xx][Cc][Ll][Uu][Dd][Ee]
    1061 #         }
    1062 
    1063 #         #V_ISO8601_DATE_TIME_CONSTRAINT_PATTERN, /\A[yY][yY][yY][yY]-[mM?X][mM?X]-[dD?X][dD?X][T\t][hH?X][hH?X]:[mM?X][mM?X]:[sS?X][sS?X]/
    1064 #         class V_ISO8601_DATE_TIME_CONSTRAINT_PATTERN
    1065 #           include Yaparc::Parsable
    1066 #           def initialize
    1067 #             @parser = lambda do |input|
    1068 #               Yaparc::Apply.new(Yaparc::Regex.new(/\A[yY][yY][yY][yY]-[mM?X][mM?X]-[dD?X][dD?X][T\t][hH?X][hH?X]:[mM?X][mM?X]:[sS?X][sS?X]/)) do |match|
    1069 #                 OpenEhr::LOG.info("V_ISO8601_DATE_TIME_CONSTRAINT_PATTERN: #{match}")
    1070 #                 [:V_ISO8601_DATE_TIME_CONSTRAINT_PATTERN, match]
    1071 #               end
    1072 #             end
    1073 #           end
    1074 #         end
    1075 
    1076 #         #V_ISO8601_DATE_CONSTRAINT_PATTERN  /\A[yY][yY][yY][yY]-[mM?X][mM?X]-[dD?X][dD?X]/
    1077 #         class V_ISO8601_DATE_CONSTRAINT_PATTERN
    1078 #           include Yaparc::Parsable
    1079 #           def initialize
    1080 #             @parser = lambda do |input|
    1081 #               Yaparc::Apply.new(Yaparc::Regex.new(/\A[yY][yY][yY][yY]-[mM?X][mM?X]-[dD?X][dD?X]/)) do |match|
    1082 #                 OpenEhr::LOG.info("V_ISO8601_DATE_CONSTRAINT_PATTERN: #{match}")
    1083 #                 [:V_ISO8601_DATE_CONSTRAINT_PATTERN, match]
    1084 #               end
    1085 #             end
    1086 #           end
    1087 #         end
    1088 
    1089 #         #V_ISO8601_TIME_CONSTRAINT_PATTERN /\A[hH][hH]:[mM?X][mM?X]:[sS?X][sS?X]/
    1090 #         class V_ISO8601_TIME_CONSTRAINT_PATTERN
    1091 #           include Yaparc::Parsable
    1092 #           def initialize
    1093 #             @parser = lambda do |input|
    1094 #               Yaparc::Apply.new(Yaparc::Regex.new(/\A[hH][hH]:[mM?X][mM?X]:[sS?X][sS?X]/)) do |match|
    1095 #                 OpenEhr::LOG.info("V_ISO8601_TIME_CONSTRAINT_PATTERN: #{match}")
    1096 #                 [:V_ISO8601_TIME_CONSTRAINT_PATTERN, match]
    1097 #               end
    1098 #             end
    1099 #           end
    1100 #         end
    1101 
    1102 #         #V_ISO8601_DURATION_CONSTRAINT_PATTERN
    1103 #         class V_ISO8601_DURATION_CONSTRAINT_PATTERN
    1104 #           include Yaparc::Parsable
    1105 #           def initialize
    1106 #             @parser = lambda do |input|
    1107 #               Yaparc::Apply.new(Yaparc::Alt.new(Yaparc::Regex.new(/\AP[yY]?[mM]?[wW]?[dD]?T[hH]?[mM]?[sS]?/),
    1108 #                                                 Yaparc::Regex.new(/\AP[yY]?[mM]?[wW]?[dD]?/))) do |match|
    1109 #                 OpenEhr::LOG.info("V_ISO8601_DURATION_CONSTRAINT_PATTERN: #{match}")
    1110 #                 [:V_ISO8601_DURATION_CONSTRAINT_PATTERN, match]
    1111 #               end
    1112 #             end
    1113 #           end
    1114 #         end
    1115 
    1116 #         #V_C_DOMAIN_TYPE /\A[A-Z][a-zA-Z0-9_]*[ \n]*\</
    1117 #         class V_C_DOMAIN_TYPE
    1118 #           include Yaparc::Parsable
    1119 #           def initialize
    1120 #             @parser = lambda do |input|
    1121 #               Yaparc::Apply.new(Yaparc::Regex.new(/\A[A-Z][a-zA-Z0-9_]*[ \n]*\</)) do |match|
    1122 #                 OpenEhr::LOG.info("V_C_DOMAIN_TYPE: #{match}")
    1123 #                 [:START_V_C_DOMAIN_TYPE_BLOCK, match]
    1124 #               end
    1125 #             end
    1126 #           end
    1127 #         end
    1128 
    1129 #         #
    1130 #         # CADL::RootScanner
    1131 #         #
    1132 #         class RootScanner
    1133 #           include Yaparc::Parsable
    1134 #           def initialize
    1135 #             @parser = lambda do |input|
    1136 #               Yaparc::Alt.new(V_ISO8601_DATE_TIME_CONSTRAINT_PATTERN.new,
    1137 #                               V_ISO8601_DATE_CONSTRAINT_PATTERN.new,
    1138 #                               V_ISO8601_TIME_CONSTRAINT_PATTERN.new,
    1139 #                               OpenEhr::ADL::Scanner::Common::V_ISO8601_DURATION.new,
    1140 #                               V_C_DOMAIN_TYPE.new,
    1141 #                               V_ISO8601_DURATION_CONSTRAINT_PATTERN.new,
    1142 #                               Reserved.new,
    1143 #                               OpenEhr::ADL::Scanner::Common::V_QUALIFIED_TERM_CODE_REF.new,
    1144 #                               OpenEhr::ADL::Scanner::Common::V_LOCAL_TERM_CODE_REF.new,
    1145 #                               OpenEhr::ADL::Scanner::Common::ERR_V_QUALIFIED_TERM_CODE_REF.new,
    1146 #                               OpenEhr::ADL::Scanner::Common::V_TYPE_IDENTIFIER.new,
    1147 #                               OpenEhr::ADL::Scanner::Common::V_GENERIC_TYPE_IDENTIFIER.new,
    1148 #                               OpenEhr::ADL::Scanner::Common::V_STRING.new,
    1149 #                               OpenEhr::ADL::Scanner::Common::V_LOCAL_CODE.new,
    1150 #                               OpenEhr::ADL::Scanner::Common::V_REAL.new,
    1151 #                               OpenEhr::ADL::Scanner::Common::V_ISO8601_DURATION.new#,
    1152 #                               #OpenEhr::ADL::Scanner::Common::START_TERM_CODE_CONSTRAINT.new
    1153 #                               )
    1154 #             end
    1155 #           end
    1156 #         end
    1157 
    1158 #         # <CADL::Reserved class>
    1159 #         class Reserved
    1160 #           include Yaparc::Parsable
    1161          
    1162 #           def initialize
    1163 #             @parser = lambda do |input|
    1164 #               orderd_reserved = RESERVED.keys.sort{|x,y| y.length <=> x.length  }
    1165 #               reserved_parsers = orderd_reserved.map do |keyword|
    1166 #                 Yaparc::Literal.new(keyword,false)
    1167 #               end
    1168 #               Yaparc::Alt.new(Yaparc::Apply.new(Yaparc::Alt.new(*reserved_parsers)) do |match|
    1169 #                                 OpenEhr::LOG.info("Reserved: #{match}")
    1170 #                                 [OpenEhr::ADL::Scanner::CADL::RESERVED[match], OpenEhr::ADL::Scanner::CADL::RESERVED[match]]
    1171 #                               end,
    1172 #                               Yaparc::Apply.new(Yaparc::Regex.new(/\A[a-z][a-zA-Z0-9_]*/)) do |match|
    1173 #                                 OpenEhr::LOG.info("V_ATTRIBUTE_IDENTIFIER: #{match}")
    1174 #                                 [:V_ATTRIBUTE_IDENTIFIER, match]
    1175 #                               end)
    1176 #             end
    1177 #           end
    1178 #         end
    1179 
    1180 #       end
    1181 
    1182 
Note: See TracChangeset for help on using the changeset viewer.