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, 15 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.