/[eiffelstudio]/branches/CAT_mono/Src/framework/parser/AST/factory/ast_factory.e
ViewVC logotype

Contents of /branches/CAT_mono/Src/framework/parser/AST/factory/ast_factory.e

Parent Directory Parent Directory | Revision Log Revision Log


Revision 69650 - (show annotations)
Tue Jul 24 17:18:14 2007 UTC (12 years, 4 months ago) by juliant
File size: 53039 byte(s)
Added monomorph mark for class types, either "frozen" or "invariant".
First (simple) conformance check for monomorphic types.
1 indexing
2
3 description: "AST node factories"
4 legal: "See notice at end of class."
5 status: "See notice at end of class."
6 date: "$Date$"
7 revision: "$Revision$"
8
9 class AST_FACTORY
10
11 feature -- Buffer operation
12
13 set_buffer (a_buf: STRING; a_scn: YY_SCANNER_SKELETON) is
14 -- Clear `a_buf' and then set it with `a_scn'.text.
15 require
16 a_buf_not_void: a_buf /= Void
17 a_scn_not_void: a_scn /= Void
18 do
19 end
20
21 append_text_to_buffer (a_buf: STRING; a_scn: YY_SCANNER_SKELETON) is
22 -- Append `a_scn'.text to end of buffer `a_buf'.
23 require
24 a_buf_not_void: a_buf /= Void
25 a_scn_not_void: a_scn /= Void
26 do
27 end
28
29 append_string_to_buffer (a_buf: STRING; a_str: STRING) is
30 -- Append `a_str' to end of buffer `a_buf'.
31 require
32 a_buf_not_void: a_buf /= Void
33 a_str_not_void: a_str /= Void
34 do
35 end
36
37 feature -- Roundtrip: Match list maintaining
38
39 match_list: LEAF_AS_LIST
40 -- List of LEAF_AS nodes.
41
42 match_list_count: INTEGER
43 -- Number of elements in `internal_match_list'
44
45 match_list_count_backup: INTEGER
46 -- Backup value of `match_list_count' as it was when the last time `backup_match_list_count' is called.
47
48 create_match_list (l_size: INTEGER) is
49 -- Create a new `match_list' with initial `l_size'.
50 require
51 l_size_positive: l_size > 0
52 do
53 end
54
55 extend_match_list (a_match: LEAF_AS) is
56 -- Extend `internal_match_list' with `a_match'.
57 do
58 end
59
60 extend_match_list_with_stub (a_stub: LEAF_STUB_AS) is
61 -- Extend `match_list' with stub `a_stub',
62 -- and set index in `a_match'.
63 do
64 end
65
66 backup_match_list_count is
67 -- Backup value of `match_list_count' into `match_list_count_backup'.
68 do
69 end
70
71 resume_match_list_count is
72 -- Resume the value of `match_list_count_backup' and set `match_list_count' with it.
73 do
74 end
75
76 enable_match_list_extension is
77 -- Enable extension of `match_list'.
78 do
79 is_match_list_extension_disabled := False
80 ensure
81 match_list_extension_enabled: is_match_list_extension_enabled
82 end
83
84 disable_match_list_extension is
85 -- Disable extension of `match_list'.
86 do
87 is_match_list_extension_disabled := True
88 ensure
89 match_list_extension_disabled: not is_match_list_extension_enabled
90 end
91
92 is_match_list_extension_enabled: BOOLEAN is
93 -- Is match list extension enabled?
94 do
95 Result := not is_match_list_extension_disabled
96 end
97
98 is_match_list_extension_disabled: BOOLEAN
99 -- Is match list extension disabled?
100
101 feature -- Roundtrip
102
103 reverse_extend_separator (a_list: EIFFEL_LIST [AST_EIFFEL]; l_as: AST_EIFFEL) is
104 -- Add `l_as' into `a_list'.separator_list in reverse order.
105 do
106 end
107
108 reverse_extend_identifier (a_list: EIFFEL_LIST [AST_EIFFEL]; l_as: ID_AS) is
109 -- Add `l_as' into `a_list'.
110 do
111 end
112
113 feature -- Access
114
115 new_agent_routine_creation_as (t: OPERAND_AS; f: ID_AS; o: DELAYED_ACTUAL_LIST_AS; is_qualified: BOOLEAN; a_as: KEYWORD_AS; d_as: SYMBOL_AS): AGENT_ROUTINE_CREATION_AS is
116 -- New AGENT_ROUTINE_CREATION AST node.
117 do
118 create Result.make (t, f, o, is_qualified, a_as, d_as)
119 end
120
121 new_tilda_routine_creation_as (t: OPERAND_AS; f: ID_AS; o: DELAYED_ACTUAL_LIST_AS; is_qualified: BOOLEAN; a_as: SYMBOL_AS): TILDA_ROUTINE_CREATION_AS is
122 -- New AGENT_ROUTINE_CREATION AST node.
123 do
124 create Result.make (t, f, o, is_qualified, a_as)
125 end
126
127 new_inline_agent_creation_as (a_b: BODY_AS; a_o: DELAYED_ACTUAL_LIST_AS; a_as: KEYWORD_AS): INLINE_AGENT_CREATION_AS is
128 -- New INLINE_AGENT_CREATION AST node.
129 do
130 if a_b /= Void then
131 create Result.make (a_b, a_o, a_as)
132 end
133 end
134
135 new_create_creation_as (tp: TYPE_AS; tg: ACCESS_AS; c: ACCESS_INV_AS; k_as: KEYWORD_AS): CREATE_CREATION_AS is
136 -- New CREATE_CREATION AST node.
137 do
138 if tg /= Void then
139 create Result.make (tp, tg, c, k_as)
140 end
141 end
142
143 new_bang_creation_as (tp: TYPE_AS; tg: ACCESS_AS; c: ACCESS_INV_AS; l_as, r_as: SYMBOL_AS): BANG_CREATION_AS is
144 -- New CREATE_CREATION AST node.
145 do
146 create Result.make (tp, tg, c, l_as, r_as)
147 end
148
149 new_create_creation_expr_as (t: TYPE_AS; c: ACCESS_INV_AS; k_as: KEYWORD_AS): CREATE_CREATION_EXPR_AS is
150 -- New creation expression AST node
151 do
152 if t /= Void then
153 create Result.make (t, c, k_as)
154 end
155 end
156
157 new_bang_creation_expr_as (t: TYPE_AS; c: ACCESS_INV_AS; l_as, r_as: SYMBOL_AS): BANG_CREATION_EXPR_AS is
158 -- New creation expression AST node
159 do
160 if t /= Void then
161 create Result.make (t, c, l_as, r_as)
162 end
163 end
164
165 new_assigner_mark_as (k_as: KEYWORD_AS; i_as: ID_AS): PAIR [KEYWORD_AS, ID_AS] is
166 -- New pair of assigner_mark structure.
167 do
168 create Result.make (k_as, i_as)
169 end
170
171 new_filled_none_id_as (l, c, p, s: INTEGER): NONE_ID_AS is
172 -- New empty ID AST node.
173 require
174 l_non_negative: l >= 0
175 c_non_negative: c >= 0
176 p_non_negative: p >= 0
177 s_non_negative: s >= 0
178 do
179 create Result.make
180 Result.set_position (l, c, p, s)
181 end
182
183 new_constraint_triple (k_as: SYMBOL_AS; t_as: CONSTRAINT_LIST_AS; l_as: CREATION_CONSTRAIN_TRIPLE): CONSTRAINT_TRIPLE is
184 -- New constraint triple structure.
185 do
186 create Result.make (k_as, t_as, l_as)
187 end
188
189 new_constraining_type (a_type_as: TYPE_AS; a_renameing_clause_as: RENAME_CLAUSE_AS; a_comma_as: KEYWORD_AS): CONSTRAINING_TYPE_AS is
190 -- New constraining type structure.
191 do
192 if a_type_as /= Void then
193 create Result.make (a_type_as, a_renameing_clause_as, a_comma_as)
194 end
195 end
196
197 new_eiffel_list_constraining_type_as (n: INTEGER): CONSTRAINT_LIST_AS is
198 -- New empty list of `CONSTRAINING_TYPE_AS'
199 require
200 n_non_negative: n >= 0
201 do
202 create Result.make (n)
203 ensure
204 list_full: Result /= Void implies Result.capacity = n and Result.all_default
205 end
206
207 new_alias_triple (k_as: KEYWORD_AS; n_as: STRING_AS; c_as: KEYWORD_AS): ALIAS_TRIPLE is
208 -- New ALIST_TRIPLE.
209 do
210 create Result.make (k_as, n_as, c_as)
211 end
212
213 new_agent_target_triple (l_as, r_as: SYMBOL_AS; o_as: OPERAND_AS): AGENT_TARGET_TRIPLE is
214 -- New ALIST_TRIPLE.
215 do
216 create Result.make (l_as, r_as, o_as)
217 end
218
219 new_keyword_instruction_list_pair (k_as: KEYWORD_AS; i_as: EIFFEL_LIST [INSTRUCTION_AS]):PAIR [KEYWORD_AS, EIFFEL_LIST [INSTRUCTION_AS]] is
220 -- New ALIST_TRIPLE.
221 do
222 create Result.make (k_as, i_as)
223 end
224
225 new_keyword_string_pair (k_as: KEYWORD_AS; s_as: STRING_AS):PAIR [KEYWORD_AS, STRING_AS] is
226 -- New ALIST_TRIPLE.
227 do
228 create Result.make (k_as, s_as)
229 end
230
231 new_invariant_pair (k_as: KEYWORD_AS; i_as: EIFFEL_LIST [TAGGED_AS]): PAIR [KEYWORD_AS, EIFFEL_LIST [TAGGED_AS]] is
232 -- New PAIR for a keyword and a tagged_as list.
233 do
234 create Result.make (k_as, i_as)
235 end
236
237 new_typed_char_as (t_as: TYPE_AS; c: CHARACTER_32; l, co, p, n: INTEGER; a_text: STRING): TYPED_CHAR_AS is
238 -- New TYPED_CHAR AST node.
239 do
240 create Result.initialize (t_as, c, l, co, p, n)
241 end
242
243 new_line_pragma (a_scn: EIFFEL_SCANNER): BREAK_AS is
244 -- New line pragma
245 --| Keep entire line, actual processing will be done later if we need it.
246 do
247 create Result.make (a_scn.text, a_scn.line, a_scn.column, a_scn.position, a_scn.text_count)
248 end
249
250 feature -- Access for Errors
251
252 new_vtgc1_error (a_line: INTEGER; a_column: INTEGER; a_filename: STRING; a_id: ID_AS; a_current: CURRENT_AS): ERROR
253 -- New vtgc1 error.
254 require
255 a_id_or_a_current_not_void: a_id /= Void xor a_current /= Void
256 local
257 l_identifier: STRING
258 do
259 if a_id /=Void then
260 l_identifier := a_id.name
261 elseif a_current /= Void then
262 l_identifier := "Current"
263 end
264 check l_identifier_not_void: l_identifier /= Void end
265
266 Result := create {SYNTAX_ERROR}.make (a_line, a_column, a_filename, "Errog VTGC1: Anchored types is are not allowed as a constraint:%N %"like " + l_identifier + "%"", false)
267 end
268
269 feature -- Value AST creation
270
271 new_character_value (a_psr: EIFFEL_PARSER_SKELETON; a_type: TYPE_AS; buffer: STRING; a_text: STRING): CHAR_AS is
272 -- New character value.
273 require
274 buffer_not_void: buffer /= Void
275 a_text_not_void: a_text /= Void
276 a_psr_not_void: a_psr /= Void
277 local
278 l_integer: INTEGER_AS
279 l_code: STRING
280 do
281 if buffer.count = 1 then
282 if a_type = Void then
283 Result := new_character_as (buffer.item (1), a_psr.line, a_psr.column, a_psr.position, a_text.count, a_text)
284 else
285 Result := new_typed_char_as (a_type, buffer.item (1), a_psr.line, a_psr.column, a_psr.position, 1, a_text)
286 end
287 else
288 l_code := buffer.substring (4, buffer.count - 1)
289 backup_match_list_count
290 disable_match_list_extension
291 l_integer := new_integer_value (a_psr, '+', Void, l_code, Void)
292 enable_match_list_extension
293 resume_match_list_count
294 if l_integer.natural_64_value <= {NATURAL_8}.Max_value then
295 if a_type = Void then
296 Result := new_character_as (l_integer.natural_8_value.to_character_8, a_psr.line, a_psr.column, a_psr.position, a_text.count, a_text)
297 else
298 Result := new_typed_char_as (a_type, l_integer.natural_8_value.to_character_8, a_psr.line, a_psr.column, a_psr.position, a_text.count, a_text)
299 end
300 elseif l_integer.natural_64_value <= {NATURAL_32}.Max_value then
301 if a_type = Void then
302 Result := new_character_as (l_integer.natural_32_value.to_character_32, a_psr.line, a_psr.column, a_psr.position, a_text.count, a_text)
303 else
304 Result := new_typed_char_as (a_type, l_integer.natural_32_value.to_character_32, a_psr.line, a_psr.column, a_psr.position, a_text.count, a_text)
305 end
306 else
307 a_psr.report_character_code_too_large_error (l_code)
308
309 -- Dummy code (for error recovery) follows:
310 Result := new_character_as ('a', 0, 0, 0, 0, "")
311 end
312 end
313 end
314
315 new_integer_value (a_psr: EIFFEL_PARSER_SKELETON; sign_symbol: CHARACTER; a_type: TYPE_AS; buffer: STRING; s_as: SYMBOL_AS): INTEGER_AS is
316 -- New integer value.
317 require
318 buffer_not_void: buffer /= Void
319 valid_sign: ("%U+-").has (sign_symbol)
320 a_psr_not_void: a_psr /= Void
321 local
322 token_value: STRING
323 do
324 validate_integer_real_type (a_psr, a_type, buffer, True)
325 -- Remember original token
326 token_value := buffer.twin
327 -- Remove underscores (if any) without breaking
328 -- original token
329 if token_value.has ('_') then
330 token_value := token_value.twin
331 token_value.prune_all ('_')
332 end
333 if token_value.is_number_sequence then
334 Result := new_integer_as (a_type, sign_symbol = '-', token_value, buffer, s_as, a_psr.line, a_psr.column, a_psr.position, a_psr.text_count)
335 elseif token_value.count >= 3 and then token_value.item (1) = '0' then
336 if token_value.item (2).lower = 'x' then
337 Result := new_integer_hexa_as (a_type, sign_symbol, token_value, buffer, s_as, a_psr.line, a_psr.column, a_psr.position, a_psr.text_count)
338 elseif token_value.item (2).lower = 'c' then
339 Result := new_integer_octal_as (a_type, sign_symbol, token_value, buffer, s_as, a_psr.line, a_psr.column, a_psr.position, a_psr.text_count)
340 elseif token_value.item (2).lower = 'b' then
341 Result := new_integer_binary_as (a_type, sign_symbol, token_value, buffer, s_as, a_psr.line, a_psr.column, a_psr.position, a_psr.text_count)
342 end
343 end
344 if Result = Void or else not Result.is_initialized then
345 if sign_symbol = '-' then
346 -- Add `-' for a better reporting.
347 buffer.precede ('-')
348 a_psr.report_integer_too_small_error (a_type, buffer)
349 else
350 a_psr.report_integer_too_large_error (a_type, buffer)
351 end
352 -- Dummy code (for error recovery) follows:
353 Result := new_integer_as (a_type, False, "0", Void, s_as, 0, 0, 0, 0)
354 end
355 end
356
357 new_real_value (a_psr: EIFFEL_PARSER_SKELETON; is_signed: BOOLEAN; sign_symbol: CHARACTER; a_type: TYPE_AS; buffer: STRING; s_as: SYMBOL_AS): REAL_AS is
358 -- New real value.
359 require
360 buffer_not_void: buffer /= Void
361 a_psr_not_void: a_psr /= Void
362 local
363 l_buffer: STRING
364 do
365 validate_integer_real_type (a_psr, a_type, buffer, False)
366 if is_signed and sign_symbol = '-' then
367 l_buffer := buffer.twin
368 buffer.precede ('-')
369 else
370 l_buffer := buffer
371 end
372 Result := new_real_as (a_type, buffer, l_buffer, s_as, a_psr.line, a_psr.column, a_psr.position, a_psr.text_count)
373 end
374
375 feature {NONE} -- Validation
376
377 validate_integer_real_type (a_psr: EIFFEL_PARSER_SKELETON; a_type: TYPE_AS; buffer: STRING; for_integer: BOOLEAN) is
378 -- New integer value.
379 require
380 buffer_not_void: buffer /= Void
381 a_psr_not_void: a_psr /= Void
382 do
383 -- We cannot validate the name easily, so we assume it is correct.
384 if for_integer then
385 else
386 end
387 end
388
389 feature -- Roundtrip: leaf_as
390
391 new_keyword_as (a_code: INTEGER; a_scn: EIFFEL_SCANNER): KEYWORD_AS is
392 -- New KEYWORD AST node
393 require
394 a_scn_not_void: a_scn /= Void
395 do
396 end
397
398 new_feature_keyword_as (l, c, p, s:INTEGER; a_scn: EIFFEL_SCANNER): KEYWORD_AS is
399 -- New KEYWORD AST node for keyword "feature".
400 require
401 l_non_negative: l >= 0
402 c_non_negative: c >= 0
403 p_non_negative: p >= 0
404 s_non_negative: s >= 0
405 a_scn_not_void: a_scn /= Void
406 do
407 create Result.make_with_location (l, c, p, s)
408 end
409
410 new_creation_keyword_as (a_scn: EIFFEL_SCANNER): KEYWORD_AS is
411 -- New KEYWORD AST node for keyword "creation'
412 require
413 a_scn_not_void: a_scn /= Void
414 do
415 create Result.make_with_location (a_scn.line, a_scn.column, a_scn.position, a_scn.text_count)
416 end
417
418 new_end_keyword_as (a_scn: EIFFEL_SCANNER): KEYWORD_AS is
419 -- New KEYWORD AST node for keyword "end'
420 require
421 a_scn_not_void: a_scn /= Void
422 do
423 create Result.make_with_location (a_scn.line, a_scn.column, a_scn.position, a_scn.text_count)
424 end
425
426 new_frozen_keyword_as (a_scn: EIFFEL_SCANNER): KEYWORD_AS is
427 -- New KEYWORD AST node for keyword "frozen'
428 require
429 a_scn_not_void: a_scn /= Void
430 do
431 create Result.make_with_location (a_scn.line, a_scn.column, a_scn.position, a_scn.text_count)
432 end
433
434 new_infix_keyword_as (a_scn: EIFFEL_SCANNER): KEYWORD_AS is
435 -- New KEYWORD AST node for keyword "infix'
436 require
437 a_scn_not_void: a_scn /= Void
438 do
439 create Result.make_with_location (a_scn.line, a_scn.column, a_scn.position, a_scn.text_count)
440 end
441
442 new_precursor_keyword_as (a_scn: EIFFEL_SCANNER): KEYWORD_AS is
443 -- New KEYWORD AST node for keyword "precursor'.
444 require
445 a_scn_not_void: a_scn /= Void
446 do
447 create Result.make_with_location (a_scn.line, a_scn.column, a_scn.position, a_scn.text_count)
448 end
449
450 new_prefix_keyword_as (a_scn: EIFFEL_SCANNER): KEYWORD_AS is
451 -- New KEYWORD AST node for keyword "prefix'.
452 require
453 a_scn_not_void: a_scn /= Void
454 do
455 create Result.make_with_location (a_scn.line, a_scn.column, a_scn.position, a_scn.text_count)
456 end
457
458 new_once_string_keyword_as (a_text: STRING; l, c, p, n: INTEGER): KEYWORD_AS is
459 -- New KEYWORD AST node
460 require
461 l_non_negative: l >= 0
462 c_non_negative: c >= 0
463 p_non_negative: p >= 0
464 n_non_negative: n >= 0
465 a_text_not_void: a_text /= Void
466 a_text_not_empty: not a_text.is_empty
467 do
468 end
469
470 new_symbol_as (a_code: INTEGER; a_scn: EIFFEL_SCANNER): SYMBOL_AS is
471 -- New symbol AST node for all Eiffel symbols except ";", "[" and "]"
472 require
473 a_scn_not_void: a_scn /= Void
474 do
475 end
476
477 new_square_symbol_as (a_code: INTEGER; a_scn: EIFFEL_SCANNER): SYMBOL_AS is
478 -- New symbol AST node only for symbol "[" and "]"
479 require
480 a_scn_not_void: a_scn /= Void
481 a_code_is_squre: a_code = {EIFFEL_TOKENS}.te_lsqure or a_code = {EIFFEL_TOKENS}.te_rsqure
482 do
483 create Result.make (a_code, a_scn.line, a_scn.column, a_scn.position, 1)
484 end
485
486 create_break_as (a_scn: EIFFEL_SCANNER) is
487 -- NEw BREAK_AS node
488 do
489 end
490
491 create_break_as_with_data (a_text: STRING; l, c, p, n: INTEGER) is
492 -- New COMMENT_AS node
493 require
494 l_non_negative: l >= 0
495 c_non_negative: c >= 0
496 p_non_negative: p >= 0
497 n_non_negative: n >= 0
498 a_text_not_void: a_text /= Void
499 do
500 end
501
502 feature -- Access
503
504 new_access_assert_as (f: ID_AS; p: PARAMETER_LIST_AS): ACCESS_ASSERT_AS is
505 -- New ACCESS_ASSERT AST node
506 do
507 if f /= Void then
508 create Result.initialize (f, p)
509 end
510 end
511
512 new_access_feat_as (f: ID_AS; p: PARAMETER_LIST_AS): ACCESS_FEAT_AS is
513 -- New ACCESS_FEAT AST node
514 do
515 if f /= Void then
516 create Result.initialize (f, p)
517 end
518 end
519
520 new_access_id_as (f: ID_AS; p: PARAMETER_LIST_AS): ACCESS_ID_AS is
521 -- New ACCESS_ID AST node
522 do
523 if f /= Void then
524 create Result.initialize (f, p)
525 end
526 end
527
528 new_access_inv_as (f: ID_AS; p: PARAMETER_LIST_AS; k_as: SYMBOL_AS): ACCESS_INV_AS is
529 -- New ACCESS_INV AST node
530 do
531 if f /= Void then
532 create Result.make (f, p, k_as)
533 end
534 end
535
536 new_address_as (f: FEATURE_NAME; a_as: SYMBOL_AS): ADDRESS_AS is
537 -- New ADDRESS AST node
538 do
539 if f /= Void then
540 create Result.initialize (f, a_as)
541 end
542 end
543
544 new_address_current_as (other: CURRENT_AS; a_as: SYMBOL_AS): ADDRESS_CURRENT_AS is
545 -- New ADDRESS_CURRENT AST node
546 do
547 if other /= Void then
548 create Result.initialize (other, a_as)
549 end
550 end
551
552 new_address_result_as (other: RESULT_AS; a_as: SYMBOL_AS): ADDRESS_RESULT_AS is
553 -- New ADDRESS_RESULT AST node
554 do
555 if other /= Void then
556 create Result.initialize (other, a_as)
557 end
558 end
559
560 new_all_as (a_as: KEYWORD_AS): ALL_AS is
561 -- New ALL AST node
562 do
563 create Result.initialize (a_as)
564 end
565
566 new_array_as (exp: EIFFEL_LIST [EXPR_AS]; l_as, r_as: SYMBOL_AS): ARRAY_AS is
567 -- New Manifest ARRAY AST node
568 do
569 if exp /= Void then
570 create Result.initialize (exp, l_as, r_as)
571 end
572 end
573
574 new_assign_as (t: ACCESS_AS; s: EXPR_AS; a_as: SYMBOL_AS): ASSIGN_AS is
575 -- New ASSIGN AST node
576 do
577 if t /= Void and s /= Void then
578 create Result.initialize (t, s, a_as)
579 end
580 end
581
582 new_assigner_call_as (t: EXPR_AS; s: EXPR_AS; a_as: SYMBOL_AS): ASSIGNER_CALL_AS is
583 -- New ASSIGNER CALL AST node
584 do
585 if t /= Void and s /= Void then
586 create Result.initialize (t, s, a_as)
587 end
588 end
589
590 new_bin_and_as (l, r: EXPR_AS; o: AST_EIFFEL): BIN_AND_AS is
591 -- New binary and AST node
592 do
593 if l /= Void and r /= Void then
594 create Result.initialize (l, r, o)
595 end
596 end
597
598 new_bin_and_then_as (l, r: EXPR_AS; k_as, s_as: KEYWORD_AS): BIN_AND_THEN_AS is
599 -- New binary and then AST node
600 do
601 if l /= Void and r /= Void then
602 create Result.initialize (l, r, Void)
603 end
604 end
605
606 new_bin_div_as (l, r: EXPR_AS; o: AST_EIFFEL): BIN_DIV_AS is
607 -- New binary // AST node
608 do
609 if l /= Void and r /= Void then
610 create Result.initialize (l, r, o)
611 end
612 end
613
614 new_bin_eq_as (l, r: EXPR_AS; o: AST_EIFFEL): BIN_EQ_AS is
615 -- New binary = AST node
616 do
617 if l /= Void and r /= Void then
618 create Result.initialize (l, r, o)
619 end
620 end
621
622 new_bin_free_as (l: EXPR_AS; op: ID_AS; r: EXPR_AS): BIN_FREE_AS is
623 -- New BIN_FREE AST node
624 do
625 if l /= Void and r /= Void and op /= Void then
626 create Result.initialize (l, op, r)
627 end
628 end
629
630 new_bin_ge_as (l, r: EXPR_AS; o: AST_EIFFEL): BIN_GE_AS is
631 -- New binary >= AST node
632 do
633 if l /= Void and r /= Void then
634 create Result.initialize (l, r, o)
635 end
636 end
637
638 new_bin_gt_as (l, r: EXPR_AS; o: AST_EIFFEL): BIN_GT_AS is
639 -- New binary > AST node
640 do
641 if l /= Void and r /= Void then
642 create Result.initialize (l, r, o)
643 end
644 end
645
646 new_bin_implies_as (l, r: EXPR_AS; o: AST_EIFFEL): BIN_IMPLIES_AS is
647 -- New binary implies AST node
648 do
649 if l /= Void and r /= Void then
650 create Result.initialize (l, r, o)
651 end
652 end
653
654 new_bin_le_as (l, r: EXPR_AS; o: AST_EIFFEL): BIN_LE_AS is
655 -- New binary <= AST node
656 do
657 if l /= Void and r /= Void then
658 create Result.initialize (l, r, o)
659 end
660 end
661
662 new_bin_lt_as (l, r: EXPR_AS; o: AST_EIFFEL): BIN_LT_AS is
663 -- New binary < AST node
664 do
665 if l /= Void and r /= Void then
666 create Result.initialize (l, r, o)
667 end
668 end
669
670 new_bin_minus_as (l, r: EXPR_AS; o: AST_EIFFEL): BIN_MINUS_AS is
671 -- New binary - AST node
672 do
673 if l /= Void and r /= Void then
674 create Result.initialize (l, r, o)
675 end
676 end
677
678 new_bin_mod_as (l, r: EXPR_AS; o: AST_EIFFEL): BIN_MOD_AS is
679 -- New binary \\ AST node
680 do
681 if l /= Void and r /= Void then
682 create Result.initialize (l, r, o)
683 end
684 end
685
686 new_bin_ne_as (l, r: EXPR_AS; o: AST_EIFFEL): BIN_NE_AS is
687 -- New binary /= AST node
688 do
689 if l /= Void and r /= Void then
690 create Result.initialize (l, r, o)
691 end
692 end
693
694 new_bin_or_as (l, r: EXPR_AS; o: AST_EIFFEL): BIN_OR_AS is
695 -- New binary or AST node
696 do
697 if l /= Void and r /= Void then
698 create Result.initialize (l, r, o)
699 end
700 end
701
702 new_bin_or_else_as (l, r: EXPR_AS; k_as, s_as: KEYWORD_AS): BIN_OR_ELSE_AS is
703 -- New binary or else AST node
704 do
705 if l /= Void and r /= Void then
706 create Result.initialize (l, r, Void)
707 end
708 end
709
710 new_bin_plus_as (l, r: EXPR_AS; o: AST_EIFFEL): BIN_PLUS_AS is
711 -- New binary + AST node
712 do
713 if l /= Void and r /= Void then
714 create Result.initialize (l, r, o)
715 end
716 end
717
718 new_bin_power_as (l, r: EXPR_AS; o: AST_EIFFEL): BIN_POWER_AS is
719 -- New binary ^ AST node
720 do
721 if l /= Void and r /= Void then
722 create Result.initialize (l, r, o)
723 end
724 end
725
726 new_bin_slash_as (l, r: EXPR_AS; o: AST_EIFFEL): BIN_SLASH_AS is
727 -- New binary / AST node
728 do
729 if l /= Void and r /= Void then
730 create Result.initialize (l, r, o)
731 end
732 end
733
734 new_bin_star_as (l, r: EXPR_AS; o: AST_EIFFEL): BIN_STAR_AS is
735 -- New binary * AST node
736 do
737 if l /= Void and r /= Void then
738 create Result.initialize (l, r, o)
739 end
740 end
741
742 new_bin_xor_as (l, r: EXPR_AS; o: AST_EIFFEL): BIN_XOR_AS is
743 -- New binary xor AST node
744 do
745 if l /= Void and r /= Void then
746 create Result.initialize (l, r, o)
747 end
748 end
749
750 new_bit_const_as (b: ID_AS): BIT_CONST_AS is
751 -- New BIT_CONSTANT AST node with
752 -- with bit sequence contained in `b'
753 do
754 if b /= Void then
755 create Result.initialize (b)
756 end
757 end
758
759 new_bits_as (v: INTEGER_AS; b_as: KEYWORD_AS): BITS_AS is
760 -- New BITS AST node
761 do
762 if v /= Void then
763 create Result.initialize (v, b_as)
764 end
765 end
766
767 new_bits_symbol_as (s: ID_AS; b_as: KEYWORD_AS): BITS_SYMBOL_AS is
768 -- New BITS_SYMBOL AST node
769 do
770 if s /= Void then
771 create Result.initialize (s, b_as)
772 end
773 end
774
775 new_bracket_as (t: EXPR_AS; o: EIFFEL_LIST [EXPR_AS]; l_as, r_as: SYMBOL_AS): BRACKET_AS is
776 -- New BRACKET AST node
777 require
778 t_not_void: t /= Void
779 o_not_void: o /= Void
780 do
781 create Result.make (t, o, l_as, r_as)
782 end
783
784 new_body_as (a: FORMAL_ARGU_DEC_LIST_AS; t: TYPE_AS; r: ID_AS; c: CONTENT_AS; c_as: SYMBOL_AS; k_as: LEAF_AS; a_as: KEYWORD_AS; i_as: INDEXING_CLAUSE_AS): BODY_AS is
785 -- New BODY AST node
786 do
787 create Result.initialize (a, t, r, c, c_as, k_as, a_as, i_as)
788 end
789
790 new_boolean_as (b: BOOLEAN; a_scn: EIFFEL_SCANNER): BOOL_AS is
791 -- New BOOLEAN AST node
792 require
793 a_scn_not_void: a_scn /= Void
794 do
795 create Result.initialize (b, a_scn.line, a_scn.column, a_scn.position, a_scn.text_count)
796 end
797
798 new_built_in_as (l: EXTERNAL_LANG_AS; a: STRING_AS; e_as, a_as: KEYWORD_AS): BUILT_IN_AS is
799 -- New BUILT_IN AST node
800 do
801 if l /= Void then
802 create Result.initialize (l, a, e_as, a_as)
803 end
804 end
805
806 new_case_as (i: EIFFEL_LIST [INTERVAL_AS]; c: EIFFEL_LIST [INSTRUCTION_AS]; w_as, t_as: KEYWORD_AS): CASE_AS is
807 -- New WHEN AST node
808 do
809 if i /= Void then
810 create Result.initialize (i, c, w_as, t_as)
811 end
812 end
813
814 new_character_as (c: CHARACTER_32; l, co, p, n: INTEGER; a_text: STRING): CHAR_AS is
815 -- New CHARACTER AST node
816 require
817 l_non_negative: l >= 0
818 co_non_negative: co >= 0
819 p_non_negative: p >= 0
820 n_non_negative: n >= 0
821 do
822 create Result.initialize (c, l, co, p, n)
823 end
824
825 new_check_as (c: EIFFEL_LIST [TAGGED_AS]; c_as, e: KEYWORD_AS): CHECK_AS is
826 -- New CHECK AST node
827 do
828 if e /= Void then
829 create Result.initialize (c, c_as, e)
830 end
831 end
832
833 new_class_as (n: ID_AS; ext_name: STRING_AS;
834 is_d, is_e, is_s, is_fc, is_ex, is_par: BOOLEAN;
835 top_ind, bottom_ind: INDEXING_CLAUSE_AS;
836 g: EIFFEL_LIST [FORMAL_DEC_AS];
837 p: PARENT_LIST_AS;
838 c: EIFFEL_LIST [CREATE_AS];
839 co: CONVERT_FEAT_LIST_AS;
840 f: EIFFEL_LIST [FEATURE_CLAUSE_AS];
841 inv: INVARIANT_AS;
842 s: SUPPLIERS_AS;
843 o: STRING_AS;
844 ed: KEYWORD_AS): CLASS_AS
845 is
846 -- New CLASS AST node
847 do
848 if n /= Void and s /= Void and (co = Void or else not co.is_empty) and ed /= Void then
849 create Result.initialize (n, ext_name, is_d, is_e, is_s, is_fc, is_ex, is_par, top_ind,
850 bottom_ind, g, p, c, co, f, inv, s, o, ed)
851 end
852 end
853
854 new_class_type_as (n: ID_AS; g: TYPE_LIST_AS): CLASS_TYPE_AS is
855 -- New CLASS_TYPE AST node
856 do
857 if n /= Void then
858 create Result.initialize (n, g)
859 end
860 end
861
862 set_expanded_class_type (a_type: TYPE_AS; is_expanded: BOOLEAN; s_as: KEYWORD_AS) is
863 -- Set expanded status of `a_type' if it is an instance of CLASS_TYPE_AS.
864 local
865 l_class_type: CLASS_TYPE_AS
866 do
867 if is_expanded then
868 l_class_type ?= a_type
869 if l_class_type /= Void then
870 l_class_type.set_is_expanded (True, s_as)
871 end
872 end
873 end
874
875 set_monomorph_type (a_type: TYPE_AS; is_monomorphic: BOOLEAN; s_as: KEYWORD_AS) is
876 -- Set monomorphic status of `a_type' if it is an instance of CLASS_TYPE_AS.
877 local
878 l_class_type: CLASS_TYPE_AS
879 do
880 if is_monomorphic then
881 l_class_type ?= a_type
882 if l_class_type /= Void then
883 l_class_type.set_is_monomorph (True, s_as)
884 end
885 end
886 end
887
888 new_named_tuple_type_as (n: ID_AS; p: FORMAL_ARGU_DEC_LIST_AS): NAMED_TUPLE_TYPE_AS is
889 -- New TUPLE_TYPE AST node
890 do
891 if n /= Void and (p /= Void and then p.arguments /= Void) then
892 create Result.initialize (n, p)
893 end
894 end
895
896 new_client_as (c: CLASS_LIST_AS): CLIENT_AS is
897 -- New CLIENT AST node
898 do
899 if c /= Void and then not c.is_empty then
900 create Result.initialize (c)
901 end
902 end
903
904 new_constant_as (a: ATOMIC_AS): CONSTANT_AS is
905 -- New CONSTANT_AS node
906 do
907 if a /= Void then
908 create Result.initialize (a)
909 end
910 end
911
912 new_convert_feat_as (cr: BOOLEAN; fn: FEATURE_NAME; t: TYPE_LIST_AS; l_as, r_as, c_as, lc_as, rc_as: SYMBOL_AS): CONVERT_FEAT_AS is
913 -- New convert feature entry AST node.
914 do
915 if fn /= Void and (t /= Void and then not t.is_empty) then
916 create Result.initialize (cr, fn, t, l_as, r_as, c_as, lc_as, rc_as)
917 end
918 end
919
920 new_create_as (c: CLIENT_AS; f: EIFFEL_LIST [FEATURE_NAME]; c_as: KEYWORD_AS): CREATE_AS is
921 -- New creation clause AST node
922 do
923 create Result.initialize (c, f, c_as)
924 end
925
926 new_creation_as (tp: TYPE_AS; tg: ACCESS_AS; c: ACCESS_INV_AS): CREATION_AS is
927 -- New creation instruction AST node
928 do
929 check
930 should_not_arrive_here: False
931 end
932 end
933
934 new_creation_expr_as (t: TYPE_AS; c: ACCESS_INV_AS): CREATION_EXPR_AS is
935 -- New creation expression AST node
936 do
937 check
938 should_not_arrive_here: False
939 end
940 end
941
942 new_current_as (a_scn: EIFFEL_SCANNER): CURRENT_AS is
943 -- New CURRENT AST node
944 require
945 a_scn_not_void: a_scn /= Void
946 do
947 create Result.make_with_location (a_scn.line, a_scn.column, a_scn.position, a_scn.text_count)
948 end
949
950 new_custom_attribute_as (c: CREATION_EXPR_AS; t: TUPLE_AS; k_as: KEYWORD_AS): CUSTOM_ATTRIBUTE_AS is
951 -- Create a new UNIQUE AST node.
952 do
953 if c /= Void then
954 create Result.initialize (c, t, k_as)
955 end
956 end
957
958 new_debug_as (k: DEBUG_KEY_LIST_AS; c: EIFFEL_LIST [INSTRUCTION_AS]; d_as, e: KEYWORD_AS): DEBUG_AS is
959 -- New DEBUG AST node
960 do
961 if e /= Void then
962 create Result.initialize (k, c, d_as, e)
963 end
964 end
965
966 new_deferred_as (a_scn: EIFFEL_SCANNER): DEFERRED_AS is
967 -- New DEFERRED AST node
968 require
969 a_scn_not_void: a_scn /= Void
970 do
971 create Result.make_with_location (a_scn.line, a_scn.column, a_scn.position, a_scn.text_count)
972 end
973
974 new_do_as (c: EIFFEL_LIST [INSTRUCTION_AS]; k_as: KEYWORD_AS): DO_AS is
975 -- New DO AST node
976 do
977 create Result.make (c, k_as)
978 end
979
980 new_eiffel_list_atomic_as (n: INTEGER): EIFFEL_LIST [ATOMIC_AS] is
981 -- New empty list of ATOMIC_AS
982 require
983 n_non_negative: n >= 0
984 do
985 create Result.make (n)
986 ensure
987 list_full: Result /= Void implies Result.capacity = n and Result.all_default
988 end
989
990 new_eiffel_list_case_as (n: INTEGER): EIFFEL_LIST [CASE_AS] is
991 -- New empty list of CASE_AS
992 require
993 n_non_negative: n >= 0
994 do
995 create Result.make (n)
996 ensure
997 list_full: Result /= Void implies Result.capacity = n and Result.all_default
998 end
999
1000 new_eiffel_list_convert (n: INTEGER): CONVERT_FEAT_LIST_AS is
1001 -- New empty list of CONVERT_FEAT_AS
1002 require
1003 n_non_negative: n >= 0
1004 do
1005 create Result.make (n)
1006 ensure
1007 list_full: Result /= Void implies Result.capacity = n and Result.all_default
1008 end
1009
1010 new_eiffel_list_create_as (n: INTEGER): EIFFEL_LIST [CREATE_AS] is
1011 -- New empty list of CREATE_AS
1012 require
1013 n_non_negative: n >= 0
1014 do
1015 create Result.make (n)
1016 ensure
1017 list_full: Result /= Void implies Result.capacity = n and Result.all_default
1018 end
1019
1020 new_eiffel_list_elseif_as (n: INTEGER): EIFFEL_LIST [ELSIF_AS] is
1021 -- New empty list of ELSIF_AS
1022 require
1023 n_non_negative: n >= 0
1024 do
1025 create Result.make (n)
1026 ensure
1027 list_full: Result /= Void implies Result.capacity = n and Result.all_default
1028 end
1029
1030 new_eiffel_list_export_item_as (n: INTEGER): EIFFEL_LIST [EXPORT_ITEM_AS] is
1031 -- New empty list of EXPORT_ITEM_AS
1032 require
1033 n_non_negative: n >= 0
1034 do
1035 create Result.make (n)
1036 ensure
1037 list_full: Result /= Void implies Result.capacity = n and Result.all_default
1038 end
1039
1040 new_eiffel_list_expr_as (n: INTEGER): EIFFEL_LIST [EXPR_AS] is
1041 -- New empty list of PARAMETER_LIST_AS
1042 require
1043 n_non_negative: n >= 0
1044 do
1045 create Result.make (n)
1046 ensure
1047 list_full: Result /= Void implies Result.capacity = n and Result.all_default
1048 end
1049
1050 new_parameter_list_as (l: EIFFEL_LIST [EXPR_AS]; lp_as, rp_as: SYMBOL_AS): PARAMETER_LIST_AS is
1051 -- New empty list of EXPR_AS
1052 do
1053 create Result.initialize (l, lp_as, rp_as)
1054 end
1055
1056 new_eiffel_list_feature_as (n: INTEGER): EIFFEL_LIST [FEATURE_AS] is
1057 -- New empty list of FEATURE_AS
1058 require
1059 n_non_negative: n >= 0
1060 do
1061 create Result.make (n)
1062 ensure
1063 list_full: Result /= Void implies Result.capacity = n and Result.all_default
1064 end
1065
1066 new_eiffel_list_feature_clause_as (n: INTEGER): EIFFEL_LIST [FEATURE_CLAUSE_AS] is
1067 -- New empty list of FEATURE_CLAUSE_AS
1068 require
1069 n_non_negative: n >= 0
1070 do
1071 create Result.make (n)
1072 ensure
1073 list_full: Result /= Void implies Result.capacity = n and Result.all_default
1074 end
1075
1076 new_eiffel_list_feature_name (n: INTEGER): EIFFEL_LIST [FEATURE_NAME] is
1077 -- New empty list of FEATURE_NAME
1078 require
1079 n_non_negative: n >= 0
1080 do
1081 create Result.make (n)
1082 ensure
1083 list_full: Result /= Void implies Result.capacity = n and Result.all_default
1084 end
1085
1086 new_eiffel_list_formal_dec_as (n: INTEGER): FORMAL_GENERIC_LIST_AS is
1087 -- New empty list of FORMAL_DEC_AS
1088 require
1089 n_non_negative: n >= 0
1090 do
1091 create Result.make (n)
1092 ensure
1093 list_full: Result /= Void implies Result.capacity = n and Result.all_default
1094 end
1095
1096 new_eiffel_list_id_as (n: INTEGER): EIFFEL_LIST [ID_AS] is
1097 -- New empty list of ID_AS
1098 require
1099 n_non_negative: n >= 0
1100 do
1101 create Result.make (n)
1102 ensure
1103 list_full: Result /= Void implies Result.capacity = n and Result.all_default
1104 end
1105
1106 new_indexing_clause_as (n: INTEGER): INDEXING_CLAUSE_AS is
1107 -- New empty list of INDEX_AS
1108 require
1109 n_non_negative: n >= 0
1110 do
1111 create Result.make (n)
1112 ensure
1113 list_full: Result /= Void implies Result.capacity = n and Result.all_default
1114 end
1115
1116 new_eiffel_list_instruction_as (n: INTEGER): EIFFEL_LIST [INSTRUCTION_AS] is
1117 -- New empty list of INSTRUCTION_AS
1118 require
1119 n_non_negative: n >= 0
1120 do
1121 create Result.make (n)
1122 ensure
1123 list_full: Result /= Void implies Result.capacity = n and Result.all_default
1124 end
1125
1126 new_eiffel_list_interval_as (n: INTEGER): EIFFEL_LIST [INTERVAL_AS] is
1127 -- New empty list of INTERVAL_AS
1128 require
1129 n_non_negative: n >= 0
1130 do
1131 create Result.make (n)
1132 ensure
1133 list_full: Result /= Void implies Result.capacity = n and Result.all_default
1134 end
1135
1136 new_eiffel_list_operand_as (n: INTEGER): EIFFEL_LIST [OPERAND_AS] is
1137 -- New empty list of OPERAND_AS
1138 require
1139 n_non_negative: n >= 0
1140 do
1141 create Result.make (n)
1142 ensure
1143 list_full: Result /= Void implies Result.capacity = n and Result.all_default
1144 end
1145
1146 new_eiffel_list_parent_as (n: INTEGER): PARENT_LIST_AS is
1147 -- New empty list of PARENT_AS
1148 require
1149 n_non_negative: n >= 0
1150 do
1151 create Result.make (n)
1152 ensure
1153 list_full: Result /= Void implies Result.capacity = n and Result.all_default
1154 end
1155
1156 new_eiffel_list_rename_as (n: INTEGER): EIFFEL_LIST [RENAME_AS] is
1157 -- New empty list of RENAME_AS
1158 require
1159 n_non_negative: n >= 0
1160 do
1161 create Result.make (n)
1162 ensure
1163 list_full: Result /= Void implies Result.capacity = n and Result.all_default
1164 end
1165
1166 new_eiffel_list_string_as (n: INTEGER): EIFFEL_LIST [STRING_AS] is
1167 -- New empty list of STRING_AS
1168 require
1169 n_non_negative: n >= 0
1170 do
1171 create Result.make (n)
1172 ensure
1173 list_full: Result /= Void implies Result.capacity = n and Result.all_default
1174 end
1175
1176 new_eiffel_list_tagged_as (n: INTEGER): EIFFEL_LIST [TAGGED_AS] is
1177 -- New empty list of TAGGED_AS
1178 require
1179 n_non_negative: n >= 0
1180 do
1181 create Result.make (n)
1182 ensure
1183 list_full: Result /= Void implies Result.capacity = n and Result.all_default
1184 end
1185
1186 new_eiffel_list_type (n: INTEGER): TYPE_LIST_AS is
1187 -- New empty list of TYPE
1188 require
1189 n_non_negative: n >= 0
1190 do
1191 create Result.make (n)
1192 ensure
1193 list_full: Result /= Void implies Result.capacity = n and Result.all_default
1194 end
1195
1196 new_eiffel_list_type_dec_as (n: INTEGER): TYPE_DEC_LIST_AS is
1197 -- New empty list of TYPE_DEC_AS
1198 require
1199 n_non_negative: n >= 0
1200 do
1201 create Result.make (n)
1202 ensure
1203 list_full: Result /= Void implies Result.capacity = n and Result.all_default
1204 end
1205
1206 new_elseif_as (e: EXPR_AS; c: EIFFEL_LIST [INSTRUCTION_AS]; l_as, t_as: KEYWORD_AS): ELSIF_AS is
1207 -- New ELSIF AST node
1208 do
1209 if e /= Void then
1210 create Result.initialize (e, c, l_as, t_as)
1211 end
1212 end
1213
1214 new_ensure_as (a: EIFFEL_LIST [TAGGED_AS]; k_as: KEYWORD_AS): ENSURE_AS is
1215 -- New ENSURE AST node
1216 do
1217 create Result.make (a, k_as)
1218 end
1219
1220 new_ensure_then_as (a: EIFFEL_LIST [TAGGED_AS]; k_as, l_as: KEYWORD_AS): ENSURE_THEN_AS is
1221 -- New ENSURE THEN AST node
1222 do
1223 create Result.make (a, k_as, l_as)
1224 end
1225
1226 new_export_item_as (c: CLIENT_AS; f: FEATURE_SET_AS): EXPORT_ITEM_AS is
1227 -- New EXPORT_ITEM AST node
1228 do
1229 if c /= Void then
1230 create Result.initialize (c, f)
1231 end
1232 end
1233
1234 new_expr_address_as (e: EXPR_AS; a_as, l_as, r_as: SYMBOL_AS): EXPR_ADDRESS_AS is
1235 -- New EXPR_ADDRESS AST node
1236 do
1237 if e /= Void then
1238 create Result.initialize (e, a_as, l_as, r_as)
1239 end
1240 end
1241
1242 new_expr_call_as (c: CALL_AS): EXPR_CALL_AS is
1243 -- New EXPR_CALL AST node
1244 do
1245 if c /= Void then
1246 create Result.initialize (c)
1247 end
1248 end
1249
1250 new_external_as (l: EXTERNAL_LANG_AS; a: STRING_AS; e_as, a_as: KEYWORD_AS): EXTERNAL_AS is
1251 -- New EXTERNAL AST node
1252 do
1253 if l /= Void then
1254 create Result.initialize (l, a, e_as, a_as)
1255 end
1256 end
1257
1258 new_external_lang_as (l: STRING_AS): EXTERNAL_LANG_AS is
1259 -- New EXTERNAL_LANGUAGE AST node
1260 do
1261 if l /= Void then
1262 create Result.initialize (l)
1263 end
1264 end
1265
1266 new_feature_as (f: EIFFEL_LIST [FEATURE_NAME]; b: BODY_AS; i: INDEXING_CLAUSE_AS; next_pos: INTEGER): FEATURE_AS is
1267 -- New FEATURE AST node
1268 do
1269 if
1270 (f /= Void and then not f.is_empty) and b /= Void
1271 then
1272 create Result.initialize (f, b, i, 0, next_pos)
1273 end
1274 end
1275
1276 new_feature_clause_as (c: CLIENT_AS; f: EIFFEL_LIST [FEATURE_AS]; l: KEYWORD_AS; ep: INTEGER): FEATURE_CLAUSE_AS is
1277 -- New FEATURE_CLAUSE AST node
1278 do
1279 if f /= Void and l /= Void then
1280 create Result.initialize (c, f, l, ep)
1281 end
1282 end
1283
1284 new_feature_list_as (f: EIFFEL_LIST [FEATURE_NAME]): FEATURE_LIST_AS is
1285 -- New FEATURE_LIST AST node
1286 do
1287 if f /= Void then
1288 create Result.initialize (f)
1289 end
1290 end
1291
1292 new_feature_name_alias_as (feature_name: ID_AS; alias_name: STRING_AS; has_convert_mark: BOOLEAN; a_as, c_as: KEYWORD_AS): FEATURE_NAME_ALIAS_AS is
1293 -- New FEATURE_NAME_ALIAS AST node
1294 do
1295 if feature_name /= Void and then alias_name /= Void then
1296 create Result.initialize (feature_name, alias_name, has_convert_mark, a_as, c_as)
1297 end
1298 end
1299
1300 new_feature_name_id_as (f: ID_AS): FEAT_NAME_ID_AS is
1301 -- New FEAT_NAME_ID AST node
1302 do
1303 if f /= Void then
1304 create Result.initialize (f)
1305 end
1306 end
1307
1308 new_formal_as (n: ID_AS; is_ref, is_exp: BOOLEAN; r_as: KEYWORD_AS): FORMAL_AS is
1309 -- New FORMAL AST node
1310 do
1311 if n /= Void then
1312 create Result.initialize (n, is_ref, is_exp, r_as)
1313 end
1314 end
1315
1316 new_formal_dec_as (f: FORMAL_AS; c: CONSTRAINT_LIST_AS; cf: EIFFEL_LIST [FEATURE_NAME]; c_as: SYMBOL_AS; ck_as, ek_as: KEYWORD_AS): FORMAL_DEC_AS is
1317 -- New FORMAL_DECLARATION AST node
1318 do
1319 if f /= Void then
1320 create Result.initialize (f, c, cf, c_as, ck_as, ek_as)
1321 end
1322 end
1323
1324 new_filled_id_as (a_scn: EIFFEL_SCANNER_SKELETON): ID_AS is
1325 -- New empty ID AST node.
1326 require
1327 a_scn_not_void: a_scn /= Void
1328 local
1329 l_cnt: INTEGER
1330 l_str: STRING
1331 do
1332 l_cnt := a_scn.text_count
1333 create l_str.make (l_cnt)
1334 a_scn.append_text_to_string (l_str)
1335 create Result.initialize (l_str)
1336 Result.set_position (a_scn.line, a_scn.column, a_scn.position, l_cnt)
1337 end
1338
1339 new_filled_id_as_with_existing_stub (a_scn: EIFFEL_SCANNER_SKELETON; a_index: INTEGER): ID_AS is
1340 -- New empty ID AST node.
1341 require
1342 a_scn_not_void: a_scn /= Void
1343 do
1344 Result := new_filled_id_as (a_scn)
1345 end
1346
1347 new_filled_bit_id_as (a_scn: EIFFEL_SCANNER): ID_AS is
1348 -- New empty ID AST node.
1349 require
1350 a_scn_not_void: a_scn /= Void
1351 local
1352 l_cnt: INTEGER
1353 l_str: STRING
1354 do
1355 l_cnt := a_scn.text_count - 1
1356 create l_str.make (l_cnt)
1357 a_scn.append_text_substring_to_string (1, l_cnt, l_str)
1358 create Result.initialize (l_str)
1359 Result.set_position (a_scn.line, a_scn.column, a_scn.position, l_cnt)
1360 end
1361
1362 new_identifier_list (n: INTEGER): IDENTIFIER_LIST is
1363 -- New ARRAYED_LIST [INTEGER]
1364 require
1365 n_non_negative: n >= 0
1366 do
1367 create Result.make (n)
1368 end
1369
1370 new_if_as (cnd: EXPR_AS; cmp: EIFFEL_LIST [INSTRUCTION_AS];
1371 ei: EIFFEL_LIST [ELSIF_AS]; e: EIFFEL_LIST [INSTRUCTION_AS];
1372 end_location, i_as, t_as, e_as: KEYWORD_AS): IF_AS
1373 is
1374 -- New IF AST node
1375 do
1376 if cnd /= Void and end_location /= Void then
1377 create Result.initialize (cnd, cmp, ei, e, end_location, i_as, t_as, e_as)
1378 end
1379 end
1380
1381 new_index_as (t: ID_AS; i: EIFFEL_LIST [ATOMIC_AS]; c_as: SYMBOL_AS): INDEX_AS is
1382 -- Create a new INDEX AST node.
1383 do
1384 if i /= Void then
1385 create Result.initialize (t, i, c_as)
1386 end
1387 end
1388
1389 new_infix_as (op: STRING_AS; l: KEYWORD_AS): INFIX_PREFIX_AS is
1390 -- New INFIX AST node
1391 do
1392 if op /= Void then
1393 create Result.initialize (op, True, l)
1394 end
1395 end
1396
1397 new_inspect_as (s: EXPR_AS; c: EIFFEL_LIST [CASE_AS];
1398 e: EIFFEL_LIST [INSTRUCTION_AS]; end_location, i_as, e_as: KEYWORD_AS): INSPECT_AS
1399 is
1400 -- New INSPECT AST node
1401 do
1402 if s /= Void and end_location /= Void then
1403 create Result.initialize (s, c, e, end_location, i_as, e_as)
1404 end
1405 end
1406
1407 new_instr_call_as (c: CALL_AS): INSTR_CALL_AS is
1408 -- New INSTR_CALL AST node
1409 do
1410 if c /= Void then
1411 create Result.initialize (c)
1412 end
1413 end
1414
1415 new_integer_as (t: TYPE_AS; s: BOOLEAN; v: STRING; buf: STRING; s_as: SYMBOL_AS; l, c, p, n: INTEGER): INTEGER_AS is
1416 -- New INTEGER_AS node
1417 do
1418 if v /= Void then
1419 create Result.make_from_string (t, s, v)
1420 Result.set_position (l, c, p, n)
1421 end
1422 end
1423
1424 new_integer_hexa_as (t: TYPE_AS; s: CHARACTER; v: STRING; buf: STRING; s_as: SYMBOL_AS; l, c, p, n: INTEGER): INTEGER_AS is
1425 -- New INTEGER_AS node
1426 do
1427 if v /= Void then
1428 create Result.make_from_hexa_string (t, s, v)
1429 Result.set_position (l, c, p, n)
1430 end
1431 end
1432
1433 new_integer_octal_as (t: TYPE_AS; s: CHARACTER; v: STRING; buf: STRING; s_as: SYMBOL_AS; l, c, p, n: INTEGER): INTEGER_AS is
1434 -- New INTEGER_AS node
1435 do
1436 if v /= Void then
1437 create Result.make_from_octal_string (t, s, v)
1438 Result.set_position (l, c, p, n)
1439 end
1440 end
1441
1442 new_integer_binary_as (t: TYPE_AS; s: CHARACTER; v: STRING; buf: STRING; s_as: SYMBOL_AS; l, c, p, n: INTEGER): INTEGER_AS is
1443 -- New INTEGER_AS node
1444 do
1445 if v /= Void then
1446 create Result.make_from_binary_string (t, s, v)
1447 Result.set_position (l, c, p, n)
1448 end
1449 end
1450
1451 new_interval_as (l, u: ATOMIC_AS; d_as: SYMBOL_AS): INTERVAL_AS is
1452 -- New INTERVAL AST node
1453 do
1454 if l /= Void then
1455 create Result.initialize (l, u, d_as)
1456 end
1457 end
1458
1459 new_invariant_as (a: EIFFEL_LIST [TAGGED_AS]; once_manifest_string_count: INTEGER; i_as: KEYWORD_AS): INVARIANT_AS is
1460 -- New INVARIANT AST node
1461 require
1462 valid_once_manifest_string_count: once_manifest_string_count >= 0
1463 do
1464 create Result.initialize (a, once_manifest_string_count, i_as)
1465 end
1466
1467 new_like_id_as (a: ID_AS; l_as: KEYWORD_AS): LIKE_ID_AS is
1468 -- New LIKE_ID AST node
1469 do
1470 if a /= Void then
1471 create Result.initialize (a, l_as)
1472 end
1473 end
1474
1475 new_like_current_as (other: CURRENT_AS; l_as: KEYWORD_AS): LIKE_CUR_AS is
1476 -- New LIKE_CURRENT AST node
1477 do
1478 create Result.make (other, l_as)
1479 end
1480
1481 new_location_as (l, c, p, s: INTEGER): LOCATION_AS is
1482 -- New LOCATION_AS
1483 require
1484 l_non_negative: l >= 0
1485 c_non_negative: c >= 0
1486 p_non_negative: p >= 0
1487 s_non_negative: s >= 0
1488 do
1489 create Result.make (l, c, p, s)
1490 end
1491
1492 new_loop_as (f: EIFFEL_LIST [INSTRUCTION_AS]; i: EIFFEL_LIST [TAGGED_AS];
1493 v: VARIANT_AS; s: EXPR_AS; c: EIFFEL_LIST [INSTRUCTION_AS];
1494 e, f_as, i_as, u_as, l_as: KEYWORD_AS): LOOP_AS
1495 is
1496 -- New LOOP AST node
1497 do
1498 if s /= Void and e /= Void then
1499 create Result.initialize (f, i, v, s, c, e, f_as, i_as, u_as, l_as)
1500 end
1501 end
1502
1503 new_nested_as (t: ACCESS_AS; m: CALL_AS; d_as: SYMBOL_AS): NESTED_AS is
1504 -- New NESTED CALL AST node
1505 do
1506 if t /= Void and m /= Void then
1507 create Result.initialize (t, m, d_as)
1508 end
1509 end
1510
1511 new_nested_expr_as (t: EXPR_AS; m: CALL_AS; d_as, l_as, r_as: SYMBOL_AS): NESTED_EXPR_AS is
1512 -- New NESTED_EXPR CALL AST node
1513 do
1514 if t /= Void and m /= Void then
1515 create Result.initialize (t, m, d_as, l_as, r_as)
1516 end
1517 end
1518
1519 new_none_type_as (c: ID_AS): NONE_TYPE_AS is
1520 -- New type AST node for "NONE"
1521 do
1522 if c /= Void then
1523 create Result.initialize (c)
1524 end
1525 end
1526
1527 new_once_as (c: EIFFEL_LIST [INSTRUCTION_AS]; k_as: KEYWORD_AS): ONCE_AS is
1528 -- New ONCE AST node
1529 do
1530 create Result.make (c, k_as)
1531 end
1532
1533 new_operand_as (c: TYPE_AS; t: ACCESS_AS; e: EXPR_AS): OPERAND_AS is
1534 -- New OPERAND AST node
1535 do
1536 create Result.initialize (c, t, e)
1537 end
1538
1539 new_paran_as (e: EXPR_AS; l_as, r_as: SYMBOL_AS): PARAN_AS is
1540 -- New PARAN AST node
1541 do
1542 if e /= Void then
1543 create Result.initialize (e, l_as, r_as)
1544 end
1545 end
1546
1547 new_parent_as (t: CLASS_TYPE_AS; rn: RENAME_CLAUSE_AS;
1548 e: EXPORT_CLAUSE_AS; u: UNDEFINE_CLAUSE_AS;
1549 rd: REDEFINE_CLAUSE_AS; s: SELECT_CLAUSE_AS; ed: KEYWORD_AS): PARENT_AS
1550 is
1551 -- New PARENT AST node
1552 do
1553 if t /= Void then
1554 create Result.initialize (t, rn, e, u, rd, s, ed)
1555 end
1556 end
1557
1558 new_precursor_as (pk: KEYWORD_AS; n: CLASS_TYPE_AS; p: PARAMETER_LIST_AS): PRECURSOR_AS is
1559 -- New PRECURSOR AST node
1560 do
1561 if pk /= Void and (n /= Void implies n.generics = Void) then
1562 create Result.initialize (pk, n, p)
1563 end
1564 end
1565
1566 new_prefix_as (op: STRING_AS; l: KEYWORD_AS): INFIX_PREFIX_AS is
1567 -- New PREFIX AST node
1568 do
1569 if op /= Void then
1570 create Result.initialize (op, False, l)
1571 end
1572 end
1573
1574 new_real_as (t: TYPE_AS; v: STRING; buf: STRING; s_as: SYMBOL_AS; l, c, p, n: INTEGER): REAL_AS is
1575 -- New REAL AST node
1576 do
1577 if v /= Void then
1578 create Result.make (t, v)
1579 Result.set_position (l, c, p, n)
1580 end
1581 end
1582
1583 new_rename_as (o, n: FEATURE_NAME; k_as: KEYWORD_AS): RENAME_AS is
1584 -- New RENAME_PAIR AST node
1585 do
1586 if o /= Void and n /= Void then
1587 create Result.initialize (o, n, k_as)
1588 end
1589 end
1590
1591 new_require_as (a: EIFFEL_LIST [TAGGED_AS]; k_as: KEYWORD_AS): REQUIRE_AS is
1592 -- New REQUIRE AST node
1593 do
1594 create Result.make (a, k_as)
1595 end
1596
1597 new_require_else_as (a: EIFFEL_LIST [TAGGED_AS]; k_as, l_as: KEYWORD_AS): REQUIRE_ELSE_AS is
1598 -- New REQUIRE ELSE AST node
1599 do
1600 create Result.make (a, k_as, l_as)
1601 end
1602
1603 new_result_as (a_scn: EIFFEL_SCANNER): RESULT_AS is
1604 -- New RESULT AST node
1605 require
1606 a_scn_not_void: a_scn /= Void
1607 do
1608 create Result.make_with_location (a_scn.line, a_scn.column, a_scn.position, a_scn.text_count)
1609 end
1610
1611 new_retry_as (a_scn: EIFFEL_SCANNER): RETRY_AS is
1612 -- New RETRY AST node
1613 require
1614 a_scn_not_void: a_scn /= Void
1615 do
1616 create Result.make_with_location (a_scn.line, a_scn.column, a_scn.position, a_scn.text_count)
1617 end
1618
1619 new_reverse_as (t: ACCESS_AS; s: EXPR_AS; a_as: SYMBOL_AS): REVERSE_AS is
1620 -- New assignment attempt AST node
1621 do
1622 if t /= Void and s /= Void then
1623 create Result.initialize (t, s, a_as)
1624 end
1625 end
1626
1627 new_routine_as (o: STRING_AS; pr: REQUIRE_AS;
1628 l: LOCAL_DEC_LIST_AS; b: ROUT_BODY_AS; po: ENSURE_AS;
1629 r: EIFFEL_LIST [INSTRUCTION_AS]; end_loc: KEYWORD_AS;
1630 oms_count, a_pos: INTEGER; k_as, r_as: KEYWORD_AS): ROUTINE_AS
1631 is
1632 -- New ROUTINE AST node
1633 require
1634 valid_oms_count: oms_count >= 0
1635 a_pos_positive: a_pos > 0
1636 do
1637 if b /= Void and end_loc /= Void then
1638 create Result.initialize (o, pr, l, b, po, r, end_loc, oms_count, a_pos, k_as, r_as)
1639 end
1640 end
1641
1642 new_routine_creation_as (t: OPERAND_AS; f: ID_AS; o: DELAYED_ACTUAL_LIST_AS; is_qualified: BOOLEAN): ROUTINE_CREATION_AS is
1643 -- New ROUTINE_CREATION AST node
1644 do
1645 end
1646
1647 new_old_routine_creation_as (
1648 l: AST_EIFFEL; t: OPERAND_AS; f: ID_AS; o: DELAYED_ACTUAL_LIST_AS;
1649 is_qualified: BOOLEAN; a_as: SYMBOL_AS): PAIR [ROUTINE_CREATION_AS, LOCATION_AS]
1650 is
1651 -- New ROUTINE_CREATION AST node for obsolete use of `~'.
1652 local
1653 l_routine: TILDA_ROUTINE_CREATION_AS
1654 do
1655 if l /= Void and f /= Void then
1656 create l_routine.make (t, f, o, is_qualified, a_as)
1657 create Result.make (l_routine, l.start_location)
1658 end
1659 end
1660
1661 new_static_access_as (c: TYPE_AS; f: ID_AS; p: PARAMETER_LIST_AS; f_as: KEYWORD_AS; d_as: SYMBOL_AS): STATIC_ACCESS_AS is
1662 -- New STATIC_ACCESS AST node
1663 do
1664 create Result.initialize (c, f, p, f_as, d_as)
1665 end
1666
1667 new_string_as (s: STRING; l, c, p, n: INTEGER; buf: STRING): STRING_AS is
1668 -- New STRING AST node
1669 require
1670 s_not_void: s /= Void
1671 l_non_negative: l >= 0
1672 c_non_negative: c >= 0
1673 p_non_negative: p >= 0
1674 n_non_negative: n >= 0
1675 do
1676 if s /= Void then
1677 create Result.initialize (s, l, c, p, n)
1678 end
1679 end
1680
1681 new_tagged_as (t: ID_AS; e: EXPR_AS; s_as: SYMBOL_AS): TAGGED_AS is
1682 -- New TAGGED AST node
1683 do
1684 create Result.initialize (t, e, s_as)
1685 end
1686
1687 new_tuple_as (exp: EIFFEL_LIST [EXPR_AS]; l_as, r_as: SYMBOL_AS): TUPLE_AS is
1688 -- New Manifest TUPLE AST node
1689 do
1690 if exp /= Void then
1691 create Result.initialize (exp, l_as, r_as)
1692 end
1693 end
1694
1695 new_type_dec_as (i: IDENTIFIER_LIST; t: TYPE_AS; c_as: SYMBOL_AS): TYPE_DEC_AS is
1696 -- New TYPE_DEC AST node
1697 do
1698 if i /= Void and t /= Void then
1699 create Result.initialize (i, t, c_as)
1700 end
1701 end
1702
1703 new_type_expr_as (t: TYPE_AS): TYPE_EXPR_AS is
1704 -- New TYPE_EXPR AST node
1705 do
1706 if t /= Void then
1707 create Result.initialize (t)
1708 end
1709 end
1710
1711 new_un_free_as (op: ID_AS; e: EXPR_AS): UN_FREE_AS is
1712 -- New UN_FREE AST node
1713 do
1714 if op /= Void and e /= Void then
1715 create Result.initialize (op, e)
1716 end
1717 end
1718
1719 new_un_minus_as (e: EXPR_AS; o: AST_EIFFEL): UN_MINUS_AS is
1720 -- New unary - AST node
1721 do
1722 if e /= Void then
1723 create Result.initialize (e, o)
1724 end
1725 end
1726
1727 new_un_not_as (e: EXPR_AS; o: AST_EIFFEL): UN_NOT_AS is
1728 -- New unary not AST node
1729 do
1730 if e /= Void then
1731 create Result.initialize (e, o)
1732 end
1733 end
1734
1735 new_un_old_as (e: EXPR_AS; o: AST_EIFFEL): UN_OLD_AS is
1736 -- New unary old AST node
1737 do
1738 if e /= Void then
1739 create Result.initialize (e, o)
1740 end
1741 end
1742
1743 new_un_plus_as (e: EXPR_AS; o: AST_EIFFEL): UN_PLUS_AS is
1744 -- New unary + AST node
1745 do
1746 if e /= Void then
1747 create Result.initialize (e, o)
1748 end
1749 end
1750
1751 new_un_strip_as (i: CONSTRUCT_LIST [INTEGER]; o: KEYWORD_AS; lp_as, rp_as: SYMBOL_AS): UN_STRIP_AS is
1752 -- New UN_STRIP AST node
1753 do
1754 if i /= Void then
1755 create Result.initialize (i, o, lp_as, rp_as)
1756 end
1757 end
1758
1759 new_unique_as (a_scn: EIFFEL_SCANNER): UNIQUE_AS is
1760 -- New UNIQUE AST node
1761 require
1762 a_scn_not_void: a_scn /= Void
1763 do
1764 create Result.make_with_location (a_scn.line, a_scn.column, a_scn.position, a_scn.text_count)
1765 end
1766
1767 new_variant_as (t: ID_AS; e: EXPR_AS; k_as: KEYWORD_AS; s_as: SYMBOL_AS): VARIANT_AS is
1768 -- New VARIANT AST node
1769 do
1770 if e /= Void then
1771 create Result.make (t, e, k_as, s_as)
1772 end
1773 end
1774
1775 new_verbatim_string_as (s, marker: STRING; is_indentable: BOOLEAN; l, c, p, n: INTEGER; buf: STRING): VERBATIM_STRING_AS is
1776 -- New VERBATIM_STRING AST node
1777 require
1778 s_not_void: s /= Void
1779 marker_not_void: marker /= Void
1780 l_non_negative: l >= 0
1781 c_non_negative: c >= 0
1782 p_non_negative: p >= 0
1783 n_non_negative: n >= 0
1784 do
1785 if s /= Void and marker /= Void then
1786 create Result.initialize (s, marker, is_indentable, l, c, p, n)
1787 end
1788 end
1789
1790 new_void_as (a_scn: EIFFEL_SCANNER): VOID_AS is
1791 -- New VOID AST node
1792 require
1793 a_scn_not_void: a_scn /= Void
1794 do
1795 create Result.make_with_location (a_scn.line, a_scn.column, a_scn.position, a_scn.text_count)
1796 end
1797
1798 new_class_list_as (n: INTEGER): CLASS_LIST_AS is
1799 -- New empty list of CLASS_LIST AST node
1800 require
1801 n_non_negative: n >= 0
1802 do
1803 create Result.make (n)
1804 ensure
1805 list_full: Result /= Void implies Result.capacity = n and Result.all_default
1806 end
1807
1808 new_local_dec_list_as (l: EIFFEL_LIST [TYPE_DEC_AS]; k_as: KEYWORD_AS): LOCAL_DEC_LIST_AS is
1809 -- New LOCAL_DEC_LIST AST node
1810 do
1811 if l /= Void then
1812 create Result.make (l, k_as)
1813 end
1814 end
1815
1816 new_formal_argu_dec_list_as (l: EIFFEL_LIST [TYPE_DEC_AS]; l_as, r_as: SYMBOL_AS): FORMAL_ARGU_DEC_LIST_AS is
1817 -- New FORMAL_ARGU_DEC_LIST AST node
1818 do
1819 create Result.make (l, l_as, r_as)
1820 end
1821
1822 new_debug_key_list_as (l: EIFFEL_LIST [STRING_AS]; l_as, r_as: SYMBOL_AS): DEBUG_KEY_LIST_AS is
1823 -- New DEBUG_KEY_LIST AST node
1824 do
1825 create Result.make (l, l_as, r_as)
1826 end
1827
1828 new_delayed_actual_list_as (l: EIFFEL_LIST [OPERAND_AS]; l_as, r_as: SYMBOL_AS): DELAYED_ACTUAL_LIST_AS is
1829 -- New DELAYED_ACTUAL_LIST AST node
1830 do
1831 create Result.make (l, l_as, r_as)
1832 end
1833
1834 new_rename_clause_as (l: EIFFEL_LIST [RENAME_AS]; k_as: KEYWORD_AS): RENAME_CLAUSE_AS is
1835 -- New RENAME_CLAUSE AST node
1836 do
1837 create Result.make (l, k_as)
1838 end
1839
1840 new_export_clause_as (l: EIFFEL_LIST [EXPORT_ITEM_AS]; k_as: KEYWORD_AS): EXPORT_CLAUSE_AS is
1841 -- New EXPORT_CLAUSE AST node
1842 do
1843 create Result.make (l, k_as)
1844 end
1845
1846 new_undefine_clause_as (l: EIFFEL_LIST [FEATURE_NAME]; k_as: KEYWORD_AS): UNDEFINE_CLAUSE_AS is
1847 -- New UNDEFINE_CLAUSE AST node
1848 do
1849 create Result.make (l, k_as)
1850 end
1851
1852 new_redefine_clause_as (l: EIFFEL_LIST [FEATURE_NAME]; k_as: KEYWORD_AS): REDEFINE_CLAUSE_AS is
1853 -- New REDEFINE_CLAUSE AST node
1854 do
1855 create Result.make (l, k_as)
1856 end
1857
1858 new_select_clause_as (l: EIFFEL_LIST [FEATURE_NAME]; k_as: KEYWORD_AS): SELECT_CLAUSE_AS is
1859 -- New SELECT_CLAUSE AST node
1860 do
1861 create Result.make (l, k_as)
1862 end
1863
1864 new_creation_constrain_triple (fl: EIFFEL_LIST [FEATURE_NAME]; c_as, e_as: KEYWORD_AS): CREATION_CONSTRAIN_TRIPLE is
1865 -- New CREATION_CONSTRAIN_TRIPLE object
1866 do
1867 create Result.make (fl, c_as, e_as)
1868 end
1869
1870 indexing
1871 copyright: "Copyright (c) 1984-2006, Eiffel Software"
1872 license: "GPL version 2 (see http://www.eiffel.com/licensing/gpl.txt)"
1873 licensing_options: "http://www.eiffel.com/licensing"
1874 copying: "[
1875 This file is part of Eiffel Software's Eiffel Development Environment.
1876
1877 Eiffel Software's Eiffel Development Environment is free
1878 software; you can redistribute it and/or modify it under
1879 the terms of the GNU General Public License as published
1880 by the Free Software Foundation, version 2 of the License
1881 (available at the URL listed under "license" above).
1882
1883 Eiffel Software's Eiffel Development Environment is
1884 distributed in the hope that it will be useful, but
1885 WITHOUT ANY WARRANTY; without even the implied warranty
1886 of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
1887 See the GNU General Public License for more details.
1888
1889 You should have received a copy of the GNU General Public
1890 License along with Eiffel Software's Eiffel Development
1891 Environment; if not, write to the Free Software Foundation,
1892 Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
1893 ]"
1894 source: "[
1895 Eiffel Software
1896 356 Storke Road, Goleta, CA 93117 USA
1897 Telephone 805-685-1006, Fax 805-685-6869
1898 Website http://www.eiffel.com
1899 Customer support http://support.eiffel.com
1900 ]"
1901
1902 end -- class AST_FACTORY
1903

Properties

Name Value
svn:eol-style native
svn:keywords Author Date Id Revision

  ViewVC Help
Powered by ViewVC 1.1.23