/[eiffelstudio]/branches/eth/eve/Src/Eiffel/eiffel/byte_code/byte_context.e
ViewVC logotype

Log of /branches/eth/eve/Src/Eiffel/eiffel/byte_code/byte_context.e

Parent Directory Parent Directory | Revision Log Revision Log


Links to HEAD: (view) (annotate)
Sticky Revision:

Revision 94983 - (view) (annotate) - [select for diffs]
Modified Fri May 2 11:05:28 2014 UTC (5 years, 5 months ago) by jasonw
File length: 91868 byte(s)
Diff to previous 94581
<<Merged from trunk#94978.>>

Revision 94581 - (view) (annotate) - [select for diffs]
Modified Fri Mar 7 11:57:58 2014 UTC (5 years, 7 months ago) by jasonw
File length: 92264 byte(s)
Diff to previous 93780
<<Merged from trunk#94580.>>

Revision 93780 - (view) (annotate) - [select for diffs]
Modified Fri Dec 20 15:08:05 2013 UTC (5 years, 9 months ago) by jasonw
File length: 92238 byte(s)
Diff to previous 92499
<<Merged from trunk#93779.>>

Revision 92499 - (view) (annotate) - [select for diffs]
Modified Fri Apr 26 23:06:21 2013 UTC (6 years, 5 months ago) by jasonw
File length: 92471 byte(s)
Diff to previous 91379
<<Merged from trunk#92492.>>

Revision 91379 - (view) (annotate) - [select for diffs]
Modified Fri Mar 15 08:48:07 2013 UTC (6 years, 7 months ago) by jasonw
File length: 92471 byte(s)
Diff to previous 89535
<<Merged from trunk#91375.>>

Revision 89535 - (view) (annotate) - [select for diffs]
Modified Fri Oct 5 06:46:18 2012 UTC (7 years ago) by jasonw
File length: 92753 byte(s)
Diff to previous 89347
<<Merged from trunk#89534.>>

Revision 89347 - (view) (annotate) - [select for diffs]
Modified Fri Aug 10 15:09:25 2012 UTC (7 years, 2 months ago) by jasonw
File length: 92751 byte(s)
Diff to previous 87069
<<Merged from trunk#89346.>>

Revision 87069 - (view) (annotate) - [select for diffs]
Modified Fri Aug 19 18:04:34 2011 UTC (8 years, 1 month ago) by jasonw
File length: 92772 byte(s)
Diff to previous 86696
<<Merged from trunk#87065.>>

Revision 86696 - (view) (annotate) - [select for diffs]
Modified Fri Jun 10 11:12:57 2011 UTC (8 years, 4 months ago) by jasonw
File length: 90821 byte(s)
Diff to previous 86354
<<Merged from trunk#86694.>>

Revision 86354 - (view) (annotate) - [select for diffs]
Modified Fri Apr 29 18:23:18 2011 UTC (8 years, 5 months ago) by jasonw
File length: 90610 byte(s)
Diff to previous 86099
<<Merged from trunk#86353.>>

Revision 86099 - (view) (annotate) - [select for diffs]
Modified Fri Apr 1 08:07:39 2011 UTC (8 years, 6 months ago) by jasonw
File length: 87795 byte(s)
Diff to previous 85720
<<Merged from trunk#86097.>>

Revision 85720 - (view) (annotate) - [select for diffs]
Modified Fri Feb 25 11:20:29 2011 UTC (8 years, 7 months ago) by jasonw
File length: 87534 byte(s)
Diff to previous 85496
<<Merged from trunk#85719.>>

Revision 85496 - (view) (annotate) - [select for diffs]
Modified Fri Jan 28 14:31:42 2011 UTC (8 years, 8 months ago) by jasonw
File length: 87549 byte(s)
Diff to previous 84470
<<Merged from trunk#85495.>>

Revision 84470 - (view) (annotate) - [select for diffs]
Modified Fri Oct 1 14:01:07 2010 UTC (9 years ago) by jasonw
File length: 87638 byte(s)
Diff to previous 84363
<<Merged from trunk#84468.>>


Revision 84363 - (view) (annotate) - [select for diffs]
Modified Fri Sep 3 09:37:49 2010 UTC (9 years, 1 month ago) by jasonw
File length: 87377 byte(s)
Diff to previous 83524
<<Merged from trunk#84362.>>

Revision 83524 - (view) (annotate) - [select for diffs]
Modified Fri Jun 11 08:12:14 2010 UTC (9 years, 4 months ago) by jasonw
File length: 87140 byte(s)
Diff to previous 83445
<<Merged from trunk#83523.>>

Revision 83445 - (view) (annotate) - [select for diffs]
Modified Sat Jun 5 15:29:40 2010 UTC (9 years, 4 months ago) by jasonw
File length: 87313 byte(s)
Diff to previous 83441
<<Merged from trunk@83442.>>

Revision 83441 - (view) (annotate) - [select for diffs]
Modified Sat Jun 5 13:52:53 2010 UTC (9 years, 4 months ago) by jasonw
File length: 86334 byte(s)
Diff to previous 83331
Renamed branch eve3 to eve. The eve branch serves as the new branch for the EVE project.

Revision 83331 - (view) (annotate) - [select for diffs]
Modified Wed May 26 18:49:35 2010 UTC (9 years, 4 months ago) by jasonw
Original Path: branches/eth/eve3/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 86334 byte(s)
Diff to previous 82897
<<Breanched from trunk@83330>> Created a branch to upgrade Eiffel Transform library to trunk.

Revision 82897 - (view) (annotate) - [select for diffs]
Modified Wed Apr 21 09:35:44 2010 UTC (9 years, 5 months ago) by alexk
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 86334 byte(s)
Diff to previous 82888
Made classes to be used in facility inheritance deferred so that they cannot be (directly) used as suppliers and ensured they do not export any immediate features.

