Ignore:
Timestamp:
Apr 29, 2008, 3:04:36 AM (16 years ago)
Author:
Tatsukawa, Akimichi
Message:

successful parsing 25 archtypes

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r18 r19  
    88  module ADL
    99    module Scanner
     10      module Common
     11        LOG = Logger.new('log/scanner.log','daily')
     12
     13        class V_QUALIFIED_TERM_CODE_REF
     14          include Yaparc::Parsable
     15          def initialize
     16            @parser = lambda do |input|
     17              Yaparc::Apply.new(Yaparc::Regex.new(/\A\[[a-zA-Z0-9()\._-]+::[a-zA-Z0-9\._-]+\]/)) do |match|
     18                LOG.info("V_QUALIFIED_TERM_CODE_REF: #{match}")
     19                [:V_QUALIFIED_TERM_CODE_REF, match]
     20              end
     21            end
     22          end
     23        end
     24       
     25        class V_LOCAL_TERM_CODE_REF
     26          include Yaparc::Parsable
     27          def initialize
     28            @parser = lambda do |input|
     29              Yaparc::Apply.new(Yaparc::Regex.new(/\A\[[a-zA-Z0-9][a-zA-Z0-9._\-]*\]/)) do |match|
     30                LOG.info("V_TERM_CODE_REF: #{match}")
     31                [:V_LOCAL_TERM_CODE_REF, match]
     32              end
     33            end
     34          end
     35        end
     36
     37        class ERR_V_QUALIFIED_TERM_CODE_REF
     38          include Yaparc::Parsable
     39          def initialize
     40            @parser = lambda do |input|
     41              Yaparc::Apply.new(Yaparc::Regex.new(/\A\[[a-zA-Z0-9._\- ]+::[a-zA-Z0-9._\- ]+\]/)) do |match|
     42                LOG.info("ERR_V_QUALIFIED_TERM_CODE_REF: #{match}")
     43                [:ERR_V_QUALIFIED_TERM_CODE_REF, match]
     44              end
     45            end
     46          end
     47        end
     48
     49        class V_TYPE_IDENTIFIER
     50          include Yaparc::Parsable
     51          def initialize
     52            @parser = lambda do |input|
     53              Yaparc::Apply.new(Yaparc::Regex.new(/\A[A-Z][a-zA-Z0-9_]*/)) do |match|
     54                LOG.info("V_TYPE_IDENTIFIER: #{match}")
     55                [:V_TYPE_IDENTIFIER, match]
     56              end
     57            end
     58          end
     59        end
     60
     61        class V_GENERIC_TYPE_IDENTIFIER
     62          include Yaparc::Parsable
     63          def initialize
     64            @parser = lambda do |input|
     65              Yaparc::Apply.new(Yaparc::Regex.new(/\A[A-Z][a-zA-Z0-9_]*<[a-zA-Z0-9,_<>]+>/)) do |match|
     66                LOG.info("V_GENERIC_TYPE_IDENTIFIER: #{match}")
     67                [:V_GENERIC_TYPE_IDENTIFIER, match]
     68              end
     69            end
     70          end
     71        end
     72
     73
     74        class V_LOCAL_CODE
     75          include Yaparc::Parsable
     76          def initialize
     77            @parser = lambda do |input|
     78              Yaparc::Apply.new(Yaparc::Regex.new(/\Aa[ct][0-9.]+/)) do |match|
     79                LOG.info("V_LOCAL_CODE: #{match}")
     80                [:V_LOCAL_CODE, match]
     81              end
     82            end
     83          end
     84        end
     85
     86        class V_STRING
     87          include Yaparc::Parsable
     88          def initialize
     89            @parser = lambda do |input|
     90              Yaparc::Apply.new(Yaparc::Regex.new(/\A"([^"]*)"/m)) do |match|
     91                LOG.info("V_STRING: #{match}")
     92                [:V_STRING, match]
     93              end
     94            end
     95          end
     96        end
     97
     98        class V_REAL
     99          include Yaparc::Parsable
     100          def initialize
     101            @parser = lambda do |input|
     102              Yaparc::Apply.new(Yaparc::Regex.new(/\A[0-9]+\.[0-9]+|[0-9]+\.[0-9]+[eE][+-]?[0-9]+/)) do |match|
     103                LOG.info("V_REAL: #{match}")
     104                [:V_REAL, match]
     105              end
     106            end
     107          end
     108        end
     109
     110        #V_ISO8601_DURATION PnYnMnWnDTnnHnnMnnS
     111        class V_ISO8601_DURATION
     112          include Yaparc::Parsable
     113          def initialize
     114            @parser = lambda do |input|
     115              Yaparc::Apply.new(
     116                                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])?/),
     117                                                Yaparc::Regex.new(/AP([0-9]+[yY])?([0-9]+[mM])?([0-9]+[wW])?([0-9]+[dD])?/))) do |match|
     118                LOG.info("V_ISO8601_DURATION: #{match}")
     119                [:V_ISO8601_DURATION, match]
     120              end
     121            end
     122          end
     123        end
     124
     125      end # of Common
     126
    10127      module DADL
    11128        # c.f. http://www.openehr.org/svn/ref_impl_eiffel/TRUNK/components/adl_parser/src/syntax/adl/parser/adl_scanner.l
    … …  
    16133        }
    17134
    18         LOG = Logger.new('log/scanner.log','daily')
    19 
    20135        class RootScanner
    21136          include Yaparc::Parsable
    … …  
    23138            @parser = lambda do |input|
    24139              Yaparc::Alt.new(Reserved.new,
    25                               V_QUALIFIED_TERM_CODE_REF.new,
    26                               V_LOCAL_TERM_CODE_REF.new,
    27                               ERR_V_QUALIFIED_TERM_CODE_REF.new,
    28                               V_TYPE_IDENTIFIER.new,
    29                               V_GENERIC_TYPE_IDENTIFIER.new,
    30                               V_STRING.new,
    31                               V_LOCAL_CODE.new,
    32                               V_REAL.new
     140                              OpenEHR::ADL::Scanner::Common::V_QUALIFIED_TERM_CODE_REF.new,
     141                              OpenEHR::ADL::Scanner::Common::V_LOCAL_TERM_CODE_REF.new,
     142                              OpenEHR::ADL::Scanner::Common::ERR_V_QUALIFIED_TERM_CODE_REF.new,
     143                              OpenEHR::ADL::Scanner::Common::V_TYPE_IDENTIFIER.new,
     144                              OpenEHR::ADL::Scanner::Common::V_GENERIC_TYPE_IDENTIFIER.new,
     145                              OpenEHR::ADL::Scanner::Common::V_STRING.new,
     146                              OpenEHR::ADL::Scanner::Common::V_LOCAL_CODE.new,
     147                              OpenEHR::ADL::Scanner::Common::V_REAL.new,
     148                              OpenEHR::ADL::Scanner::Common::V_ISO8601_DURATION.new
    33149                              )
    34150            end
    … …  
    42158            @parser = lambda do |input|
    43159              reserved_parsers = OpenEHR::ADL::Scanner::DADL::RESERVED.map do |keyword|
    44                 Yaparc::Tokenize.new(Yaparc::Literal.new(keyword))
     160                Yaparc::Tokenize.new(Yaparc::Literal.new(keyword[0], false))
    45161              end
    46162              Yaparc::Alt.new(Yaparc::Apply.new(Yaparc::Alt.new(*reserved_parsers)) do |match|
    47                                 LOG.info("Reserved: #{match}")
     163                                OpenEHR::ADL::Scanner::Common::LOG.info("Reserved: #{match}")
    48164                                [OpenEHR::ADL::Scanner::DADL::RESERVED[match], OpenEHR::ADL::Scanner::DADL::RESERVED[match]]
    49165                              end,
    50166                              Yaparc::Apply.new(Yaparc::Regex.new(/\A[a-z][a-zA-Z0-9_]*/)) do |match|
    51                                 LOG.info("V_ATTRIBUTE_IDENTIFIER: #{match}")
     167                                OpenEHR::ADL::Scanner::Common::LOG.info("V_ATTRIBUTE_IDENTIFIER: #{match}")
    52168                                [:V_ATTRIBUTE_IDENTIFIER, match]
    53169                              end)
    … …  
    56172        end
    57173
    58         class V_QUALIFIED_TERM_CODE_REF
    59           include Yaparc::Parsable
    60           def initialize
    61             @parser = lambda do |input|
    62               Yaparc::Apply.new(Yaparc::Regex.new(/\A\[[a-zA-Z0-9()\._-]+::[a-zA-Z0-9\._-]+\]/)) do |match|
    63                 LOG.info("V_QUALIFIED_TERM_CODE_REF: #{match}")
    64                 [:V_QUALIFIED_TERM_CODE_REF, match]
    65               end
    66             end
    67           end
    68         end
    69 
    70         class V_LOCAL_TERM_CODE_REF
    71           include Yaparc::Parsable
    72           def initialize
    73             @parser = lambda do |input|
    74               Yaparc::Apply.new(Yaparc::Regex.new(/\A\[[a-zA-Z0-9][a-zA-Z0-9._\-]*\]/)) do |match|
    75                 LOG.info("V_TERM_CODE_REF: #{match}")
    76                 [:V_LOCAL_TERM_CODE_REF, match]
    77               end
    78             end
    79           end
    80         end
    81 
    82         class ERR_V_QUALIFIED_TERM_CODE_REF
    83           include Yaparc::Parsable
    84           def initialize
    85             @parser = lambda do |input|
    86               Yaparc::Apply.new(Yaparc::Regex.new(/\A\[[a-zA-Z0-9._\- ]+::[a-zA-Z0-9._\- ]+\]/)) do |match|
    87                 LOG.info("ERR_V_QUALIFIED_TERM_CODE_REF: #{match}")
    88                 [:ERR_V_QUALIFIED_TERM_CODE_REF, match]
    89               end
    90             end
    91           end
    92         end
    93 
    94         class V_TYPE_IDENTIFIER
    95           include Yaparc::Parsable
    96           def initialize
    97             @parser = lambda do |input|
    98               Yaparc::Apply.new(Yaparc::Regex.new(/\A[A-Z][a-zA-Z0-9_]*/)) do |match|
    99                 LOG.info("V_TYPE_IDENTIFIER: #{match}")
    100                 [:V_TYPE_IDENTIFIER, match]
    101               end
    102             end
    103           end
    104         end
    105 
    106         class V_GENERIC_TYPE_IDENTIFIER
    107           include Yaparc::Parsable
    108           def initialize
    109             @parser = lambda do |input|
    110               Yaparc::Apply.new(Yaparc::Regex.new(/\A[A-Z][a-zA-Z0-9_]*<[a-zA-Z0-9,_<>]+>/)) do |match|
    111                 LOG.info("V_GENERIC_TYPE_IDENTIFIER: #{match}")
    112                 [:V_GENERIC_TYPE_IDENTIFIER, match]
    113               end
    114             end
    115           end
    116         end
    117 
    118 
    119         class V_LOCAL_CODE
    120           include Yaparc::Parsable
    121           def initialize
    122             @parser = lambda do |input|
    123               Yaparc::Apply.new(Yaparc::Regex.new(/\Aa[ct][0-9.]+/)) do |match|
    124                 LOG.info("V_LOCAL_CODE: #{match}")
    125                 [:V_LOCAL_CODE, match]
    126               end
    127             end
    128           end
    129         end
    130 
    131         class V_STRING
    132           include Yaparc::Parsable
    133           def initialize
    134             @parser = lambda do |input|
    135               Yaparc::Apply.new(Yaparc::Regex.new(/\A"([^"]*)"/m)) do |match|
    136                 LOG.info("V_STRING: #{match}")
    137                 [:V_STRING, match]
    138               end
    139             end
    140           end
    141         end
    142 
    143         class V_REAL
    144           include Yaparc::Parsable
    145           def initialize
    146             @parser = lambda do |input|
    147               Yaparc::Apply.new(Yaparc::Regex.new(/\A[0-9]+\.[0-9]+|[0-9]+\.[0-9]+[eE][+-]?[0-9]+/)) do |match|
    148                 LOG.info("V_REAL: #{match}")
    149                 [:V_REAL, match]
    150               end
    151             end
    152           end
    153         end
     174
    154175
    155176      end # of DADL
    … …  
    157178      module CADL
    158179        # c.f. http://www.openehr.org/svn/ref_impl_eiffel/TRUNK/components/adl_parser/src/syntax/cadl/parser/cadl_scanner.l
     180        RESERVED = {
     181          'ordered' => :SYM_ORDERED, # [Oo][Rr][Dd][Ee][Rr][Ee][Dd]
     182          'unordered' => :SYM_UNORDERED, # [Uu][Nn][Oo][Rr][Dd][Ee][Rr][Ee][Dd]
     183          'then' => :SYM_THEN, # [Tt][Hh][Ee][Nn]
     184          'else' => :SYM_ELSE, # [Ee][Ll][Ss][Ee]
     185          'and' => :SYM_AND, # [Aa][Nn][Dd]
     186          'or' => :SYM_OR, # [Oo][Rr]
     187          'xor' => :SYM_XOR, # [Xx][Oo][Rr]
     188          'not' => :SYM_NOT, # [Nn][Oo][Tt]
     189          'implies' => :SYM_IMPLIES, # [Ii][Mm][Pp][Ll][Ii][Ee][Ss]
     190          'true' => :SYM_TRUE, #[Tt][Rr][Uu][Ee] -- -> SYM_TRUE
     191          'false' => :SYM_FALSE, # [Ff][Aa][Ll][Ss][Ee] -- -> SYM_FALSE
     192          'forall' => :SYM_FORALL, # [Ff][Oo][Rr][_][Aa][Ll][Ll]
     193          'exists' => :SYM_EXISTS, # [Ee][Xx][Ii][Ss][Tt][Ss]
     194          'existence' => :SYM_EXISTENCE, # [Ee][Xx][Iu][Ss][Tt][Ee][Nn][Cc][Ee]
     195          'occurrences' => :SYM_OCCURRENCES, # [Oo][Cc][Cc][Uu][Rr][Rr][Ee][Nn][Cc][Ee][Ss]
     196          'cardinality' => :SYM_CARDINALITY, # [Cc][Aa][Rr][Dd][Ii][Nn][Aa][Ll][Ii][Tt][Yy]
     197          'unique' => :SYM_UNIQUE, # [Uu][Nn][Ii][Qq][Uu][Ee]
     198          'matches' => :SYM_MATCHES, # [Mm][Aa][Tt][Cc][Hh][Ee][Ss]
     199          'is_in' => :SYM_MATCHES, # [Ii][Ss][_][Ii][Nn]
     200          'invariant' => :SYM_INVARIANT, # [Ii][Nn][Vv][Aa][Rr][Ii][Aa][Nn][Tt]
     201          'infinity' => :SYM_INFINITY, # [Ii][Nn][Ff][Ii][Nn][Ii][Tt][Yy] -- -> SYM_INFINITY
     202          'use_node' => :SYM_USE_NODE, # [Uu][Ss][Ee][_][Nn][Oo][Dd][Ee]
     203          'use_archetype' => :SYM_ALLOW_ARCHETYPE, # [Uu][Ss][Ee][_][Aa][Rr][Cc][Hh][Ee][Tt][Yy][Pp][Ee]
     204          'allow_archetype' => :SYM_ALLOW_ARCHETYPE, # [Aa][Ll][Ll][Oo][Ww][_][Aa][Rr][Cc][Hh][Ee][Tt][Yy][Pp][Ee]
     205          'include' => :SYM_INCLUDE, # [Ii][Nn][Cc][Ll][Uu][Dd][Ee]
     206          'exclude' => :SYM_EXCLUDE # [Ee][Xx][Cc][Ll][Uu][Dd][Ee]
     207        }
     208
     209        #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]/
     210        class V_ISO8601_DATE_TIME_CONSTRAINT_PATTERN
     211          include Yaparc::Parsable
     212          def initialize
     213            @parser = lambda do |input|
     214              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|
     215                OpenEHR::ADL::Scanner::Common::LOG.info("V_ISO8601_DATE_TIME_CONSTRAINT_PATTERN: #{match}")
     216                [:V_ISO8601_DATE_TIME_CONSTRAINT_PATTERN, match]
     217              end
     218            end
     219          end
     220        end
     221
     222        #V_ISO8601_DATE_CONSTRAINT_PATTERN  /\A[yY][yY][yY][yY]-[mM?X][mM?X]-[dD?X][dD?X]/
     223        class V_ISO8601_DATE_CONSTRAINT_PATTERN
     224          include Yaparc::Parsable
     225          def initialize
     226            @parser = lambda do |input|
     227              Yaparc::Apply.new(Yaparc::Regex.new(/\A[yY][yY][yY][yY]-[mM?X][mM?X]-[dD?X][dD?X]/)) do |match|
     228                OpenEHR::ADL::Scanner::Common::LOG.info("V_ISO8601_DATE_CONSTRAINT_PATTERN: #{match}")
     229                [:V_ISO8601_DATE_CONSTRAINT_PATTERN, match]
     230              end
     231            end
     232          end
     233        end
     234
     235        #V_ISO8601_TIME_CONSTRAINT_PATTERN /\A[hH][hH]:[mM?X][mM?X]:[sS?X][sS?X]/
     236        class V_ISO8601_TIME_CONSTRAINT_PATTERN
     237          include Yaparc::Parsable
     238          def initialize
     239            @parser = lambda do |input|
     240              Yaparc::Apply.new(Yaparc::Regex.new(/\A[hH][hH]:[mM?X][mM?X]:[sS?X][sS?X]/)) do |match|
     241                OpenEHR::ADL::Scanner::Common::LOG.info("V_ISO8601_TIME_CONSTRAINT_PATTERN: #{match}")
     242                [:V_ISO8601_TIME_CONSTRAINT_PATTERN, match]
     243              end
     244            end
     245          end
     246        end
     247
     248        #V_C_DOMAIN_TYPE /\A[A-Z][a-zA-Z0-9_]*[ \n]*\</
     249        class V_C_DOMAIN_TYPE
     250          include Yaparc::Parsable
     251          def initialize
     252            @parser = lambda do |input|
     253              Yaparc::Apply.new(Yaparc::Regex.new(/\A[A-Z][a-zA-Z0-9_]*[ \n]*\</)) do |match|
     254                OpenEHR::ADL::Scanner::Common::LOG.info("V_C_DOMAIN_TYPE: #{match}")
     255                [:START_V_C_DOMAIN_TYPE_BLOCK, match]
     256              end
     257#               parser = Yaparc::Regex.new(/\A[A-Z][a-zA-Z0-9_]*[ \n]*\</)
     258#               case result = parser.parse(input)
     259#               when Yaparc::Result::OK
     260#                 OpenEHR::ADL::Scanner::Common::LOG.info("V_C_DOMAIN_TYPE: #{result.value}")
     261#                 Yaparc::Result::Fail.new
     262#               else
     263#                 Yaparc::Result::Fail.new
     264#               end
     265            end
     266          end
     267        end
     268
     269        class RootScanner
     270          include Yaparc::Parsable
     271          def initialize
     272            @parser = lambda do |input|
     273              Yaparc::Alt.new(V_ISO8601_DATE_TIME_CONSTRAINT_PATTERN.new,
     274                              V_ISO8601_DATE_CONSTRAINT_PATTERN.new,
     275                              V_ISO8601_TIME_CONSTRAINT_PATTERN.new,
     276                              OpenEHR::ADL::Scanner::Common::V_ISO8601_DURATION.new,
     277                              V_C_DOMAIN_TYPE.new,
     278                              Reserved.new,
     279                              OpenEHR::ADL::Scanner::Common::V_QUALIFIED_TERM_CODE_REF.new,
     280                              OpenEHR::ADL::Scanner::Common::V_LOCAL_TERM_CODE_REF.new,
     281                              OpenEHR::ADL::Scanner::Common::ERR_V_QUALIFIED_TERM_CODE_REF.new,
     282                              OpenEHR::ADL::Scanner::Common::V_TYPE_IDENTIFIER.new,
     283                              OpenEHR::ADL::Scanner::Common::V_GENERIC_TYPE_IDENTIFIER.new,
     284                              OpenEHR::ADL::Scanner::Common::V_STRING.new,
     285                              OpenEHR::ADL::Scanner::Common::V_LOCAL_CODE.new,
     286                              OpenEHR::ADL::Scanner::Common::V_REAL.new,
     287                              OpenEHR::ADL::Scanner::Common::V_ISO8601_DURATION.new
     288                              )
     289            end
     290          end
     291        end
     292
     293        class Reserved
     294          include Yaparc::Parsable
     295         
     296          def initialize
     297            @parser = lambda do |input|
     298              orderd_reserved = RESERVED.keys.sort{|x,y| y.length <=> x.length  }
     299              reserved_parsers = orderd_reserved.map do |keyword|
     300                Yaparc::Literal.new(keyword, false)
     301              end
     302              Yaparc::Alt.new(Yaparc::Apply.new(Yaparc::Alt.new(*reserved_parsers)) do |match|
     303                                OpenEHR::ADL::Scanner::Common::LOG.info("Reserved: #{match}")
     304                                [OpenEHR::ADL::Scanner::CADL::RESERVED[match], OpenEHR::ADL::Scanner::CADL::RESERVED[match]]
     305                              end,
     306                              Yaparc::Apply.new(Yaparc::Regex.new(/\A[a-z][a-zA-Z0-9_]*/)) do |match|
     307                                OpenEHR::ADL::Scanner::Common::LOG.info("V_ATTRIBUTE_IDENTIFIER: #{match}")
     308                                [:V_ATTRIBUTE_IDENTIFIER, match]
     309                              end)
     310            end
     311          end
     312        end
     313
    159314      end
    160315    end
Note: See TracChangeset for help on using the changeset viewer.