/[eiffelstudio]/branches/CAT_mono/Src/Eiffel/eiffel/genericity/cl_type_i.e
ViewVC logotype

Contents of /branches/CAT_mono/Src/Eiffel/eiffel/genericity/cl_type_i.e

Parent Directory Parent Directory | Revision Log Revision Log


Revision 39412 - (show annotations)
Sat Oct 4 22:08:21 2003 UTC (16 years, 4 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/genericity/cl_type_i.e
File size: 13908 byte(s)
Fixed eweasel bug exec176. The change is quite dramatic. Instead of generating
special marker in `typarr' for anchored type, we generate just 0. Then the associated
entry is computed later on by applying RTID to the result since `typarr' needs
the `static_type_id', not the `type_id' when in workbench mode.
Moreover when a type has a `cr_info' then we generate the info for this only,
we do not repeat code generation for the type we think we have. I don't understand
why it was done before, I think this was just a mistake to do both, so now
they are separated by a `else'.

1 indexing
2 description: "Type class."
3 date: "$Date$"
4 revision: "$Revision$"
5
6 class CL_TYPE_I
7
8 inherit
9 TYPE_I
10 redefine
11 is_reference,
12 is_true_expanded,
13 is_separate,
14 is_valid,
15 is_explicit,
16 is_external,
17 same_as,
18 c_type,
19 instantiation_in,
20 complete_instantiation_in,
21 conforms_to_array,
22 generated_id,
23 generate_cid,
24 make_gen_type_byte_code,
25 generate_cid_array,
26 generate_cid_init,
27 generate_gen_type_il,
28 generate_expanded_creation
29 end
30
31 DEBUG_OUTPUT
32 export
33 {NONE} all
34 end
35
36 SHARED_IL_CASING
37 export
38 {NONE} all
39 end
40
41 SHARED_GENERATION
42 export
43 {NONE} all
44 end
45
46 SHARED_DECLARATIONS
47 export
48 {NONE} all
49 end
50
51 create
52 make
53
54 feature {NONE} -- Initialization
55
56 make (id: INTEGER) is
57 -- Create new instance of `Current' with `class_id'
58 -- assigned with `id'.
59 require
60 valid_id: id > 0
61 do
62 class_id := id
63 ensure
64 class_id_set: class_id = id
65 end
66
67 feature -- Access
68
69 class_id: INTEGER
70 -- Base class id of the type class
71
72 meta_generic: META_GENERIC is
73 -- Meta generic array describing the type class
74 do
75 -- No meta generic in non-generic type
76 end
77
78 cr_info : CREATE_INFO
79 -- Additional information for the creation
80 -- of generic types with anchored parameters
81
82 true_generics : ARRAY [TYPE_I] is
83 -- Array of generics: no mapping reference -> REFERENCE_I
84 do
85 -- Non generic types don't have them
86 end
87
88 base_class: CLASS_C is
89 -- Base class associated to the class type
90 do
91 Result := System.class_of_id (class_id)
92 end
93
94 type_a: CL_TYPE_A is
95 do
96 create Result.make (class_id)
97 Result.set_is_true_expanded (is_true_expanded)
98 Result.set_is_separate (is_separate)
99 end
100
101 il_type_name (a_prefix: STRING): STRING is
102 -- Class name of current type.
103 local
104 l_class_c: like base_class
105 l_is_precompiled: BOOLEAN
106 l_cl_type: like associated_class_type
107 do
108 l_class_c := base_class
109 if l_class_c.is_external then
110 Result := clone (l_class_c.external_class_name)
111 else
112 l_is_precompiled := l_class_c.is_precompiled
113 if l_is_precompiled then
114 l_cl_type := associated_class_type
115 l_is_precompiled := l_cl_type.is_precompiled
116 if l_is_precompiled then
117 Result := associated_class_type.il_type_name (a_prefix)
118 end
119 end
120 if not l_is_precompiled then
121 Result := internal_il_type_name (clone (l_class_c.name), a_prefix)
122 end
123 end
124 end
125
126 instantiation_in (other: GEN_TYPE_I): CL_TYPE_I is
127 -- Instantiation of Current in context of `other'
128 require else
129 True
130 do
131 Result := Current
132 end
133
134 complete_instantiation_in (other: GEN_TYPE_I): CL_TYPE_I is
135 -- Instantiation of Current in context of `other'
136 require else
137 True
138 do
139 Result := Current
140 end
141
142 description: ATTR_DESC is
143 -- Type description for skeletons
144 local
145 exp: EXPANDED_DESC
146 ref: REFERENCE_DESC
147 do
148 if is_true_expanded then
149 create exp
150 is_true_expanded := False
151 exp.set_class_type (base_class.types.search_item (Current))
152 is_true_expanded := True
153 exp.set_type_i (Current)
154 Result := exp
155 elseif is_separate then
156 -- FIXME
157 Result := c_type.description
158 else
159 Result := c_type.description
160 end
161
162 ref ?= Result
163 if ref /= Void then
164 ref.set_type_i (Current)
165 end
166 end
167
168 c_type: TYPE_C is
169 -- Associated C type
170 do
171 Result := Reference_c_type
172 end
173
174 associated_class_type: CLASS_TYPE is
175 -- Associated class type
176 require
177 -- has: has_associated_class_type
178 do
179 if is_true_expanded then
180 is_true_expanded := False
181 Result := base_class.types.search_item (Current)
182 is_true_expanded := True
183 elseif is_separate then
184 is_separate := False
185 Result := base_class.types.search_item (Current)
186 is_separate := True
187 else
188 Result := base_class.types.search_item (Current)
189 end
190 end
191
192 type_id: INTEGER is
193 -- Type id of the correponding class type
194 do
195 Result := associated_class_type.type_id
196 end
197
198 sk_value: INTEGER is
199 -- Generate SK value associated to the current type.
200 do
201 -- FIXME????: separate
202 if not is_true_expanded then
203 Result := Sk_ref | (type_id - 1)
204 else
205 is_true_expanded := False
206 Result := Sk_exp | (type_id - 1)
207 is_true_expanded := True
208 end
209 end
210
211 cecil_value: INTEGER is
212 do
213 -- FIXME????: separate
214 if not is_true_expanded then
215 Result := Sk_dtype
216 else
217 Result := Sk_exp | class_id
218 end
219 end
220
221 hash_code: INTEGER is
222 -- Hash code for current type
223 do
224 Result := Other_code + class_id
225 end
226
227 feature -- Status
228
229 element_type: INTEGER_8 is
230 -- Void element type
231 do
232 if is_expanded and base_class.is_external then
233 -- We only support expanded for external class at the moment.
234 Result := feature {MD_SIGNATURE_CONSTANTS}.Element_type_valuetype
235 else
236 if class_id = System.system_string_class.compiled_class.class_id then
237 Result := feature {MD_SIGNATURE_CONSTANTS}.Element_type_string
238 elseif class_id = System.system_object_id then
239 Result := feature {MD_SIGNATURE_CONSTANTS}.Element_type_object
240 else
241 Result := feature {MD_SIGNATURE_CONSTANTS}.Element_type_class
242 end
243 end
244 end
245
246 is_true_expanded: BOOLEAN
247 -- Is the type expanded?
248
249 is_separate: BOOLEAN
250 -- Is the type separate?
251
252 is_enum: BOOLEAN is
253 -- Is current type an IL enum type?
254 -- Useful to find out if some call optimization can be done
255 -- in FEATURE_B.
256 require
257 il_generation: System.il_generation
258 do
259 Result := is_true_expanded and then base_class.is_enum
260 end
261
262 is_external: BOOLEAN is
263 -- Is current type an IL enum type?
264 -- Useful to find out if some call optimization can be done
265 -- in FEATURE_B.
266 do
267 Result := base_class.is_external
268 end
269
270 is_valid: BOOLEAN is
271 -- Is the base class still in the system and matches its specification?
272 do
273 Result := base_class /= Void and then (base_class.generics = Void)
274 end
275
276 is_reference: BOOLEAN is
277 -- Is the type a reference type ?
278 do
279 Result := not is_true_expanded
280 end;
281
282 is_explicit: BOOLEAN is
283
284 do
285 Result := (cr_info = Void) or else is_expanded
286 end
287
288 has_associated_class_type: BOOLEAN is
289 -- Has `Current' an associated class type?
290 do
291 if is_true_expanded then
292 is_true_expanded := False
293 Result := base_class.types.has_type (Current)
294 is_true_expanded := True
295 elseif is_separate then
296 is_separate := False
297 Result := base_class.types.has_type (Current)
298 is_separate := True
299 else
300 Result := base_class.types.has_type (Current)
301 end
302 end
303
304 same_as (other: TYPE_I): BOOLEAN is
305 -- Is `other' equal to Current ?
306 local
307 other_cl_type: CL_TYPE_I
308 do
309 other_cl_type ?= other
310 Result := other_cl_type /= Void -- FIXME
311 and then other_cl_type.class_id = class_id
312 and then other_cl_type.is_true_expanded = is_true_expanded
313 and then other_cl_type.is_separate = is_separate
314 and then other_cl_type.meta_generic = Void
315 and then other_cl_type.true_generics = Void
316 end
317
318 feature -- Setting
319
320 set_is_true_expanded (b: BOOLEAN) is
321 -- Assign `b' to `is_true_expanded'.
322 do
323 is_true_expanded := b
324 ensure
325 is_true_expanded_set: is_true_expanded = b
326 end
327
328 set_is_separate (b: BOOLEAN) is
329 -- Assign `b' to `is_separate'.
330 do
331 is_separate := b
332 ensure
333 is_separate_set: is_separate = b
334 end
335
336 set_cr_info (cinfo : CREATE_INFO) is
337 -- Set `cr_info' to `cinfo'.
338 require
339 create_info_not_void: cinfo /= Void
340 do
341 cr_info := cinfo
342 ensure
343 cr_info_set : cr_info = cinfo
344 end
345
346 feature -- Formatting
347
348 append_signature (st: STRUCTURED_TEXT) is
349 do
350 if is_true_expanded then
351 st.add_string ("expanded ")
352 elseif is_separate then
353 st.add_string ("separate ")
354 end
355 base_class.append_signature (st)
356 end
357
358 dump (buffer: GENERATION_BUFFER) is
359 do
360 buffer.putstring (debug_output)
361 end
362
363 feature -- C generation
364
365 generate_expanded_creation (byte_code: BYTE_CODE; reg: REGISTRABLE; workbench_mode: BOOLEAN) is
366 -- Generate creation of expanded object associated to Current.
367 local
368 gen_type: GEN_TYPE_I
369 written_class: CLASS_C
370 class_type, written_type: CLASS_TYPE
371 creation_feature: FEATURE_I
372 c_name: STRING
373 buffer: GENERATION_BUFFER
374 do
375 buffer := byte_code.buffer
376
377 gen_type ?= Current
378
379 if gen_type /= Void then
380 byte_code.generate_block_open
381 byte_code.generate_gen_type_conversion (gen_type)
382 end
383 reg.print_register
384 if workbench_mode then
385 -- RTLX is a macro used to create
386 -- expanded types
387 if gen_type /= Void then
388 buffer.putstring (" = RTLX(typres")
389 else
390 buffer.putstring (" = RTLX(RTUD(")
391 buffer.generate_type_id (associated_class_type.static_type_id)
392 buffer.putchar (')')
393 end
394 else
395 if gen_type /= Void then
396 buffer.putstring (" = RTLN(typres")
397 else
398 buffer.putstring (" = RTLN(")
399 buffer.putint (type_id - 1)
400 end
401 class_type := associated_class_type
402 creation_feature := class_type.associated_class.creation_feature
403 if creation_feature /= Void then
404 written_class := System.class_of_id (creation_feature.written_in)
405 if written_class.generics = Void then
406 written_type := written_class.types.first
407 else
408 written_type :=
409 written_class.meta_type (class_type.type).associated_class_type
410 end
411 c_name := Encoder.feature_name (written_type.static_type_id,
412 creation_feature.body_index)
413 buffer.putstring (");")
414 buffer.new_line
415 buffer.putstring (c_name)
416 buffer.putchar ('(')
417 reg.print_register
418 Extern_declarations.add_routine_with_signature (Void_c_type,
419 c_name, <<"EIF_REFERENCE">>)
420 end
421 end
422 buffer.putchar (')')
423 buffer.putchar (';')
424
425 if gen_type /= Void then
426 byte_code.generate_block_close
427 end
428 buffer.new_line
429 end
430
431 generate_cecil_value (buffer: GENERATION_BUFFER) is
432 -- Generate cecil value
433 do
434 -- FIXME????: separate
435 if not is_true_expanded then
436 buffer.putstring ("SK_DTYPE")
437 else
438 buffer.putstring ("SK_EXP + (uint32) ")
439 buffer.putint (associated_class_type.type_id - 1)
440 end
441 end
442
443 feature -- Array optimization
444
445 conforms_to_array: BOOLEAN is
446 do
447 Result := base_class.conform_to (array_class_c)
448 end
449
450 feature {NONE} -- Array optimization
451
452 array_class_c: CLASS_C is
453 once
454 Result := System.array_class.compiled_class
455 end
456
457 feature -- Generic conformance
458
459 generated_id (final_mode : BOOLEAN) : INTEGER is
460
461 do
462 if final_mode then
463 Result := type_id - 1
464 else
465 Result := associated_class_type.static_type_id-1
466 end
467
468 if is_true_expanded then
469 Result := Expanded_level - Result
470 end
471 end
472
473 generate_cid (buffer : GENERATION_BUFFER; final_mode, use_info : BOOLEAN) is
474
475 do
476 if
477 use_info and then (cr_info /= Void)
478 and then not is_expanded
479 then
480 -- It's an anchored type
481 cr_info.generate_cid (buffer, final_mode)
482 else
483 buffer.putint (generated_id (final_mode))
484 buffer.putstring (", ")
485 end
486 end
487
488 make_gen_type_byte_code (ba : BYTE_ARRAY; use_info : BOOLEAN) is
489 do
490 if
491 use_info and then (cr_info /= Void)
492 and then not is_expanded
493 then
494 -- It's an anchored type
495 cr_info.make_gen_type_byte_code (ba)
496 else
497 ba.append_short_integer (generated_id (False))
498 end
499 end
500
501 generate_cid_array (buffer : GENERATION_BUFFER;
502 final_mode, use_info : BOOLEAN; idx_cnt : COUNTER) is
503 local
504 dummy : INTEGER
505 do
506 if
507 use_info and then (cr_info /= Void)
508 and then not is_expanded
509 then
510 -- It's an anchored type
511 cr_info.generate_cid_array (buffer, final_mode, idx_cnt)
512 else
513 buffer.putint (generated_id (final_mode))
514 buffer.putstring (", ")
515
516 -- Increment counter
517 dummy := idx_cnt.next
518 end
519 end
520
521 generate_cid_init (buffer : GENERATION_BUFFER;
522 final_mode, use_info : BOOLEAN; idx_cnt : COUNTER) is
523 local
524 dummy : INTEGER
525 do
526 if
527 use_info and then (cr_info /= Void)
528 and then not is_expanded
529 then
530 -- It's an anchored type
531 cr_info.generate_cid_init (buffer, final_mode, idx_cnt)
532 else
533 dummy := idx_cnt.next
534 end
535 end
536
537 feature -- Generic conformance for IL
538
539 generate_gen_type_il (il_generator: IL_CODE_GENERATOR; use_info : BOOLEAN) is
540 -- `use_info' is true iff we generate code for a
541 -- creation instruction.
542 do
543 if use_info and then cr_info /= Void then
544 -- It's an anchored type, we call feature
545 -- that will tell us the real type of the
546 -- anchor in the context of Current.
547 cr_info.generate_il_type
548 else
549 il_generator.generate_class_type_instance (Current)
550 end
551 end
552
553 feature -- Output
554
555 debug_output: STRING is
556 -- String that should be displayed in debugger to represent `Current'.
557 do
558 create Result.make (32)
559 if is_true_expanded then
560 Result.append ("expanded ")
561 elseif is_separate then
562 Result.append ("separate ")
563 end
564 Result.append (base_class.name_in_upper)
565 end
566
567 feature {NONE} -- Implementation
568
569 internal_il_type_name (a_base_name, a_prefix: STRING): STRING is
570 -- Full type name of `a_base_name' using `a_prefix' in IL code generation
571 -- with namespace specification
572 require
573 a_base_name_not_void: a_base_name /= Void
574 local
575 l_name: STRING
576 do
577 Result := a_base_name
578 l_name := base_class.lace_class.actual_namespace
579 if a_prefix /= Void then
580 if l_name.is_empty then
581 l_name := a_prefix + "."
582 else
583 l_name := il_casing.namespace_casing (System.dotnet_naming_convention,
584 l_name) + "." + a_prefix + "."
585 end
586 else
587 if not l_name.is_empty then
588 l_name := il_casing.namespace_casing (System.dotnet_naming_convention,
589 l_name) + "."
590 end
591 end
592 Result := l_name + il_casing.pascal_casing (System.dotnet_naming_convention,
593 Result, feature {IL_CASING_CONVERSION}.upper_case)
594 ensure
595 internal_il_type_name_not_void: Result /= Void
596 internal_il_type_name_not_empty: not Result.is_empty
597 end
598
599 end

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.23