source: ruby/trunk/lib/adl_parser/lib/adl_scanner.rb @ 261

Last change on this file since 261 was 261, checked in by Tatsukawa, Akimichi, 11 years ago

renamed scanner.rb to adl_scanner.rb

File size: 14.4 KB
Line 
1require 'rubygems'
2gem 'yaparc'
3require 'yaparc'
4
5
6module OpenEHR
7  module ADL
8    module Scanner
9      module Common
10        class START_TERM_CODE_CONSTRAINT
11          include Yaparc::Parsable
12          def initialize
13            @parser = lambda do |input|
14              Yaparc::Apply.new(Yaparc::Regex.new(/[ \t\n]*\[([a-zA-Z0-9\(\)\._\-]+)::[ \t\n]*/)) do |match|
15                OpenEHR::LOG.info("START_TERM_CODE_CONSTRAINT: #{match}")
16                [:START_TERM_CODE_CONSTRAINT, match]
17              end
18            end
19          end
20        end
21
22        # /\A\[[a-zA-Z0-9()\._-]+::[a-zA-Z0-9\._-]+\]/  #V_QUALIFIED_TERM_CODE_REF form [ICD10AM(1998)::F23]
23        class V_QUALIFIED_TERM_CODE_REF
24          include Yaparc::Parsable
25          def initialize
26            @parser = lambda do |input|
27              Yaparc::Apply.new(Yaparc::Regex.new(/\A\[[a-zA-Z0-9()\._-]+::[a-zA-Z0-9\._-]+\]/)) do |match|
28                OpenEHR::LOG.info("V_QUALIFIED_TERM_CODE_REF: #{match}")
29                [:V_QUALIFIED_TERM_CODE_REF, match]
30              end
31            end
32          end
33        end
34       
35        class V_LOCAL_TERM_CODE_REF
36          include Yaparc::Parsable
37          def initialize
38            @parser = lambda do |input|
39              Yaparc::Apply.new(Yaparc::Regex.new(/\A\[[a-zA-Z0-9][a-zA-Z0-9._\-]*\]/)) do |match|
40                OpenEHR::LOG.info("V_TERM_CODE_REF: #{match}")
41                [:V_LOCAL_TERM_CODE_REF, match]
42              end
43            end
44          end
45        end
46
47        class ERR_V_QUALIFIED_TERM_CODE_REF
48          include Yaparc::Parsable
49          def initialize
50            @parser = lambda do |input|
51              Yaparc::Apply.new(Yaparc::Regex.new(/\A\[[a-zA-Z0-9._\- ]+::[a-zA-Z0-9._\- ]+\]/)) do |match|
52                OpenEHR::LOG.info("ERR_V_QUALIFIED_TERM_CODE_REF: #{match}")
53                [:ERR_V_QUALIFIED_TERM_CODE_REF, match]
54              end
55            end
56          end
57        end
58
59        class V_TYPE_IDENTIFIER
60          include Yaparc::Parsable
61          def initialize
62            @parser = lambda do |input|
63              Yaparc::Apply.new(Yaparc::Regex.new(/\A[A-Z][a-zA-Z0-9_]*/)) do |match|
64                OpenEHR::LOG.info("V_TYPE_IDENTIFIER: #{match}")
65                [:V_TYPE_IDENTIFIER, match]
66              end
67            end
68          end
69        end
70
71        class V_GENERIC_TYPE_IDENTIFIER
72          include Yaparc::Parsable
73          def initialize
74            @parser = lambda do |input|
75              Yaparc::Apply.new(Yaparc::Regex.new(/\A[A-Z][a-zA-Z0-9_]*<[a-zA-Z0-9,_<>]+>/)) do |match|
76                OpenEHR::LOG.info("V_GENERIC_TYPE_IDENTIFIER: #{match}")
77                [:V_GENERIC_TYPE_IDENTIFIER, match]
78              end
79            end
80          end
81        end
82
83
84        class V_LOCAL_CODE
85          include Yaparc::Parsable
86          def initialize
87            @parser = lambda do |input|
88              Yaparc::Apply.new(Yaparc::Regex.new(/\Aa[ct][0-9.]+/)) do |match|
89                OpenEHR::LOG.info("V_LOCAL_CODE: #{match}")
90                [:V_LOCAL_CODE, match]
91              end
92            end
93          end
94        end
95
96        class V_STRING
97          include Yaparc::Parsable
98          def initialize
99            @parser = lambda do |input|
100              Yaparc::Apply.new(Yaparc::Regex.new(/\A"([^"]*)"/m)) do |match|
101                OpenEHR::LOG.info("V_STRING: #{match}")
102                [:V_STRING, match]
103              end
104            end
105          end
106        end
107
108        class V_REAL
109          include Yaparc::Parsable
110          def initialize
111            @parser = lambda do |input|
112              Yaparc::Apply.new(Yaparc::Regex.new(/\A[0-9]+\.[0-9]+|[0-9]+\.[0-9]+[eE][+-]?[0-9]+/)) do |match|
113                OpenEHR::LOG.info("V_REAL: #{match}")
114                [:V_REAL, match]
115              end
116            end
117          end
118        end
119
120        #V_ISO8601_DURATION PnYnMnWnDTnnHnnMnnS
121        class V_ISO8601_DURATION
122          include Yaparc::Parsable
123          def initialize
124            @parser = lambda do |input|
125              Yaparc::Apply.new(
126                                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])?/),
127                                                Yaparc::Regex.new(/\AP([0-9]+|[yY])?([0-9]+|[mM])?([0-9]+|[wW])?([0-9]+|[dD])?/))) do |match|
128                OpenEHR::LOG.info("V_ISO8601_DURATION: #{match}")
129                [:V_ISO8601_DURATION, match]
130              end
131            end
132          end
133        end
134
135      end # of Common
136
137      module DADL
138        # c.f. http://www.openehr.org/svn/ref_impl_eiffel/TRUNK/components/adl_parser/src/syntax/adl/parser/adl_scanner.l
139        RESERVED = {
140          'true' => :SYM_TRUE, #[Tt][Rr][Uu][Ee] -- -> SYM_TRUE
141          'false' => :SYM_FALSE, # [Ff][Aa][Ll][Ss][Ee] -- -> SYM_FALSE
142          'infinity' => :SYM_INFINITY # [Ii][Nn][Ff][Ii][Nn][Ii][Tt][Yy] -- -> SYM_INFINITY
143        }
144        #
145        # DADL::RootScanner
146        #
147        class RootScanner
148          include Yaparc::Parsable
149          def initialize
150            @parser = lambda do |input|
151              Yaparc::Alt.new(Reserved.new,
152                              OpenEHR::ADL::Scanner::Common::V_QUALIFIED_TERM_CODE_REF.new,
153                              OpenEHR::ADL::Scanner::Common::V_LOCAL_TERM_CODE_REF.new,
154                              OpenEHR::ADL::Scanner::Common::ERR_V_QUALIFIED_TERM_CODE_REF.new,
155                              OpenEHR::ADL::Scanner::Common::V_TYPE_IDENTIFIER.new,
156                              OpenEHR::ADL::Scanner::Common::V_GENERIC_TYPE_IDENTIFIER.new,
157                              OpenEHR::ADL::Scanner::Common::V_STRING.new,
158                              OpenEHR::ADL::Scanner::Common::V_LOCAL_CODE.new,
159                              OpenEHR::ADL::Scanner::Common::V_REAL.new,
160                              OpenEHR::ADL::Scanner::Common::V_ISO8601_DURATION.new#,
161                              #OpenEHR::ADL::Scanner::Common::START_TERM_CODE_CONSTRAINT.new
162                              )
163            end
164          end
165        end
166
167        #  <DADL::Reserved class>
168        class Reserved
169          include Yaparc::Parsable
170         
171          def initialize
172            @parser = lambda do |input|
173              reserved_parsers = OpenEHR::ADL::Scanner::DADL::RESERVED.map do |keyword| 
174                Yaparc::Tokenize.new(
175                                     Yaparc::Literal.new(keyword[0],false)
176                                     )
177              end
178              Yaparc::Alt.new(Yaparc::Apply.new(Yaparc::Alt.new(*reserved_parsers)) do |match|
179                                OpenEHR::LOG.info("Reserved: #{match}")
180                                [OpenEHR::ADL::Scanner::DADL::RESERVED[match], OpenEHR::ADL::Scanner::DADL::RESERVED[match]]
181                              end,
182                              Yaparc::Apply.new(Yaparc::Regex.new(/\A[a-z][a-zA-Z0-9_]*/)) do |match|
183                                OpenEHR::LOG.info("V_ATTRIBUTE_IDENTIFIER: #{match}")
184                                [:V_ATTRIBUTE_IDENTIFIER, match]
185                              end)
186            end
187          end
188        end
189      end # of DADL
190
191      module CADL
192        # c.f. http://www.openehr.org/svn/ref_impl_eiffel/TRUNK/components/adl_parser/src/syntax/cadl/parser/cadl_scanner.l
193        RESERVED = {
194          'ordered' => :SYM_ORDERED, # [Oo][Rr][Dd][Ee][Rr][Ee][Dd]
195          'unordered' => :SYM_UNORDERED, # [Uu][Nn][Oo][Rr][Dd][Ee][Rr][Ee][Dd]
196          'then' => :SYM_THEN, # [Tt][Hh][Ee][Nn]
197          'else' => :SYM_ELSE, # [Ee][Ll][Ss][Ee]
198          'and' => :SYM_AND, # [Aa][Nn][Dd]
199          'or' => :SYM_OR, # [Oo][Rr]
200          'xor' => :SYM_XOR, # [Xx][Oo][Rr]
201          'not' => :SYM_NOT, # [Nn][Oo][Tt]
202          'implies' => :SYM_IMPLIES, # [Ii][Mm][Pp][Ll][Ii][Ee][Ss]
203          'true' => :SYM_TRUE, #[Tt][Rr][Uu][Ee] -- -> SYM_TRUE
204          'false' => :SYM_FALSE, # [Ff][Aa][Ll][Ss][Ee] -- -> SYM_FALSE
205          'forall' => :SYM_FORALL, # [Ff][Oo][Rr][_][Aa][Ll][Ll]
206          'exists' => :SYM_EXISTS, # [Ee][Xx][Ii][Ss][Tt][Ss]
207          'existence' => :SYM_EXISTENCE, # [Ee][Xx][Iu][Ss][Tt][Ee][Nn][Cc][Ee]
208          'occurrences' => :SYM_OCCURRENCES, # [Oo][Cc][Cc][Uu][Rr][Rr][Ee][Nn][Cc][Ee][Ss]
209          'cardinality' => :SYM_CARDINALITY, # [Cc][Aa][Rr][Dd][Ii][Nn][Aa][Ll][Ii][Tt][Yy]
210          'unique' => :SYM_UNIQUE, # [Uu][Nn][Ii][Qq][Uu][Ee]
211          'matches' => :SYM_MATCHES, # [Mm][Aa][Tt][Cc][Hh][Ee][Ss]
212          'is_in' => :SYM_MATCHES, # [Ii][Ss][_][Ii][Nn]
213          'invariant' => :SYM_INVARIANT, # [Ii][Nn][Vv][Aa][Rr][Ii][Aa][Nn][Tt]
214          'infinity' => :SYM_INFINITY, # [Ii][Nn][Ff][Ii][Nn][Ii][Tt][Yy] -- -> SYM_INFINITY
215          'use_node' => :SYM_USE_NODE, # [Uu][Ss][Ee][_][Nn][Oo][Dd][Ee]
216          'use_archetype' => :SYM_ALLOW_ARCHETYPE, # [Uu][Ss][Ee][_][Aa][Rr][Cc][Hh][Ee][Tt][Yy][Pp][Ee]
217          'allow_archetype' => :SYM_ALLOW_ARCHETYPE, # [Aa][Ll][Ll][Oo][Ww][_][Aa][Rr][Cc][Hh][Ee][Tt][Yy][Pp][Ee]
218          'include' => :SYM_INCLUDE, # [Ii][Nn][Cc][Ll][Uu][Dd][Ee]
219          'exclude' => :SYM_EXCLUDE # [Ee][Xx][Cc][Ll][Uu][Dd][Ee]
220        }
221
222        #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]/
223        class V_ISO8601_DATE_TIME_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][T\t][hH?X][hH?X]:[mM?X][mM?X]:[sS?X][sS?X]/)) do |match|
228                OpenEHR::LOG.info("V_ISO8601_DATE_TIME_CONSTRAINT_PATTERN: #{match}")
229                [:V_ISO8601_DATE_TIME_CONSTRAINT_PATTERN, match]
230              end
231            end
232          end
233        end
234
235        #V_ISO8601_DATE_CONSTRAINT_PATTERN  /\A[yY][yY][yY][yY]-[mM?X][mM?X]-[dD?X][dD?X]/
236        class V_ISO8601_DATE_CONSTRAINT_PATTERN
237          include Yaparc::Parsable
238          def initialize
239            @parser = lambda do |input|
240              Yaparc::Apply.new(Yaparc::Regex.new(/\A[yY][yY][yY][yY]-[mM?X][mM?X]-[dD?X][dD?X]/)) do |match|
241                OpenEHR::LOG.info("V_ISO8601_DATE_CONSTRAINT_PATTERN: #{match}")
242                [:V_ISO8601_DATE_CONSTRAINT_PATTERN, match]
243              end
244            end
245          end
246        end
247
248        #V_ISO8601_TIME_CONSTRAINT_PATTERN /\A[hH][hH]:[mM?X][mM?X]:[sS?X][sS?X]/
249        class V_ISO8601_TIME_CONSTRAINT_PATTERN
250          include Yaparc::Parsable
251          def initialize
252            @parser = lambda do |input|
253              Yaparc::Apply.new(Yaparc::Regex.new(/\A[hH][hH]:[mM?X][mM?X]:[sS?X][sS?X]/)) do |match|
254                OpenEHR::LOG.info("V_ISO8601_TIME_CONSTRAINT_PATTERN: #{match}")
255                [:V_ISO8601_TIME_CONSTRAINT_PATTERN, match]
256              end
257            end
258          end
259        end
260
261        #V_ISO8601_DURATION_CONSTRAINT_PATTERN
262        class V_ISO8601_DURATION_CONSTRAINT_PATTERN
263          include Yaparc::Parsable
264          def initialize
265            @parser = lambda do |input|
266              Yaparc::Apply.new(Yaparc::Alt.new(Yaparc::Regex.new(/\AP[yY]?[mM]?[wW]?[dD]?T[hH]?[mM]?[sS]?/),
267                                                Yaparc::Regex.new(/\AP[yY]?[mM]?[wW]?[dD]?/))) do |match|
268                OpenEHR::LOG.info("V_ISO8601_DURATION_CONSTRAINT_PATTERN: #{match}")
269                [:V_ISO8601_DURATION_CONSTRAINT_PATTERN, match]
270              end
271            end
272          end
273        end
274
275        #V_C_DOMAIN_TYPE /\A[A-Z][a-zA-Z0-9_]*[ \n]*\</
276        class V_C_DOMAIN_TYPE
277          include Yaparc::Parsable
278          def initialize
279            @parser = lambda do |input|
280              Yaparc::Apply.new(Yaparc::Regex.new(/\A[A-Z][a-zA-Z0-9_]*[ \n]*\</)) do |match|
281                OpenEHR::LOG.info("V_C_DOMAIN_TYPE: #{match}")
282                [:START_V_C_DOMAIN_TYPE_BLOCK, match]
283              end
284            end
285          end
286        end
287
288        #
289        # CADL::RootScanner
290        #
291        class RootScanner
292          include Yaparc::Parsable
293          def initialize
294            @parser = lambda do |input|
295              Yaparc::Alt.new(V_ISO8601_DATE_TIME_CONSTRAINT_PATTERN.new,
296                              V_ISO8601_DATE_CONSTRAINT_PATTERN.new,
297                              V_ISO8601_TIME_CONSTRAINT_PATTERN.new,
298                              OpenEHR::ADL::Scanner::Common::V_ISO8601_DURATION.new,
299                              V_C_DOMAIN_TYPE.new,
300                              V_ISO8601_DURATION_CONSTRAINT_PATTERN.new,
301                              Reserved.new,
302                              OpenEHR::ADL::Scanner::Common::V_QUALIFIED_TERM_CODE_REF.new,
303                              OpenEHR::ADL::Scanner::Common::V_LOCAL_TERM_CODE_REF.new,
304                              OpenEHR::ADL::Scanner::Common::ERR_V_QUALIFIED_TERM_CODE_REF.new,
305                              OpenEHR::ADL::Scanner::Common::V_TYPE_IDENTIFIER.new,
306                              OpenEHR::ADL::Scanner::Common::V_GENERIC_TYPE_IDENTIFIER.new,
307                              OpenEHR::ADL::Scanner::Common::V_STRING.new,
308                              OpenEHR::ADL::Scanner::Common::V_LOCAL_CODE.new,
309                              OpenEHR::ADL::Scanner::Common::V_REAL.new,
310                              OpenEHR::ADL::Scanner::Common::V_ISO8601_DURATION.new#,
311                              #OpenEHR::ADL::Scanner::Common::START_TERM_CODE_CONSTRAINT.new
312                              )
313            end
314          end
315        end
316
317=begin <CADL::Reserved class>
318=end
319        class Reserved
320          include Yaparc::Parsable
321         
322          def initialize
323            @parser = lambda do |input|
324              orderd_reserved = RESERVED.keys.sort{|x,y| y.length <=> x.length  }
325              reserved_parsers = orderd_reserved.map do |keyword| 
326                Yaparc::Literal.new(keyword,false)
327              end
328              Yaparc::Alt.new(Yaparc::Apply.new(Yaparc::Alt.new(*reserved_parsers)) do |match|
329                                OpenEHR::LOG.info("Reserved: #{match}")
330                                [OpenEHR::ADL::Scanner::CADL::RESERVED[match], OpenEHR::ADL::Scanner::CADL::RESERVED[match]]
331                              end,
332                              Yaparc::Apply.new(Yaparc::Regex.new(/\A[a-z][a-zA-Z0-9_]*/)) do |match|
333                                OpenEHR::LOG.info("V_ATTRIBUTE_IDENTIFIER: #{match}")
334                                [:V_ATTRIBUTE_IDENTIFIER, match]
335                              end)
336            end
337          end
338        end
339
340      end
341    end
342  end
343end
Note: See TracBrowser for help on using the repository browser.