Revision 82888 - (view) (annotate) - [select for diffs]
Modified Tue Apr 20 19:14:36 2010 UTC (9 years, 5 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 86188 byte(s)
Diff to previous 82803
Renamed {TYPE_C}.is_pointer into {TYPE_C}.is_reference as `is_pointer' did actually not represent the C type for a POINTER instance but EIF_REFERENCE for all the Eiffel reference types.


Revision 82803 - (view) (annotate) - [select for diffs]
Modified Mon Apr 12 15:57:46 2010 UTC (9 years, 6 months ago) by jfiat
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 86178 byte(s)
Diff to previous 82767
- Compiler: implementation for once per object (classic and dotnet)
- Debugger support for once per object (classic and dotnet)
- Minor refactorying related to once (mainly with expression evaluation in debugger)
- Added is_hidden for FEATURE_I with the counterpart on the runtime (minor change for IS_TRANSIENT...)

Revision 82767 - (view) (annotate) - [select for diffs]
Modified Thu Apr 8 04:45:50 2010 UTC (9 years, 6 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 85961 byte(s)
Diff to previous 82752
Migrated SK_CHAR and SK_WCHAR to SK_CHAR8 and SK_CHAR32 for consistency. Updated the Eiffel code.
Updated the runtime to use EIF_CHARACTER_8 and EIF_CHARACTER_32 in place of EIF_CHARACTER and EIF_WIDE_CHAR.


Revision 82752 - (view) (annotate) - [select for diffs]
Modified Fri Apr 2 15:28:24 2010 UTC (9 years, 6 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 85957 byte(s)
Diff to previous 81548
Started to use the C_CONST class instead of manifest strings to generate the C code.


Revision 81548 - (view) (annotate) - [select for diffs]
Modified Sat Nov 14 00:42:04 2009 UTC (9 years, 11 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 85831 byte(s)
Diff to previous 81455
Fixed a bunch of .NET eweasel tests which would fail because we inadvertently removed some code that was protecting the code (see rev#81207 for where it was introduced).


Revision 81455 - (view) (annotate) - [select for diffs]
Modified Fri Nov 6 17:40:38 2009 UTC (9 years, 11 months ago) by jfiat
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 85108 byte(s)
Diff to previous 81214
Added/fixed debugger's support for the new loop construct (mapped breakpoint slots with generated code)

Revision 81214 - (view) (annotate) - [select for diffs]
Modified Thu Oct 22 00:05:06 2009 UTC (9 years, 11 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 84133 byte(s)
Diff to previous 81207
While extending eweasel test#svalid025, I found it still crashed. The issue had to do with the type of an object test local from the generic parent class, let's say the type is A [G], but the descendant class has no generic. We still kept A [G] as the type of the local and because descendant class is not generic, it would simply crash. The solution was to store the type as it appears in the ancestor in the OBJECT_TEST_LOCAL_B node, and resolved the type of those locals accordingly using the `BYTE_CONTEXT.real_type' feature.
The other thing that had to change is the building of the local list for the redefined routines when merging the assertions. We have slightly modified BYTE_CONTEXT.add_object_test_locals to call `descendant_type' and its caller INHERITED_ASSERTION.add_object_test_locals to properly initialized the context.


Revision 81207 - (view) (annotate) - [select for diffs]
Modified Wed Oct 21 16:28:04 2009 UTC (9 years, 11 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 84225 byte(s)
Diff to previous 80780
Fixed eweasel test#term156 and test#svalid025 (and made sure that test#exec286 was still passing) and bug#16352.
The issue was related to the way types were recomputed in descendant. In the case it involved a formal we were trying to do that twice, but then the second time it simply fails since the new type has no sense for the parent. The solution was to make sure that CREATE_INFO nodes that are created for the `BYTE_CONTEXT.class_type' context are solved for `BYTE_CONTEXT.context_class_type' once using the newly introduced `updated_info' query. Once done nothing special needs to be done. Also if you need to construct a CREATE_INFO from a TYPE_A instance we made sure not to call `updated_info' if the type was already resolved for `BYTE_CONTEXT.context_class_type'.
Removed useless `CREATE_INFO.created_in' and `BYTE_CONTEXT.real_type_in_fixed' routines.


Revision 80780 - (view) (annotate) - [select for diffs]
Modified Mon Sep 21 16:13:26 2009 UTC (10 years ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 84910 byte(s)
Diff to previous 80376
Fixed eweasel test#melt097 by ensuring that when a type expression as an attachment mark,
  the generated code by the compiler preserves it (it currently was discarding it). The same
  change was done for the catcall checker as we only checked if the type as the attachment mark
  and not if the type was attached. Updated the interpreter accordingly.
Removed hard-coding of {TYPE}.has_default code generation, the built-in external is fine. Kept the
  code from the built_ins directory for the code generation, but this time we simply remove the check
  from the code generation since it should work for detachable references.


Revision 80376 - (view) (annotate) - [select for diffs]
Modified Fri Aug 21 06:20:33 2009 UTC (10 years, 1 month ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 84928 byte(s)
Diff to previous 80247
Replaced call to `clear_all' from either STRING_XX or HASH_TABLE by `wipe_out' as `clear_all' is now obsolete.


Revision 80247 - (view) (annotate) - [select for diffs]
Modified Thu Aug 13 17:24:47 2009 UTC (10 years, 2 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 84929 byte(s)
Diff to previous 79484
To prevent many eweasel tests to fail due to missing C compilation that was required with the addition
  of `generating_type: TYPE [like Current]' in ANY, we made sure that the compiler would not force a
  freeze each time a new generic derivation of TYPE was added to the system (it was freezing because TYPE
  contains some C externals). To prevent the freeze, now in the case of TYPE we say no need to freeze
  and we have augmented the interpreter with the ability to generate in byte code EXTERNAL_B node assuming
  they are builtin.
Fixed a bug in the code generation of the manifest type `{like Current}' in ANY. Indeed from ANY's point
  of view, like Current is a reference and it was generating the TYPE instance for the reference generice
  derivation of TYPE. Unfortunately when the descendant is expanded it uses the wrong generic derivation
  and code fails at execution. To prevent that problem, a manifest type creation only compute the type
  of its actual generic parameter, and then in the runtime we added `eif_typeof_type_of' which computes
  the approprite TYPE generic derivation to use based on the actual type. Because of that the 
  `rt_type_set' is indexed via the actual generic parameter type rather than by the type of the TYPE instance.
  Note the entry is actually `dftype + 1' as the 0 index is for TYPE [NONE].
Fixed missing analyze of type in TYPE_EXPR_B causing `Current' not to be registered for GC in finalized mode
  when generating a routine with just `Result := {like Current}'. This was making eweasel test#runtime005
  fail.
Fixed a bug in processing TYPED_POINTER associated CLASS_TYPE because the actual generic parameter recorded
  in `basic_type' could be anything and thus would be out of context.
Removed native processing of `generating_type' for basic types since now we need to generate STRING in
  non-experimental mode and TYPE [like Current] in experimental mode.
Renamed private `sk_type' from eif_type_id.c into public `eif_dtype_to_sk_type' in `cecil.c'. This is used
  by the `eif_typeof_type_of' above to calculate the proper generic derivation.
Made `RTLNTY' and `eif_type_malloc' really thread safe (they were not previously due to resizing of
  `rt_type_set'.
Changed signature of `generate_cid_init' in TYPE_A to also take a context (this is needed for the LIKE_CURRENT
  descendant) and this matches the need for a context in `generate_cid' and `generate_cid_array'.
Fixed `internal_same_generic_derivation_as' in GEN_TYPE_A to properly process actual generic parameter
  which are LIKE_CURRENT. This fixes eweasel test#incr074 which was failing with the addition of 
  `generating_type: TYPE [like Current]' in ANY.
Changed LIKE_CURRENT to always use the context type when provided and if not `conformance_type'.
Refactored `generate_type_id' in CREATE_TYPE to use `generated_id' from TYPE_A. This is needed for allowing
  generating the type declaration of NONE.
This commit fixes eweasel test#melt097 and test#valid257.


Revision 79484 - (view) (annotate) - [select for diffs]
Modified Fri Jun 26 18:24:42 2009 UTC (10 years, 3 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 84898 byte(s)
Diff to previous 79139
Added support for unique instances of TYPE when representing the same Eiffel type.
Added speed up for computation of generic dynamic full type by not having `eif_compound_id' perform
  the cache checking. It is now done in the generated code making it slightly bigger but in a tight
  loop, which simply does t := {LIST [ANY]}, we went from 13s down to 4.5s.
Changed signature of crealloc and cmalloc to use `void *' instead of `char *'.
Added new builtin for class TYPE, even if that class has not yet been committed.


Revision 79139 - (view) (annotate) - [select for diffs]
Modified Mon Jun 8 21:56:42 2009 UTC (10 years, 4 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 84559 byte(s)
Diff to previous 78446
Made code of the batch compiler compile with both the old and new version of EiffelBase.


Revision 78446 - (view) (annotate) - [select for diffs]
Modified Wed Apr 29 21:52:07 2009 UTC (10 years, 5 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 84546 byte(s)
Diff to previous 78050
Simplified the code generation of GC hooks since it did some useless checks.


Revision 78050 - (view) (annotate) - [select for diffs]
Modified Thu Apr 2 17:11:59 2009 UTC (10 years, 6 months ago) by alexk
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 84955 byte(s)
Diff to previous 77912
Fixed bug#15570 by tracking offsets for object test locals separately in inherited preconditions and postconditions as they may have the same code id, but different start position in the original code, or even the same start position, but they have to be registered for the same code id twice (see test#attach061).

Revision 77912 - (view) (annotate) - [select for diffs]
Modified Thu Mar 26 05:24:54 2009 UTC (10 years, 6 months ago) by tedf
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 83553 byte(s)
Diff to previous 77520
Integrated `{EXCEPTION}.cause' .NET implementation.

Revision 77520 - (view) (annotate) - [select for diffs]
Modified Wed Mar 4 01:50:25 2009 UTC (10 years, 7 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 83364 byte(s)
Diff to previous 77215
Updated to new syntax of object test and attached/detachable types using the `syntax_updater' tool.


Revision 77215 - (view) (annotate) - [select for diffs]
Modified Thu Feb 19 21:42:46 2009 UTC (10 years, 7 months ago) by king
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 83320 byte(s)
Diff to previous 76771
Added minor string optimizations

Revision 76771 - (view) (annotate) - [select for diffs]
Modified Tue Jan 20 05:05:28 2009 UTC (10 years, 8 months ago) by king
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 83302 byte(s)
Diff to previous 76432
Improved degree 4 implementation to alias feature i objects should no change be required, most reusable objects are now cached for each class pass resulting in far less memory, gc and disk space being used, aliasing can be further improved by not storing export information in the feature i objects themselves as well as redoing the somewhat broken is_origin implementation

Revision 76432 - (view) (annotate) - [select for diffs]
Modified Mon Dec 29 23:41:59 2008 UTC (10 years, 9 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 83284 byte(s)
Diff to previous 76398
Removal of `is' keyword.
Replacement of `is' by `=' for constant definitions.
Replaced `indexing' by `note'.


Revision 76398 - (view) (annotate) - [select for diffs]
Modified Thu Dec 25 15:09:35 2008 UTC (10 years, 9 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 83666 byte(s)
Diff to previous 76125
Fixed a Solaris Sparc 64 bug for misaligned data access for expanded stored on the C stack. The issue
  is that the structure we generate does not force the C compiler to properly align the structure on the
  stack. So instead of having a "char data [size + OVERHEAD]" structure, we now have "union overhead overhead;
  char data [size]" structure. The overhead field forces the proper alignment. And we have also verified
  that `data' is contiguous to the end of `overhead' otherwise this structure definition would not make sense.
  (This fixes eweasel test#incr234, test#runtime003, test#runtime004 and others using expanded.)


Revision 76125 - (view) (annotate) - [select for diffs]
Modified Tue Dec 9 20:24:44 2008 UTC (10 years, 10 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 83751 byte(s)
Diff to previous 75652
Added a context class to `conform_to'. This prevents having to use `System.current_class' in the case
  of formals and thus making the code more robust.


Revision 75652 - (view) (annotate) - [select for diffs]
Modified Sun Nov 16 05:05:37 2008 UTC (10 years, 11 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 84188 byte(s)
Diff to previous 75567
Fixed processing of TYPE_EXPR_AS to use {TYPE_A}.create_info rather than creating a CREATE_TYPE because the later
  would not remove the possible attachment mark that could appear when code is compiled in void-safe mode.
Fixed bug test#conform005 where assignment attempt or object test would not possible attachment mark that may appear
  via redefinition or via actual generic parameter.
Forbid the assignment attempts when target is attached by introducing a new validity rule vjrv3.
Fixed eweasel test#freez029 when using an object test local which is a formal type. A side effect of this fix which
  was to keep the original type of a local in BYTE_CONTEXT.local_list instead of the `real_type' version was
  to also fix eweasel test#exec284.

Revision 75567 - (view) (annotate) - [select for diffs]
Modified Thu Nov 13 20:39:48 2008 UTC (10 years, 11 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 84200 byte(s)
Diff to previous 75169
Added support for attachment marks at runtime in actual generic parameters:
- Updated runtime to understand annotation marks in our type arrays and all routines for 
  creating types and handling conformance.
- To properly handle conformance, a new entry in the type arrays generated in eparents.c have been
  added, it stores whether or not a type is attached. That is to say A inherits B, and when we check if
  !A conforms to !B, we modify the type array so that it has the attachment mark.
- Increased storable version number as old systems cannot understand the marks.
- Fixed catcall detection at runtime which was not properly handling attached arguments (as before
  we only check catcalls for non-void argument, but it the argument is attached, then we need to
  check that it is indeed not Void.
- Changed the Eiffel code generation so that even if we asked to create !A, we actually create A
  (i.e. we remove the annotation as they do not make sense for the type of an object).
- Made sure that a generic descriptor is created for attributes whose type is an attached non-generic type
  as well as a non-explicit type (e.g. formal/anchors).


Revision 75169 - (view) (annotate) - [select for diffs]
Modified Fri Oct 17 22:27:50 2008 UTC (10 years, 11 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 82173 byte(s)
Diff to previous 75076
Removed usage of RTID in generated code and run-time.
Removed generic conformance macros and directly use `eif_final_id', `eif_compound_id'
  and `eif_gen_param_id' in the generated C code.
Removed the `static type id' argument of most generic conformance routines because now we do not
  use it anymore and updated callers accordingly.
Improved `analyze' from CREATE_FEAT so that we use `dftype' instead of `Dftype (Current)' when
  generating code for a formal type.


Revision 75076 - (view) (annotate) - [select for diffs]
Modified Mon Oct 13 22:47:33 2008 UTC (11 years ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 82155 byte(s)
Diff to previous 75043
Improved {POLY_TABLE}.has_one_type to actually analyzed the deanchored form of a type, making
  it more likely to remove some dynamic queries for types.
Updated {BYTE_CONTEXT}.generate_gen_type_conversion to use `deep_actual_type' when the type is
  explicit, this is to remove the potential anchors we might have. Although this might not be
  needed if `has_formal_generic' was properly defined on LIKE_TYPE_A types.
To reduce code duplication, move the common implementation of `generate_gen_type_conversion'
  from CREATE_TYPE, CREATE_ARG and CREATE_FEAT into CREATE_INFO.


Revision 75043 - (view) (annotate) - [select for diffs]
Modified Thu Oct 9 04:37:36 2008 UTC (11 years ago) by alexk
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 81876 byte(s)
Diff to previous 74954
Added a check at the end of an external routine to ensure the result is not-void when it is of an attached type (see test#attach022).

Revision 74954 - (view) (annotate) - [select for diffs]
Modified Fri Oct 3 20:10:12 2008 UTC (11 years ago) by alexk
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 79298 byte(s)
Diff to previous 73697
Removed support for self-initializing types as they may be excluded from
the standard.
Prepared C code generation for attributes with explicit attribute bodies.
Integrated changes that address bug#14453.


Revision 73697 - (view) (annotate) - [select for diffs]
Modified Fri May 23 18:22:30 2008 UTC (11 years, 4 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 78386 byte(s)
Diff to previous 73367
Properly implemented the ~ operator on .NET.
Fixed .NET code generation which was generating incorrect code for the basic type when we changed the
  signature from `like Current' to the basic type. The issue is that our code generation was not good
  at changing the expanded status of an argument in a signature as this was not detected.
  To make this work, I also changed the code generation of basic type so that they use the basic type
  .NET equivalent rather than the value type we generate for all the signatures (see
  {BASIC_A}.generic_derivation change).
  And also changed a few things here and there for some various transformation of values from ref to
  basic and reverse.
Also if an inherited routine of an expanded class was calling a routine whose signature was changed
  in the expanded type (e.g. `infix "&"' in INTEGER_32 calling `bit_and' which is redefined) then
  we were calling the new `bit_and' routine but still using its inherited signature thus generating
  the wrong argument passing. So we fixed that by changing {CALL_ACCESS_B}.byte_node to update the
  call to the descendant signature but this caused eweasel test#exec060 to now fails. We tried to
  fix it but could not for the time being. The only result of that change is in {BYTE_CONTEXT}.real_type
  which has been factorized to use {BYTE_CONTEXT}.creation_type which now has a slightly different
  code for resolving types when handling inherited code. Other eweasel tests affected by this change
  but that are passing are test#incr288, test#expanded007 and test#melt069.
Had to change FEATURE_I.access to call the new {TYPE_A}.context_free_type instead of {TYPE_A}.deep_actual_type
  because otherwise the code generation in workbench mode for .NET of `abs_ref' in INTEGER would 
  be incorrect for the postcondition. Basically `context_free_type' only keeps `like Current' and gets
  rid of all the other anchors. The name is not that great since it is not completely free from context,
  but could not find one that express this.
 
Added some validity precondition in TYPE_A for `dispatch_anchors', `is_equivalent', `is_safe_equivalent'
  and `equivalent'. Updated REFERENCE_DESC to reflect that change.


Revision 73367 - (view) (annotate) - [select for diffs]
Modified Tue May 6 20:51:40 2008 UTC (11 years, 5 months ago) by king
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 78126 byte(s)
Diff to previous 73302
Now exporting put_register_name to REGISTER so that it may be reused to avoid unnecessary string creation.

Revision 73302 - (view) (annotate) - [select for diffs]
Modified Fri May 2 23:50:14 2008 UTC (11 years, 5 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 78098 byte(s)
Diff to previous 73127
Use an ARRAYED_STACK instead of a LINKED_LIST for efficiency/space usage.


Revision 73127 - (view) (annotate) - [select for diffs]
Modified Mon Apr 21 06:59:41 2008 UTC (11 years, 5 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 78092 byte(s)
Diff to previous 73010
Fixed eweasel test#attach018 by resetting `assertion_type' after each time it was used
  since it is used for computing the type of an object test. Otherwise after generating
  code for an invariant containing an object test, the compiler would crash when
  generating the next routine which has an object test.
Replaced `LINKED_LIST' by `ARRAYED_LIST' since it is faster for `i_th' operation.


Revision 73010 - (view) (annotate) - [select for diffs]
Modified Fri Apr 11 20:17:02 2008 UTC (11 years, 6 months ago) by alexk
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 78110 byte(s)
Diff to previous 72959
Supported object tests in class invariant (this fixes test#attach008).

Revision 72959 - (view) (annotate) - [select for diffs]
Modified Sat Apr 5 17:59:09 2008 UTC (11 years, 6 months ago) by jfiat
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 72676 byte(s)
Diff to previous 72891
- better catcall detection control (console and debugger)
- use remote evaluation for remote store/load object, and also for most of the replay mechanism
  (this makes the runtime lighter and cleaner)
- introduced break_nested_index (in addition to break index)
- breakpoint: do not save hidden breakpoint (since most of the time, the when hits action might include many unwanted objects)
- add a debugger observer check point to update debugger data (such as breakpoints, catcall detection .. other)
- added on_application_initialized which is just before it is really launched

- Partial integration of execution recording and replay (a few C macros are disabled for now, for next interim release)

- cosmetics

Revision 72891 - (view) (annotate) - [select for diffs]
Modified Thu Mar 27 21:58:59 2008 UTC (11 years, 6 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 71869 byte(s)
Diff to previous 72874
Fixed bug shown by eweasel test#ccomp075 where because we did not undefine macros that are 
  generated in workbench mode to access the members of a EIF_TYPED_VALUE, we could invalidate
  some C code written by the user if it happens to use the same name. The solution was to simply
  moves the #undef from prior the definition of the macro to the end of the routine.
Changed type of `register_names' to be a SPECIAL which will certainly be more efficient.


Revision 72874 - (view) (annotate) - [select for diffs]
Modified Wed Mar 26 09:29:11 2008 UTC (11 years, 6 months ago) by alexk
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 71041 byte(s)
Diff to previous 72829
Supported object tests in inherited pre- and postconditions. Now they use different byte node from normal locals, because they have to be reindexed at code generation time to take into account current feature context that may have other object test locals that come from other inherited assertions. They have unique position numbers inside one routine body. At code generation time the object test locals are registered just after normal locals.

Revision 72829 - (view) (annotate) - [select for diffs]
Modified Fri Mar 21 21:55:55 2008 UTC (11 years, 6 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 69460 byte(s)
Diff to previous 72749
Fixed `deep_actual_type' so that it does not stop at the first level in generics (this was causing
  eweasel test#final047 to fail).
Removed call to `deep_actual_type' from `process_array_as' in AST_FEATURE_CHECKER_GENERATOR because
  our recent changes to ensure SPECIALs are created with proper type highlighted a bug in eweasel
  test#term143 where a catcall was detected since we used the static solved type of the array.
  Verified that test#term131 is not failing since it was the reason for the call to `deep_actual_type';
  it is not failing because now dead code removal has no impact on the generation of the table
  for anchored creation.
Removed `generate_expanded_creation' and `generate_expanded_initialization' from TYPE_A and descendants
  they were already not used due to a previous commit, but I could not commit TYPE_A due to a conflict change.
Added some missing precondition in `TYPE_A'.
In AST_FEATURE_CHECKER_GENERATOR, added a call to `reset_constraint_error_list' which did not seem to
  cause a failure but for correctness it should always be called.

Fixed some inlining bugs with the various context switches (eweasel test#final042, term#exec283)
  are now successfully passing. One issue was that arguments were not resolved
  when creating the INLINED_FEAT_B node, this ensured that there was no need to call `real_type' and remove
  the risk of being in the wrong contest. Then the getting of registers for inlined arguments, locals and
  result should be done before doing the switch since calling `attachment_type' in the wrong context
  would cause a crash when it has some anchors.

Fixed inlining bug test#final048 where if the inlined routine is present in a descendant but defined in
  a class which does not conform to the current type, we would inline but assuming as context of inlining
  the first descendant defining it, this is bad since some dynamic calls would be replaced with static ones
  and this is wrong, since more than one descendant are present.

Fixed inlining bug test#final047 where printing the current register was not always done in the proper
  context because we did not use INLINED_CURRENT_B in `BYTE_CONTEXT.current_register' but the original
  REGISTRABLE.


Revision 72749 - (view) (annotate) - [select for diffs]
Modified Fri Mar 14 16:57:46 2008 UTC (11 years, 7 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 69364 byte(s)
Diff to previous 72729
Added catcall detection at runtime for melted mode.
Renamed `generate_catcall_check_for_argument' into `generate_catcall_check' since it can be used
  for some other things (e.g. named tuple access).


Revision 72729 - (view) (annotate) - [select for diffs]
Modified Thu Mar 13 17:20:40 2008 UTC (11 years, 7 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 68066 byte(s)
Diff to previous 72698
Minor optimization in final mode when not keeping assertions, we do not `analyze' them anymore.
Enabled the catcall checker on something else than just arguments, and the first use of that is
  the catcall detection on assignment to labels of a named tuple.
Disable the optimization for `like Current' since it would not work if the routine using `like Current'
  performs an attribute assignment.


Revision 72698 - (view) (annotate) - [select for diffs]
Modified Tue Mar 11 21:39:59 2008 UTC (11 years, 7 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 67887 byte(s)
Diff to previous 72684
Fixed issue that using a local variable to store the feature name was generating bigger executables.
  This was due to the fact we declared the C variable with `char name[]' rather than `char *name'
  as in the former case the Microsoft C compiler generates a copy of the string onto the callstack
  where we only meant a reference to the same string object.
  Also optimized to only use the local when the feature name is referenced more than once.
  Note that if you have catcall checking enabled and RTEA, or only catcall checking, we might be using
  the local even if not strictly necessary. this is because we do not know in advance how many catcall
  checks are necessary. However it does not cause any performance penalty in the C generated code because
  C compilers are smart enough to see that they don't need the local.


Revision 72684 - (view) (annotate) - [select for diffs]
Modified Tue Mar 11 05:35:31 2008 UTC (11 years, 7 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 67295 byte(s)
Diff to previous 72665
Improved code generation for catcall detection so that harmless catcalls are not reported. We may
  offer in the future an option to detect them. Reduced size of executable by reusing the same C string
  constants for feature names and avoid using a string constant for the type and use an integer instead.


Revision 72665 - (view) (annotate) - [select for diffs]
Modified Mon Mar 10 06:48:26 2008 UTC (11 years, 7 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 66606 byte(s)
Diff to previous 72664
Quick fix to make code work for .NET by providing a context feature.


Revision 72664 - (view) (annotate) - [select for diffs]
Modified Mon Mar 10 00:41:04 2008 UTC (11 years, 7 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 66384 byte(s)
Diff to previous 72653
Added detection of catcalls at runtime. First implementation only does it for C code
  generation and only prints to the console the potential catcall detection. Next
  version should support melted code and handling in EiffelStudio.


Revision 72653 - (view) (annotate) - [select for diffs]
Modified Fri Mar 7 20:01:18 2008 UTC (11 years, 7 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 65104 byte(s)
Diff to previous 72557
Improved finalized code generation by 2 factor:
- reducing amount of polymorphic calls.
- improving quality of inlined code.
Both are achieved by using the full type information of the target being used for code generation. This
  slows down a bit the caching done in EIFFEL_HISTORY since we cannot cache the information when target
  is generic. Also used a new kind of conformance check in CLASS_TYPE used for polymorphism, since
  we are going to check the conformance between a descendant CLASS_TYPE against an ancestor CL_TYPE_A.
For example: if you have in the universe a generic class A [G] which has A [G#1] and A [INTEGER] as
  generic derivations. Previously the call to `a.f ("STRING")' where `a: A [STRING]' and `f (v: G)'
  would yield a polymorphic call since `A [STRING]' was assimilated to A [G#1] and we need polymorphic
  call if you have a reattachment of A [INTEGER] to a A [ANY]. But with A [STRING] this reattachement
  cannot take place so no need for dynamic binding.
When compiling the compiler, it has a small effect on the speed (of about <2%), on size of generated
  executable (of about 1%).
Added a new feature `{CL_TYPE_A}.find_descendant_type' that returns the type of A [X] would have in a
  descendant C [G] (here C [X]). Usefull for inlining.


Revision 72557 - (view) (annotate) - [select for diffs]
Modified Fri Feb 29 22:15:29 2008 UTC (11 years, 7 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 64450 byte(s)
Diff to previous 72419
Guaranteed that when generating the hooks for the locals, we always start from 0 to the number of
  locals instead of going through the HASH_TABLE order.


Revision 72419 - (view) (annotate) - [select for diffs]
Modified Sat Feb 23 00:45:27 2008 UTC (11 years, 7 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 64508 byte(s)
Diff to previous 72344
Changed SUPPLIER_AS to only create the supplier on demands.

Merged TYPE_I and TYPE_A hierarchies in just TYPE_A one.
1-The major change is that now to compute the associated class type (CLASS_TYPE instance) of a TYPE_A
  one has to provide a context in which the TYPE_A instance appear. If no context is provided, then
  formal generics are not replaced. For example: LIST [G] alone will simply give you the LIST [G]
  CLASS_TYPE, but if you do it in the context of TEST [INTEGER], then it will return the
  LIST [INTEGER] CLASS_TYPE.
2-Updated all callers accordingly.
3-Simplified a few calls where before we did `type.associated_class_type.associated_class' to just
  `type.associated_class'.
4-Added new preconditions to the context provided, it really helped finding out when we were not doing
  things properly especially in code generation when regenerating code from parent into descendant.
5-Eventhough TYPE_I disappeared, I kept TYPE_C and its descendants since they are useful to have
  them for C code generation and quick discimination for TYPE_A instances.
6-Made validity of types better controled by checking more things in `{TYPE_A}.is_valid'. For example
  that if type used to represent a class which was expanded and that it is not expanded anymore, then
  the type is not valid anymore.
7-The most problematic change with TYPE_I/TYPE_A was that they had different notion of `is_external'
  we have added `is_true_external' to simplify the code in certain areas where the old TYPE_I semantic
  was needed.

Code generation change:
1-We now assume that the default context is always `{BYTE_CONTEXT}.context_class_type'. Then in
  `real_type' and `creation_type' we use `{TYPE_A}.evaluated_type_in_descendant' to properly evaluate
  a type from the ancestor code in the current context. Very useful for regeneration of inherited
  assertions and replicated features. Before it worked, but it was not clear how to do things properly,
  now it is clear.
2-Changed the way we generate the type information for like arguments: we simply nest calls to resolve
  the type of the arguments. This affects the interpreter and C code generation which includes a level
  ID for computing the type of generics.

C Code generation change:
1-Because debugging was too difficult at some point during that work and also because the name mapping
  we were using limited us to 32767 types and 131071 routines, I've changed the mechanism to not use
  the `encode.c' modules in C/bench and did everything in Eiffel. So now we simply write for a feature
  name FXXX_YYY where XXX is the type ID and YYY the body index. The same kind of changes have been
  done for other names (See ENCODER class for details.).
2-We also use `type_id' instead of `static_type_id' for names. The reason it is safe to do so is because
  `type_id' never changes in workbench mode and that in finalized mode, even if you have different
  incremental recompilation, 2 projects should generate more or less the same code at the ID levels
  making it easier to compare them.
3-Changed the way type are created. Instead of having a CREATE_INFO instance in the TYPE_I objects
  used to properly generate the type, we simply use the original TYPE_A instance. That way when we
  have an anchor, we either generate its `actual_type' or its anchor spec depending on the value of
  `use_info. We still use CREATE_INFO to generate the type information but instead of being an object
  in each TYPE_I, it is merely a once that we reinitialize each time we need it.
4-ONE CRITICAL ASPECT OF THE CHANGE #3 was that storable depends on the way type descriptions are generated
  and thanks to eweasel test#storable013 I was able to catch this much earlier in the process.
5-Generates less polymorphic tables for attributes and types specification. What happened before was
  that when we needed a polymorphic type specification for example to create `like x' where x is covariantly
  redefined, we were generating at the same time the polymorphic table for `x' even though if `x'
  was not actually used in the system. This reduces by a tiny amount only the size of the executable.
6-Made the DESCRIPTOR entries much smaller than they used to be by computing the number of ancestors
  instead of allocating for the numbers of routines which was really silly.

IL code generation change:
1-Provided a implementation for creation of BIT constants in .NET however it does not completely work yet,
  it has to do with the manner we generate the BIT_REF class.
2-Changed the way we compare signatures, we store a CLASS_TYPE and a routine ID instead. And then when
  needed we refetch the FEATURE_I object to perform the signature comparions. The issue is that the previous
  solution would not work if NATIVE_ARRAY and TYPED_POINTER do not record all the possible genereric
  derivations in which they are present which is now the case for simplicity.
3-Fixed a bug in code generation for a TYPE_FEATURE_I that is instantiated as a basic type. We would
  generate its associated reference type instead of the basic type. It was not caught before because those
  routines where never called at runtime unless you had a formal generic parameter creation constraint.
4-Fixed an inconsistency shown by eweasel test#incr168 where a precondition check was generated eventhough
  none was needed because one inherited routine had a True precondition. The C code was doing it ok, but
  not .NET
5-Found out see eweasel test#final041 that we first generate inherited assertion and then precondition,
  which is the contrary of what is done in melted or C code generation.
6-Simplified creation of manifest ARRAYS and TUPLE by avoiding a local variable.


Debugger:
1-Updated the code accordingly to the TYPE_I/TYPE_A merge
2-Fixed bug in {DBG_EVALUATOR}.prepare_parameters so that we do not use BYTE_CONTEXT to resolve
  the type but `instantiation_in' instead. It seems to solve one case that the previous debugger did
  not handle (See updated comment).
3-Fixed precondition violation in
  {AST_DEBUGGER_EXPRESSION_CHECKER_GENERATOR}.expression_or_instruction_type_check_and_code where
  we were still trying to evaluate in the descendant if the parent evaluation failed. Causing some
  precondition violations since the AST was not completely annotated with IDs needed for resolution.

Bug fixes:
1-Fixed issue with the way we maintained {CLASS_C}.generic_features, because you could rebuild the list
  without recompiling descendants (case of modifying only a contract of the class) and the rebuilding
  would yield new routine IDs. Then during either type checking or code generation the evaluation of 
  `{TYPE_A}.evaluate_type_in_descendant' could fail because it is not find the new routine ID in the
  descendant class. Now we preserve the routine ID as long as we can, same with feature ID.
2-Made `feature_of_rout_id' works to find the invariant feature.
3-Made sure that when removing an ID from a server it is also removed from the TMP server. Added
  a `not_present' postcondition after calling `remove' to ensure that.


Revision 72344 - (view) (annotate) - [select for diffs]
Modified Mon Feb 18 21:31:23 2008 UTC (11 years, 7 months ago) by alexk
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 64272 byte(s)
Diff to previous 72085
Temporary disabled precondition to allow for bootstrap with assertions (test#final041 demonstrates the issue even without assertions).

Revision 72085 - (view) (annotate) - [select for diffs]
Modified Mon Jan 28 23:36:24 2008 UTC (11 years, 8 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 64065 byte(s)
Diff to previous 71841
Removed `current_used_count' from BYTE_CONTEXT since we were not using it.
Removed `constraint_position' from MULTI_FORMALI_I since not used and updated callers of `make' in BYTE_CONTEXT.


Revision 71841 - (view) (annotate) - [select for diffs]
Modified Thu Jan 10 20:06:55 2008 UTC (11 years, 9 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 64271 byte(s)
Diff to previous 71783
Slightly improved GENERATION_BUFFER so that we only put indentation when inserting a newline character.
  As a consequence when you need to generate a new statement which is supposed to be on a new line you
  have to call {GENERATION_BUFFER}.put_new_line first. This changes the code generation slightly where
  before you always add to have a call to `put_new_line' at then end of your statement. This simplifies
  the contracts as there is no need for an `emitted' query.
Merged STRING_CONVERTER into GENERATION_BUFFER and optimized call to `putoctal'.
Added new `put_natural_xx' routines in GENERATION_BUFFER to avoid creating a string when emitting a
  natural constant.
Added `put_gtcx' in GENERATION_BUFFER to avoid generating the GTCX macro when not necessary.
Improved formatting of if, elseif, elseif statement where elseif clauses were not properly indented.


Revision 71783 - (view) (annotate) - [select for diffs]
Modified Sat Jan 5 21:53:09 2008 UTC (11 years, 9 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 64464 byte(s)
Diff to previous 70918
Improved performance of generated code with regard to dynamic binding. Currently we were using the
  full dynamic type, but since tables are indexed with the dynamic type instead, it requires an
  indirection to get the dtype from the dftype. This indirection costs about 4% on the compiler
  speed and 2% in executable size. The solution was to store both dftype and dtype in the object
  header. On 64-bit, the header is keeping its size, on 32-bit it goes from 8 bytes to 12 bytes.
  That is to say on 32-bit, when you had 8MB of memory used for headers, it is now using 12MB,
  and usually this corresponds to 70MB of data (for the compiler at least).

Consequence:
- dynamic types have a type definition EIF_TYPE_INDEX
- dynamic types are limited to 65000+ (before it was 32000+)
- updated runtime to use EIF_TYPE_INDEX wherever a dtype/dftype is used. Some places were using
  a int or long and this was abused (e.g. debugger encoding 2 dtypes on one int).

Other work:
- fixed most C warnings generated by the VS 2005 C++ comiler
- fixed some issues with equal/copy (use of dtype instead of dftype and comparison of expanded objects
  which should query the size in EIF_Size and not in the object header, since expanded on the stack
  have no size).
- fixed eweasel test#melt064.
- fixed eweasel test#exec255 which eventhough was passing, was not when enabling runtime assertions.
- fixed some issues with storables with respect to storable of special of expanded
- fixed issue with retrieval of special of expanded (see eweasel test#store013).
- simplified `st_write_func' to not take the flags since it is not needed for storing.

What's not perfect:
- There is a mix of usage of int, uint32 and int16 in the interpreter and in store/retrieve for representing
  types. It would be nice to make this more consistent and to use EIF_TYPE_INDEX instead.


Revision 70918 - (view) (annotate) - [select for diffs]
Modified Fri Oct 26 19:18:22 2007 UTC (11 years, 11 months ago) by king
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 64355 byte(s)
Diff to previous 69857
Temporarily commented out conformance precondition for byte code generation which no longer holds true with respect to non-conforming inheritance.  We reinstate when a is_ancestor or is_parent routine is added.

Revision 69857 - (view) (annotate) - [select for diffs]
Modified Fri Aug 3 09:10:11 2007 UTC (12 years, 2 months ago) by alexk
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 64291 byte(s)
Diff to previous 68852
Unified run-time data structures. Now EIF_TYPED_VALUE is used by the
interpreter, tuples/agents and in workbench C code to pass arguments and
result. The new structure EIF_TYPED_ADDRESS is used to register C variables
for the debugger. The new structure EIF_DEBUG_VALUE is used to access and
modify a value either on interpreted stack or on C stack.


Revision 68852 - (view) (annotate) - [select for diffs]
Modified Mon Jun 4 18:15:15 2007 UTC (12 years, 4 months ago) by martins
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 64285 byte(s)
Diff to previous 68650
Fixed bug#12818 (assigner command).
Added more support for alias features.
vwbr.e: Extended the error class to be able to support multi constraint error messages (switcht from CLACC_C to TYPE_A)
formal_a.e: Removed obsolete feature `has_multi_constraints'
gen_type_a.e: Cosmetics
renaming_a.e: Enabled storage of alias names. Detection of Infix/Prefix is not implemented (see bug#12817). 
type_set_a.e: Changed code related to alias names and added some more contracts.
formal_constraint_as.e: Creation of renaming with alias names
ast_feature_checker_generator.e: Fixed bug#12818 (assigner command) and fixed a bug for infix features.
byte_context.e: Fixed bug#12784 reproduced by test#multicon041.
constraining_type_as.e: refactored code into query
ast_formal_generics_pass2.e: In case of enabled assertions there are cases where the checks fail.


Revision 68650 - (view) (annotate) - [select for diffs]
Modified Thu May 24 22:20:37 2007 UTC (12 years, 4 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 64279 byte(s)
Diff to previous 68627
Removed non-used local.


Revision 68627 - (view) (annotate) - [select for diffs]
Modified Wed May 23 23:31:00 2007 UTC (12 years, 4 months ago) by martins
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 64359 byte(s)
Diff to previous 68440
* Clean-Up
* Switched from VTGD back to VTCG which yields in proper error location in more cases.
* il_node_generator.e: fixed a bug by protecting a call on void target

Revision 68440 - (view) (annotate) - [select for diffs]
Modified Fri May 18 17:01:58 2007 UTC (12 years, 5 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 65728 byte(s)
Diff to previous 68424
Fixed warnings by using the SK_XXX values rather than their string representation because
  the `type' field of EIF_UNION expects a uint32 and the values are sometime negatives (e.g. SK_REF).
Improved performance by making `register_sk_values' a once function.


Revision 68424 - (view) (annotate) - [select for diffs]
Modified Fri May 18 12:05:27 2007 UTC (12 years, 5 months ago) by alexk
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 65984 byte(s)
Diff to previous 68301
Ensured required wrappers are generated for features that result from merging with those that have formal generics in the signature and may be referenced from polymorphic table using formal-generic-aware name (this fixes an unresolved symbol errors in finalized GUI version of EiffelStudio, es_cleaner, etc.).

Revision 68301 - (view) (annotate) - [select for diffs]
Modified Mon May 14 21:58:53 2007 UTC (12 years, 5 months ago) by alexk
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 64977 byte(s)
Diff to previous 68280
Avoided marking registers as volatile if they are compaund as otherwise C compiler reports incompatible types.

Revision 68280 - (view) (annotate) - [select for diffs]
Modified Sun May 13 18:06:54 2007 UTC (12 years, 5 months ago) by alexk
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 64953 byte(s)
Diff to previous 68030
Supported reattachment of objects of types that are generic derivations
with expanded parameters to entities of types that are suitable generic
derivations with reference parameters.



Revision 68030 - (view) (annotate) - [select for diffs]
Modified Mon Apr 30 18:38:45 2007 UTC (12 years, 5 months ago) by martins
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 59596 byte(s)
Diff to previous 67957
Main change: I merged many occurences of "constrained_type" like features into `FORMAL_A'
Renamed `is_multi_constrained_formal' into `is_multi_constrained'
type_a.e: I moved some features into FORMAL_A because the usage pattern suggests that they are not needed in TYPE_A (to improve speed).
renamed_type_a.e: added implementation for `conformance_type', this was a bug (not reported)
formal_dec_as.e: fixed a bug in `is_multi_constrained' (not reported)

Revision 67957 - (view) (annotate) - [select for diffs]
Modified Mon Apr 23 21:58:30 2007 UTC (12 years, 5 months ago) by martins
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 59652 byte(s)
Diff to previous 67948
* mostly removed my TODOs
* removed wrong usage of `{CLASS_C}.constraint' from ast_breakable_slot_startegy.e
* refactored constraint_fixed back into constraint
* degree_4.e: removed check as assumptions seemed to be correct


Revision 67948 - (view) (annotate) - [select for diffs]
Modified Sat Apr 21 00:50:00 2007 UTC (12 years, 5 months ago) by martins
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 59658 byte(s)
Diff to previous 67227
formal_a.e: Added feature to check whether a formals constraint has a renaming or not. This is a necessary adaptation to handle single constraints which have a renaming correctly.
gen_type_a.e: provide location information.
renamed_type_a.e: Fixed bug in is_equivalent
renaming_a.e: Added a feature to map old names onto their new names.
type_a.e: added feature allows to check for certain conditions without a reverse assignment to formal_a.e
formal_constraint_as.e: removed too strong error handling (eweasel tests failed because of this, that's why it is removed)
ast_feature_checker_generator.e: Bug fix for bug#12503 and bug#12504
formal_constraint_as.e: Added a feature to support changes in formal.a and fixed a plain wrong feature.
named_tuple_type_as.e: fixed a bug which printed one comma too much in the `dump' feature



Revision 67227 - (view) (annotate) - [select for diffs]
Modified Tue Mar 13 01:32:16 2007 UTC (12 years, 7 months ago) by martins
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 59638 byte(s)
Diff to previous 66895
Support for multi constraint generics:
- Central new class is TYPE_SET_A: It provides features for type checking and feature lookup.
  (the TYPE_A interface is not perfectly complete until now)
- Added EXTENDED_TYPE_A: It basically encapsulates a type and a feature renaming.
- Changed parser to accept the new syntax.
- Adapted validity checks for generics to reflect the new rules.
- Changed AST_FEATURE_CHECKER_GENERATOR in particular `process_call' and its siblings
  to select the so called `multi_constrained_static'. This is the actual static type
  of the target. It is done for each access on a multi constraint generic.
- Added error classes VTGC*, VTGD* and VTMC*.
- Changed code which called `constrained_type' feature to make it capable
  of handling multi constraints. This is in most cases achieved through handling these cases
  explicitly: Autocompletion, query language and debugger are not yet adapted and don't work
  properly in the presence of multi constraint formals.
- Changed AST_DECORATED_OUTPUT_STRATEGY and the like to pretty print the multi constraints correctly.

Support for recursive formals:
- I added a second pass AST_FORMAL_GENERICS_PASS2 which handles the registration of suppliers
  and transformation of the types into the right class (formal or class type).

The rest of the changes are targeted to either one of these.


Revision 66895 - (view) (annotate) - [select for diffs]
Modified Sun Feb 25 17:11:57 2007 UTC (12 years, 7 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 56099 byte(s)
Diff to previous 65068
Support for FreeELKS:
- Added byte code for `floor' and `ceiling' operation on real types.
- Made `c_tagged_out' take an EIF_REFERENCE rather than an EIF_OBJECT, updated
  all C code using it accordingly and ANY/ISE_RUNTIME.
- Added `eif_built_in.h' to keep all macros used for external "built_in' features
  not implemented with Eiffel code.
- Added BUILT_IN_AS node for representing external "built_in' features:
  * when a built_in routine is found, we look in $ISE_EIFFEL/studio/built_ins to
    see if it has a corresponding implementation and the FEATURE_I/STD_BYTE_CODE
	is generated from the implementation. Otherwise we consider it as a special
	C routines.
  * In the formatters, we show the actual code of the implementation and not the
    external body, the same for debugging.
- Partial fix for Precursor call when call is made in an expanded class, the ancestor
  version might have non-expanded arguments and return type (e.g. like Current).
- Changed CLASS_TYPE for basic types so that `type_i' is a CL_TYPE_I and not
  a BASIC_I. It solves issues when you have code defined in basic types which
  would not be properly generated. Since it would be generated as if it was a
  normal expanded type but the types where still EIF_XXX instead of EIF_REFERENCE.
  This was needed for FreeELKS since now we have implementation in the basic types.
  Added some queries to CLASS_TYPE to avoid accessing `type' to get the information
  since sometime we still want to know that we are in basic types. Added `basic_type'
  to be used when it is a basic type. It has mostly an implication with .NET code
  generation.
- Updated debugger so that one can debug all features but attributes, deferred and
  constants.


Revision 65068 - (view) (annotate) - [select for diffs]
Modified Wed Nov 15 13:11:16 2006 UTC (12 years, 11 months ago) by alexk
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 56107 byte(s)
Diff to previous 64911
Changed processing for formal generics to traverse their constraints recursively to cover the case when a formal generic is constrained to another formal generic (this fixes bug#11634, test#term145).

Revision 64911 - (view) (annotate) - [select for diffs]
Modified Thu Nov 9 00:36:43 2006 UTC (12 years, 11 months ago) by konradm
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 56084 byte(s)
Diff to previous 64654
- Added compiler support for supplier preconditions.
- In finalized code the dynamic type is now used to detect whether assertions need to be checked.
- Implemented invariant checking in finalized code.
- Changed ecf files of libraries to not have any assertion checking.

Revision 64654 - (view) (annotate) - [select for diffs]
Modified Mon Oct 30 17:55:48 2006 UTC (12 years, 11 months ago) by patrickr
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 56096 byte(s)
Diff to previous 63011
changed ASSERTION_I to inherit from CONF_ASSERTIONS and always use the factory to create a CONF_ASSERTIONS object so that in the compiler we will get a ASSERTION_I object instead, eliminates creating a ASSERTION_I object in CLASS_I
fixed a bug in the CONF_PRINT_VISITOR that did not print relative external paths correct
removed CLASS_I.name_in_upper as name is never void in the new config system
fixed external_name if there is a renaming specified in the visible clause

Revision 63011 - (view) (annotate) - [select for diffs]
Modified Mon Aug 28 15:09:28 2006 UTC (13 years, 1 month ago) by alexk
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 56090 byte(s)
Diff to previous 62677
Taken into account a possibility of object creation as a result of a reattachment.

Revision 62677 - (view) (annotate) - [select for diffs]
Modified Thu Aug 17 16:34:13 2006 UTC (13 years, 2 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 55921 byte(s)
Diff to previous 62658
Reverted back to former revision because `creation_type' would not do the right thing if `type'
  is just a FORMAL_I. We could do a special case now, but perfer to wait after the release
  to do further changes. This fixes eweasel test#exec252.


Revision 62658 - (view) (annotate) - [select for diffs]
Modified Thu Aug 17 12:25:19 2006 UTC (13 years, 2 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 55724 byte(s)
Diff to previous 62651
Made `creation_type' a synonym of `real_type' since it enables a better type 
  description for descendant classes.


Revision 62651 - (view) (annotate) - [select for diffs]
Modified Thu Aug 17 09:09:12 2006 UTC (13 years, 2 months ago) by alexk
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 55918 byte(s)
Diff to previous 61575
Moved feature that generates code for calculating object type from BYTE_NODE to BYTE_CONTEXT so that it can be used outside of byte node classes.

Revision 61575 - (view) (annotate) - [select for diffs]
Modified Mon Jul 24 12:51:08 2006 UTC (13 years, 2 months ago) by alexk
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 54118 byte(s)
Diff to previous 59296
Introduced a new feature to get a reference variant of a given expanded type to avoid creating BASIC_I instances for reference variants of basic types.

Revision 59296 - (view) (annotate) - [select for diffs]
Modified Wed May 31 15:12:50 2006 UTC (13 years, 4 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 54139 byte(s)
Diff to previous 59236
Added removal of all items in `generated_inlines' in `clear_class_type_data' as otherwise
  from within an EiffelStudio session, the first time you introduce an inline it gets generated,
  but if you modify the content of the inline then it does not get generated because we still
  remembered it from the first generation.
  It could also happen if the inline has to be generated in more than one C file, but because
  it is almost impossible to reproduce there is no eweasel test for that bug.


Revision 59236 - (view) (annotate) - [select for diffs]
Modified Fri May 26 18:52:51 2006 UTC (13 years, 4 months ago) by konradm
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 54054 byte(s)
Diff to previous 58325
- For external inline routines, an inline C function is generated. This solves the problem, with false semantic behaviour
in case of a C return statement. 
- For external inline functions, it is now possible to have several C code statements. For backward compatibility, if there is no C return statement, one is added.


Revision 58325 - (view) (annotate) - [select for diffs]
Modified Thu Apr 20 16:05:16 2006 UTC (13 years, 5 months ago) by manus
Original Path: trunk/Src/Eiffel/eiffel/byte_code/byte_context.e
File length: 53877 byte(s)
Diff to previous 58156
Moved trunk/Src/bench/Eiffel to trunk/Src/Eiffel.

Revision 58156 - (view) (annotate) - [select for diffs]
Modified Tue Apr 11 13:21:33 2006 UTC (13 years, 6 months ago) by alexk
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 53877 byte(s)
Diff to previous 58027
Ensured that a class type is marked as having expanded descendants if the class type has an expanded counterpart as well.

Revision 58027 - (view) (annotate) - [select for diffs]
Modified Wed Apr 5 07:08:57 2006 UTC (13 years, 6 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 53687 byte(s)
Diff to previous 57906
Fixed mixing paranthesis in indexing clause for the licensing.
Added missing license reference in newly created Eiffel classes.


Revision 57906 - (view) (annotate) - [select for diffs]
Modified Thu Mar 30 11:41:04 2006 UTC (13 years, 6 months ago) by alexk
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 53677 byte(s)
Diff to previous 57235
Added evaluation of body index for {ANY}.twin.
Added features to compute whether a class type has descendants that are
expanded.


Revision 57235 - (view) (annotate) - [select for diffs]
Modified Thu Mar 2 07:35:54 2006 UTC (13 years, 7 months ago) by alexk
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 51640 byte(s)
Diff to previous 56797
Extended precondition of `change_class_type_context' to ensure that it is called on a previously initialized context.

Revision 56797 - (view) (annotate) - [select for diffs]
Modified Mon Jan 30 12:46:17 2006 UTC (13 years, 8 months ago) by alexk
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 51430 byte(s)
Diff to previous 56709
Marked places for potential optimization of context type evaluation.
Remembered body index of a `copy' routine for use during code generation.


Revision 56709 - (view) (annotate) - [select for diffs]
Modified Wed Jan 25 10:59:43 2006 UTC (13 years, 8 months ago) by alexk
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 50748 byte(s)
Diff to previous 56581
Optimized "real_type" to avoid instantiating types in simple cases.
Added a query to indicate whether code generation is performed in the
context where the code was originally written.


Revision 56581 - (view) (annotate) - [select for diffs]
Modified Wed Jan 18 14:16:18 2006 UTC (13 years, 8 months ago) by alexk
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 50249 byte(s)
Diff to previous 56545
Removed trailing blanks.

Revision 56545 - (view) (annotate) - [select for diffs]
Modified Tue Jan 17 12:27:20 2006 UTC (13 years, 8 months ago) by alexk
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 50258 byte(s)
Diff to previous 56535
Extended notion of current class type to be more precise during type
evaluation:
	original_class_type - denotes an original class type for which the
	                      code is generated
        context_class_type  - denotes a current class type for which the
                              code is being generated (this type is changed
                              when inlining is performed)
	class_type          - a class type where the code to be generated
	                      is written
Simplified modification of a context class type required for inlining by
introducing a stack-like operations on it.
Added functions to evaluate types in the given context without the need to
change the state of the generation context.


Revision 56535 - (view) (annotate) - [select for diffs]
Modified Tue Jan 17 01:37:10 2006 UTC (13 years, 9 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 46672 byte(s)
Diff to previous 56433
Added text of the GPL license to all classes of the compiler.


Revision 56433 - (view) (annotate) - [select for diffs]
Modified Fri Dec 30 15:00:13 2005 UTC (13 years, 9 months ago) by alexk
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 45258 byte(s)
Diff to previous 56009
Inlined a single-line feature that is not used anywhere else.

Revision 56009 - (view) (annotate) - [select for diffs]
Modified Mon Dec 5 16:25:04 2005 UTC (13 years, 10 months ago) by alexk
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 45449 byte(s)
Diff to previous 55782
Performed type instantiation unconditionally because this is required if type 'like Current' is promoted to code generation stage.

Revision 55782 - (view) (annotate) - [select for diffs]
Modified Fri Nov 18 00:23:34 2005 UTC (13 years, 10 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 45516 byte(s)
Diff to previous 55704
Removed `old_expressions' since it is not used anymore.


Revision 55704 - (view) (annotate) - [select for diffs]
Modified Fri Nov 11 18:54:28 2005 UTC (13 years, 11 months ago) by alexk
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 45823 byte(s)
Diff to previous 53194
Removed check whether a type has formal before calling "instantiation_in"
because the latter will also be used for calculating "like Current" type.


Revision 53194 - (view) (annotate) - [select for diffs]
Modified Fri Jul 8 14:13:29 2005 UTC (14 years, 3 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 45910 byte(s)
Diff to previous 52816
Removed `generate_temporary_nonref_variables' from BYTE_CONTEXT since not actually
  used because what would trigger its usage (i.e. non_gc_tmp_vars was never
  set).
Reviewed generation of EIF_VOLATILE to all variables (even the reference one
  for both real locals and temporary locals). This fix a bug with C compiler
  which could optimize local access if you don't use `volatile'.
  Also now EIF_VOLATILE appear after the type declaration all the time.


Revision 52816 - (view) (annotate) - [select for diffs]
Modified Thu Jun 30 09:00:33 2005 UTC (14 years, 3 months ago) by alexk
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 47293 byte(s)
Diff to previous 50352
Overcome a C parser limitation to handle long single-string literals for once
string manifest constants.


Revision 50352 - (view) (annotate) - [select for diffs]
Modified Fri Apr 22 16:54:18 2005 UTC (14 years, 5 months ago) by alexk
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 47350 byte(s)
Diff to previous 50079
Supported generation of new macros for fast access to successfully completed
once features of different kind (single-thread, thread-relative, process-relative).
Provided a unified way to determine whether fast-access macros for once
features can be used.


Revision 50079 - (view) (annotate) - [select for diffs]
Modified Sun Apr 17 15:27:23 2005 UTC (14 years, 6 months ago) by alexk
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 45697 byte(s)
Diff to previous 49446
Supported process-relative once routines in workbench mode.
Changed semantics of once routines to share the same data across different
generic derivations of the same generic class.


Revision 49446 - (view) (annotate) - [select for diffs]
Modified Thu Mar 24 07:11:22 2005 UTC (14 years, 6 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 40424 byte(s)
Diff to previous 48958
Use new syntax for static calls.


Revision 48958 - (view) (annotate) - [select for diffs]
Modified Sat Mar 5 09:02:16 2005 UTC (14 years, 7 months ago) by alexk
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 40432 byte(s)
Diff to previous 47838
Added a flag that indicates whether a once routine should be generated
in two C functions to avoid performance penalty caused by generation of
not very efficient object code when function has exception processing.
Changed code generation for once routines to take exceptions into account.


Revision 47838 - (view) (annotate) - [select for diffs]
Modified Tue Jan 25 02:26:51 2005 UTC (14 years, 8 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 39745 byte(s)
Diff to previous 47234
Added NATURAL_XX types support.


Revision 47234 - (view) (annotate) - [select for diffs]
Modified Sat Dec 25 00:19:09 2004 UTC (14 years, 9 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 39380 byte(s)
Diff to previous 45884
Provided new class names, new feature names to entities representing
  basic types so that they are close to the new basic type names:
    real -> real_32
	double -> double_32
	float -> real_32
	long -> integer
	....


Revision 45884 - (view) (annotate) - [select for diffs]
Modified Fri Oct 1 17:43:37 2004 UTC (15 years ago) by alexk
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 39369 byte(s)
Diff to previous 45853
Moved byte code generation to allocate memory for once manifest strings to
BYTE_CONTEXT.
Added a check to avoid initializing once manifest strings that come from
assertions when assertions are not generated.


Revision 45853 - (view) (annotate) - [select for diffs]
Modified Mon Sep 27 12:07:02 2004 UTC (15 years ago) by alexk
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 38800 byte(s)
Diff to previous 45716
Optimized the case when strings are pre-allocated, i.e. do not allocate memory when used.
Supplied compile-time hash code for once manifest strings.
Avoided using temporary register for pre-allocated strings.


Revision 45716 - (view) (annotate) - [select for diffs]
Modified Fri Sep 17 14:06:25 2004 UTC (15 years, 1 month ago) by alexk
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 40587 byte(s)
Diff to previous 45583
Moved features related to once string code generation to BYTE_CONTEXT.
Optimized code for once manifest strings in single-threaded finalized mode.
Renamed feature "clear_all" to "clear_feature_data".
Introduced features "clear_class_type_data" and "clear_system_data"
to clear data related to generated class type and to whole system.


Revision 45583 - (view) (annotate) - [select for diffs]
Modified Mon Sep 13 14:30:49 2004 UTC (15 years, 1 month ago) by alexk
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 31221 byte(s)
Diff to previous 43817
Supported once manifest strings.


Revision 43817 - (view) (annotate) - [select for diffs]
Modified Tue Jun 15 17:54:08 2004 UTC (15 years, 4 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 30703 byte(s)
Diff to previous 43084
Made sure that `current_type' always corresponds to `class_type.type'. It implies
  that one cannot use `set_current_type' (which has now been removed), but rather
  use `set_class_type' that preserves this invariant.
Updated code using `instantiation_in' from TYPE_I since now the parameter has
  to be a CLASS_TYPE and not a GEN_TYPE_I.


Revision 43084 - (view) (annotate) - [select for diffs]
Modified Tue May 18 04:14:09 2004 UTC (15 years, 5 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 30873 byte(s)
Diff to previous 42958
Used two words names instead of just one for `put_xx', `read_xx' and `last_xxx' routines.
Used specific `put_xxx_id' routines to generate runtime IDs. This removes those
  very annoying `- 1' in the code because the runtime and the compiler are not
  indexed the same way.


Revision 42958 - (view) (annotate) - [select for diffs]
Modified Tue May 11 18:13:18 2004 UTC (15 years, 5 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 30690 byte(s)
Diff to previous 41790
Removed use and computation of `exp_args' and strange way of generating
  argument cloning of expanded variable as it does not make sense because
  at the end what we clone is exactly what was passed as argument, and what
  was registered through RTLR is what was passed. So looking up the offset
  to the parent and then go back to ourself does not make much sense.
Removed `process_expanded' and merged what it was doing into `analyze_arguments'.
Updated `analyze_arguments' and `generate_expanded_cloning' and put a note where
  we could avoid the cloning if the expanded argument is not used in the body
  of the routine only if the associated expanded class does not redefine `copy'.
Moved `local_var' and `arg_var' from BYTE_CONTEXT to STD_BYTE_CODE as they are
  only used in STD_BYTE_CODE.


Revision 41790 - (view) (annotate) - [select for diffs]
Modified Sat Mar 6 00:36:10 2004 UTC (15 years, 7 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 32635 byte(s)
Diff to previous 41327
Use `complete_instantiation_in' instead of `creation_instantiation_in' since the later
does not exist anymore and has been replaced by `complete_instantiation_in'.


Revision 41327 - (view) (annotate) - [select for diffs]
Modified Wed Feb 11 21:48:38 2004 UTC (15 years, 8 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 32635 byte(s)
Diff to previous 40970
Correct implementation of global once in multithreaded mode for procedure.
Improved code generation so that we do not need a global once mutex to compute
  global onces, instead a mutex is assigned to each once and only used when
  once has not yet been computed, resulting in much better performance in
  case of contention on global onces.
MEMORY_LEAK: mutexes are created during runtime initialization, but they are
  never freed.


Revision 40970 - (view) (annotate) - [select for diffs]
Modified Mon Jan 12 00:26:24 2004 UTC (15 years, 9 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 32233 byte(s)
Diff to previous 40739
Removed former SCOOP implementation as it is now obsolete and if any new
implementation there is (through ETH) most likely it will be completely
different from the previous one.
We only keep `separate' at the type checking level, but not for code generation.


Revision 40739 - (view) (annotate) - [select for diffs]
Modified Thu Dec 11 20:00:46 2003 UTC (15 years, 10 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 33929 byte(s)
Diff to previous 39542
Use `twin' instead of `clone' which is now made obsolete.


Revision 39542 - (view) (annotate) - [select for diffs]
Modified Fri Oct 10 23:36:57 2003 UTC (16 years ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 33902 byte(s)
Diff to previous 39143
Renamed local variable `assign' into `l_assign' as this might be a new keyword
in future releases of Eiffel.


Revision 39143 - (view) (annotate) - [select for diffs]
Modified Fri Sep 19 02:15:29 2003 UTC (16 years ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 33884 byte(s)
Diff to previous 38876
Fixed check statement that did not take into account case of where Current
is a basic type.


Revision 38876 - (view) (annotate) - [select for diffs]
Modified Thu Sep 4 04:41:26 2003 UTC (16 years, 1 month ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 33857 byte(s)
Diff to previous 37665
No need for PROTECT_B anymore as it was causing eweasel test `exec167' to fail.
This failed because the protection was done prior the call to the encapsulation
and the assertions usually did not use the protected reference but the unprotected
one which did not exist.

Instead now, we generate the call normally and let the inside of the encapsulation
take care of the protection. Therefore when such a protection is needed we
always call the encapsulation, it is less efficient but not that much.

Moreover we now handle well expanded types when part of arguments of an
external.


Revision 37665 - (view) (annotate) - [select for diffs]
Modified Tue Jun 10 23:50:26 2003 UTC (16 years, 4 months ago) by julieng
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 33562 byte(s)
Diff to previous 37334
Replace !! with create keyword.


Revision 37334 - (view) (annotate) - [select for diffs]
Modified Wed May 21 21:12:30 2003 UTC (16 years, 4 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 33534 byte(s)
Diff to previous 37284
Instead of passing an object to generic conformance routines RTFCID and RTCID
 we now pass the full dynamic type. In order not to make transition easy
 (ie bootstrap) we renamed them into RTFCID2 and RTCID2. Once bootstrap is done
 we will rename them back to RTFCID.


Revision 37284 - (view) (annotate) - [select for diffs]
Modified Fri May 16 16:32:53 2003 UTC (16 years, 5 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 32175 byte(s)
Diff to previous 34930
Enabled optimizations even in multithreaded mode as they are safe, because
  our GC should make sure that all other threads are stopped at GC safe point
  before starting a collection and moving objects around.


Revision 34930 - (view) (annotate) - [select for diffs]
Modified Sat Nov 30 02:39:27 2002 UTC (16 years, 10 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 32207 byte(s)
Diff to previous 34559
Renamed argument `has_pre_post' into `has_assertions_checking_enabled' as
  it cannot optimize features which also performs invariant checking.


Revision 34559 - (view) (annotate) - [select for diffs]
Modified Wed Oct 2 02:40:32 2002 UTC (17 years ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 32150 byte(s)
Diff to previous 32350
Fixed a bug because we were not generating in final mode the hooks for the
following piece of code:

	new_variable (g: STRING): ANY is
		do
			Result := create {STRING}.make_from_string (g)
		end

and therefore just after the object was created the reference to `g' could
be completely incorrect.


Revision 32350 - (view) (annotate) - [select for diffs]
Modified Mon Jun 3 23:28:57 2002 UTC (17 years, 4 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 31938 byte(s)
Diff to previous 32324
Better optmization when we handle a reverse assignment: we do not optimize
when there is a call.


Revision 32324 - (view) (annotate) - [select for diffs]
Modified Sat Jun 1 02:08:56 2002 UTC (17 years, 4 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 31945 byte(s)
Diff to previous 31682
Fixed an old bug where when we do a reverse assignment we need some GC
protection because in the following statement:
	Result ?= f (x)
we generate
	Result = f (Current, x)
	RTRV (ComputationOfTypeOfResult, Result);
and `ComputationOfTypeOfResult' might refer to Current which was not protected
by a GC hook and `f' might have performed some memory allocation so `Current'
might not be valid after call to `f'.


Revision 31682 - (view) (annotate) - [select for diffs]
Modified Sun Apr 21 01:38:06 2002 UTC (17 years, 5 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 31706 byte(s)
Diff to previous 30294
Better code generation for feature with only one line of code. We avoid generation
of hooks when this is a single instruction call that is `is_single' (we were using
CALL_B and not INSTR_CALL_B before so no single instruction call were optimized)
and when there is an assignment `target := source' where `source' is `is_single' call
or an expression that does not generate any memory nor contain any function calls.
Improving this part we can improve a lot our performance by reducing calls to GC
and it also reduces the generated executable size since we will generate less code.

In the future we have to do it also for features that have more than one instruction.


Revision 30294 - (view) (annotate) - [select for diffs]
Modified Mon Jan 21 02:27:01 2002 UTC (17 years, 8 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 31549 byte(s)
Diff to previous 29971
Now use HASH_TABLE as it offers the same functionality as EXTEND_TABLE did.


Revision 29971 - (view) (annotate) - [select for diffs]
Modified Fri Dec 28 02:20:49 2001 UTC (17 years, 9 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 31553 byte(s)
Diff to previous 27650
Moved `generate_melted_*_debugger_hook_*' from BYTE_CONTEXT into BYTE_NODE so
that they are with their frozen equivalent (Much easier in case we need to edit
one or the other).
Fixed a bug in the generation code of nested hook when melting where we should
not generate a nested hook if the line number found is null. This is the case
with melted invariant and generating the hook was causing a segmentation violation
when we were debugging from EiffelStudio.


Revision 27650 - (view) (annotate) - [select for diffs]
Modified Sat Sep 15 02:56:13 2001 UTC (18 years, 1 month ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 32119 byte(s)
Diff to previous 27441
Refactored the way preconditions label were generated. Now we clearly make
the difference between label declaration and label usage through
- generate_current_label_definition
- print_current_label
Thanks to this, we can avoid the generation of the label definition for `label_0'
that we were doing before and because it was not used some C compilers were
complaining about it.


Revision 27441 - (view) (annotate) - [select for diffs]
Modified Fri Sep 7 18:11:46 2001 UTC (18 years, 1 month ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 32035 byte(s)
Diff to previous 26913
Replaced all occurences of `gc_rparan_comma' by `gc_rparan_semi_c' since it
was a ); and not a )' that was used.
Changed definition of `gc_rparan_comma' to indeed represent ), and not );


Revision 26913 - (view) (annotate) - [select for diffs]
Modified Sun Aug 12 23:50:20 2001 UTC (18 years, 2 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 32032 byte(s)
Diff to previous 19351
Merged branch `dev46_manu' to the trunc.


Revision 19351 - (view) (annotate) - [select for diffs]
Modified Sun Jan 16 16:08:22 2000 UTC (19 years, 9 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 28691 byte(s)
Diff to previous 19032
Go back to the 4.5 release tag. Integration of previous version should have been
done in the dev46 branch, not on the trunc.


Revision 19032 - (view) (annotate) - [select for diffs]
Modified Sun Nov 21 02:24:06 1999 UTC (19 years, 10 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 28998 byte(s)
Diff to previous 19011
Removed `print_register_by_name' since we are now always generating a register
using its name due to the new local variable generation.


Revision 19011 - (view) (annotate) - [select for diffs]
Modified Sat Nov 20 19:24:10 1999 UTC (19 years, 10 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 29014 byte(s)
Diff to previous 18072
New local Variable generation. We are not generating any hooks anymore for
accessing local variables. Local variables are now registred ad the entrance
of the routine in the l[] array, but after they are accessed directly. Thus
improving speed.


Revision 18072 - (view) (annotate) - [select for diffs]
Modified Tue Oct 19 00:16:50 1999 UTC (20 years ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 28691 byte(s)
Diff to previous 14882
Improved abstraction for C generation of protected local variables l[0], by
putting in GENERATION_BUFFER a new feature `put_protected_local' which generates
the hook l[0]. This is better, because soon we will change l[0] into l_0 and we do not
want to change that everywhere in the Eiffel code, but only at one place.


Revision 14882 - (view) (annotate) - [select for diffs]
Modified Mon Jun 14 00:27:31 1999 UTC (20 years, 4 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 28787 byte(s)
Diff to previous 12654
Replaced `(char *) 0' by `(EIF_REFERENCE) 0' for future code generation improvements.


Revision 12654 - (view) (annotate) - [select for diffs]
Modified Sun Jan 17 20:52:07 1999 UTC (20 years, 9 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 28773 byte(s)
Diff to previous 12650
Fixed a generation bug with `once' functions returning an expanded type. It was
in `generate_expanded_result' which was using `result_var'. However, from the comments
I have seen this was never used and replaced somehow by `result_register' which
has all the semantics to handle `once' functions. So, I removed `result_var' from
BYTE_CONTEXT and use `result_register' in `generate_expanded_result'.


Revision 12650 - (view) (annotate) - [select for diffs]
Modified Sat Jan 16 19:37:40 1999 UTC (20 years, 9 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 28984 byte(s)
Diff to previous 11901
Fixed a bug in the generation of C++, because we did not know when we should
generate a xpp or cpp extension. Now, we know it because we add a query in
BYTE_CONTEXT which is set when generating C++ code in CPP_EXT_BYTE_CODE.


Revision 11901 - (view) (annotate) - [select for diffs]
Modified Tue Nov 10 04:03:04 1998 UTC (20 years, 11 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 28689 byte(s)
Diff to previous 11587
Removed a reverse assignment when it was not needed, and move it in the else
part where it should have been.


Revision 11587 - (view) (annotate) - [select for diffs]
Modified Mon Oct 12 22:22:40 1998 UTC (21 years ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 28612 byte(s)
Diff to previous 11550
Use now a dedicated class for C generation: GENERATION_BUFFER


Revision 11550 - (view) (annotate) - [select for diffs]
Modified Thu Oct 8 20:36:55 1998 UTC (21 years ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 29397 byte(s)
Diff to previous 11342
Changed most of the calls `f.put_string (....generated_id)' into `....generated_id (f)'
so that `generated_id' can do a better generation.

Changed the name of the class SHARED_GENERATION_CONSTANTS into SHARED_GENERATION

Also make sure that `types' has been defined as TYPE_LIST and not as a LINKED_LIST


Revision 11342 - (view) (annotate) - [select for diffs]
Modified Wed Sep 16 03:03:22 1998 UTC (21 years, 1 month ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 29407 byte(s)
Diff to previous 9654
Replaced all the occurences to the old AST *_AS_B by *_AS.


Revision 9654 - (view) (annotate) - [select for diffs]
Modified Sun Mar 15 02:12:17 1998 UTC (21 years, 7 months ago) by manus
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 29411 byte(s)
Diff to previous 7868
Changes concerning the macro and external encapsulation
This will be finished by the addition of DLL calls


Revision 7868 - (view) (annotate) - [select for diffs]
Modified Fri May 9 11:59:33 1997 UTC (22 years, 5 months ago) by zorans
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 29854 byte(s)
Diff to previous 7004
Once per thread mechanism for bytecode


Revision 7004 - (view) (annotate) - [select for diffs]
Modified Fri Nov 1 17:20:39 1996 UTC (22 years, 11 months ago) by xavierl
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 29672 byte(s)
Diff to previous 5980
bug fix: assertion in final mode (when defined in ancestor) were not generated correctly
(externals were not declared)


Revision 5980 - (view) (annotate) - [select for diffs]
Modified Fri Jul 12 20:04:28 1996 UTC (23 years, 3 months ago) by xavierl
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 29495 byte(s)
Diff to previous 5287
ANSI C/C++ code generation


Revision 5287 - (view) (annotate) - [select for diffs]
Modified Fri May 24 14:35:59 1996 UTC (23 years, 4 months ago) by terryt
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 29255 byte(s)
Diff to previous 5265
Concurrent Eiffel


Revision 5265 - (view) (annotate) - [select for diffs]
Modified Fri May 24 11:00:54 1996 UTC (23 years, 4 months ago) by xavierl
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 28208 byte(s)
Diff to previous 3185
FIXME comment added


Revision 3185 - (view) (annotate) - [select for diffs]
Modified Tue Nov 21 16:43:54 1995 UTC (23 years, 10 months ago) by dinov
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 28162 byte(s)
Diff to previous 3009
inherits from COMPILER_EXPORTER (export status)


Revision 3009 - (view) (annotate) - [select for diffs]
Modified Fri Oct 27 11:02:21 1995 UTC (23 years, 11 months ago) by guusl
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 28142 byte(s)
Diff to previous 2659
new feature: `add_to_dt_current'


Revision 2659 - (view) (annotate) - [select for diffs]
Modified Wed Jul 5 16:25:31 1995 UTC (24 years, 3 months ago) by dewij
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 27953 byte(s)
Diff to previous 2654
abstract parser: <type> => <type_B>


Revision 2654 - (view) (annotate) - [select for diffs]
Modified Wed Jul 5 15:50:18 1995 UTC (24 years, 3 months ago) by xavierl
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 27949 byte(s)
Diff to previous 1620
bug fix: generation of local variable if metamorphosis on Result
(assignment from Generic parameter to ANY, cf CALFP bug)


Revision 1620 - (view) (annotate) - [select for diffs]
Modified Fri Jan 6 19:44:34 1995 UTC (24 years, 9 months ago) by grator
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 27596 byte(s)
Diff to previous 1354
cosmetics
generation of `dtype' is done in BYTE_CONTEXT, not in all the clients
`save'/`restore' can be called recursively


Revision 1354 - (view) (annotate) - [select for diffs]
Modified Thu Nov 3 17:18:52 1994 UTC (24 years, 11 months ago) by grator
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 27565 byte(s)
Diff to previous 1353
char * => EIF_POINTER, long => EIF_INTEGER, ...


Revision 1353 - (view) (annotate) - [select for diffs]
Modified Thu Nov 3 17:13:58 1994 UTC (24 years, 11 months ago) by grator
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 27528 byte(s)
Diff to previous 1308
Integration problem


Revision 1308 - (view) (annotate) - [select for diffs]
Modified Sat Oct 29 17:58:51 1994 UTC (24 years, 11 months ago) by grator
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 27528 byte(s)
Diff to previous 1270
cosmetics
string optimization
inlining
bug fix: generation of assertion in final mode


Revision 1270 - (view) (annotate) - [select for diffs]
Modified Fri Oct 28 22:41:41 1994 UTC (24 years, 11 months ago) by grator
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 26969 byte(s)
Diff to previous 1201
new semantic of $


Revision 1201 - (view) (annotate) - [select for diffs]
Modified Wed Oct 5 00:10:04 1994 UTC (25 years ago) by grator
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 26969 byte(s)
Diff to previous 1106
inlining


Revision 1106 - (view) (annotate) - [select for diffs]
Modified Tue Sep 20 00:12:27 1994 UTC (25 years, 1 month ago) by grator
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 26799 byte(s)
Diff to previous 764
Array optimization


Revision 764 - (view) (annotate) - [select for diffs]
Modified Thu Aug 11 15:33:53 1994 UTC (25 years, 2 months ago) by grator
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 26679 byte(s)
Diff to previous 605
executin format: stop at end of routine
index is off by one


Revision 605 - (view) (annotate) - [select for diffs]
Modified Tue Jun 28 16:58:24 1994 UTC (25 years, 3 months ago) by grator
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 26496 byte(s)
Diff to previous 557
*** empty log message ***


Revision 557 - (view) (annotate) - [select for diffs]
Modified Tue May 24 15:18:32 1994 UTC (25 years, 4 months ago) by grator
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 26483 byte(s)
Diff to previous 442
*** empty log message ***


Revision 442 - (view) (annotate) - [select for diffs]
Modified Thu Dec 16 18:47:58 1993 UTC (25 years, 10 months ago) by grator
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 25928 byte(s)
Diff to previous 435
*** empty log message ***


Revision 435 - (view) (annotate) - [select for diffs]
Modified Wed Dec 8 16:54:36 1993 UTC (25 years, 10 months ago) by grator
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 25856 byte(s)
Diff to previous 388
*** empty log message ***


Revision 388 - (view) (annotate) - [select for diffs]
Modified Fri Oct 15 14:29:26 1993 UTC (26 years ago) by grator
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 25733 byte(s)
Diff to previous 296
*** empty log message ***


Revision 296 - (view) (annotate) - [select for diffs]
Modified Thu Aug 19 20:09:35 1993 UTC (26 years, 2 months ago) by grator
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 25510 byte(s)
Diff to previous 274
*** empty log message ***


Revision 274 - (view) (annotate) - [select for diffs]
Modified Fri Jul 9 15:22:19 1993 UTC (26 years, 3 months ago) by grator
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 25513 byte(s)
Diff to previous 250
*** empty log message ***


Revision 250 - (view) (annotate) - [select for diffs]
Modified Wed Jun 23 18:01:59 1993 UTC (26 years, 3 months ago) by grator
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 25427 byte(s)
Diff to previous 216
*** empty log message ***


Revision 216 - (view) (annotate) - [select for diffs]
Modified Fri May 28 11:59:15 1993 UTC (26 years, 4 months ago) by grator
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 25427 byte(s)
Diff to previous 189
*** empty log message ***


Revision 189 - (view) (annotate) - [select for diffs]
Modified Tue May 11 10:27:36 1993 UTC (26 years, 5 months ago) by grator
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 24653 byte(s)
Diff to previous 145
Initial values (0) of locals and attributes generated differently


Revision 145 - (view) (annotate) - [select for diffs]
Modified Mon Apr 5 10:06:19 1993 UTC (26 years, 6 months ago) by grator
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 24660 byte(s)
Diff to previous 112
*** empty log message ***


Revision 112 - (view) (annotate) - [select for diffs]
Modified Tue Mar 16 18:40:47 1993 UTC (26 years, 7 months ago) by grator
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 24383 byte(s)
Diff to previous 59
*** empty log message ***


Revision 59 - (view) (annotate) - [select for diffs]
Modified Mon Mar 15 16:37:17 1993 UTC (26 years, 7 months ago) by grator
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 24222 byte(s)
Diff to previous 37
Structures for 'old'


Revision 37 - (view) (annotate) - [select for diffs]
Modified Mon Mar 15 12:25:50 1993 UTC (26 years, 7 months ago) by grator
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 24117 byte(s)
Diff to previous 26
*** empty log message ***


Revision 26 - (view) (annotate) - [select for diffs]
Modified Mon Mar 15 09:33:19 1993 UTC (26 years, 7 months ago) by grator
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 23804 byte(s)
Diff to previous 20
*** empty log message ***


Revision 20 - (view) (annotate) - [select for diffs]
Modified Fri Mar 12 19:56:00 1993 UTC (26 years, 7 months ago) by grator
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 22152 byte(s)
Diff to previous 18
Ram modification for once functions.


Revision 18 - (view) (annotate) - [select for diffs]
Added Fri Mar 12 17:44:01 1993 UTC (26 years, 7 months ago) by grator
Original Path: trunk/Src/bench/Eiffel/eiffel/byte_code/byte_context.e
File length: 21603 byte(s)
Initial revision


This form allows you to request diffs between any two revisions of this file. For each of the two "sides" of the diff, enter a numeric revision.

  Diffs between and
  Type of Diff should be a

  ViewVC Help
Powered by ViewVC 1.1.23