Parent Directory
| 
Revision Log
| Links to HEAD: | (view) (annotate) |
| Sticky Revision: |
enabled more types to store monomorph information
added statistics from CAT_interval_types branch added feature flags (covariant/formal) from CAT_interval_types branch added catcall check from CAT_interval_types branch set resolved type of like Current to be monomorphic
changed type mark to bitwise operations
Added monomorph mark for class types, either "frozen" or "invariant". First (simple) conformance check for monomorphic types.
Creation of CAT_mono branch to implement variant/invariant proposal
vtgc2.e: Error printing improved. ast_feature_checker_generator.e: Added a protection for NONE types and refactored code. Compare bug#13012 (test#fixed133). class_c.e and formal_a.e: Bugfix related to bug in ast_feature_checker_generator.e mc_feature_info.e: added constraint position to output (more information for the user) renaming_a.e: implemented alias support for multi constraints. Various bugs fixed, see list below. type_set_a.e: went from is_loose to has_formal as is_loose includes like which is ok. ast_compiler_factory.e: Added comment about where similar code can be found code. formal_constraint_as.e: Added code to print erros without using the compiled version of a renaming, as it cannot reproduce the complete information. rename_clause_as.e: Added two features to support error output generation. The following bugs are fixed because of better error printing and alias support for multi-constraint formals: * bug#12776 with test#multicon044 * bug#12778 (now there is a proper error message) * bug#12877 with test#multicon045 * bug#12785 with test#multicon047
Renamed `{SYSTEM_I}.set_freeze' and `{SYSTEM_I}.private_freeze' into
`request_freeze' and `is_freeze_requested' respectively to highlight the
fact that freezing happens because of compiler needs rather than due to
project settings or users' request.
Made `{SYSTEM_I}.is_freeze_requested' available for call to allow quick
test if the system is about to be frozen anyway to avoid more complex
checks.
Changed code generation for CECIL table in workbench mode to call wrappers
that convert CECIL types into EIF_UNION and back, so that CECIL interface
is preserved (this fixes code generation issues in test#ccomp063).
Ensured that if visible features are recompiled, the code is frozen so that
CECIL wrappers are generated.
Removed precondition "has_current_class" from `{TYPE_A}.create_info'
because it is not required for the implementation.
Removed byte code generation for CECIL table as it is not used in the
current implementation.
Small bug fix for bug#12984.
Previous fix for bug#12822 was not entirely correct since the caching in CLASS_C for constraint_classes and constrtaint_renaming was done in the same slot for all the formal generic parameter, instead of having their own slot (shown by eweasel test#multicon030). Fixed FORMAL_CONSTRAINT_AS.new_renaming_a which was causing test#multicon042 to fail. Refactored usage of FORMAL_CONSTRAINT_AS.new_renaming_a to simply callers' code by allowing a Void argument.
Fixed bug#12822 due to the storing of CLASS_C objects as part of the AST, as a consequences EIFGENs grew a lot from about 8 to 11MB for a small project, but from 800MB to 6GB for a larger one.
Turned martin's question into comments/warnings.
added statistics about total cat calls.
Refactored RENAMED_TYPE_A to RENAMED_TYPE [G -> TYPE_A] This change allows us to program type safe if possible.
In case a generic derivation is outside of a feature the message printied in an error was simply: "invariant" In some cases it was wrong as the context has not been cleared. This fix cleares now the `ast_context.current_feature' before it checks inherited classes and the error message in feature_error.e has (temporarily) be adapted.
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)
* 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
* Fixed minor bug in FORMAL_CONSTRAINT_AS (renaming of single constraint type was not checked) * Adapted precondition of conformance features in TYPE_SET_A * Refactored EXTENDED_TYPE_A into RENAMED_TYPE_A. * Refactored MC_ERROR_REPORT into MC_FEATURE_INFO
Cosmetics: I replaced double (or more) lines in the source code by single lines automatically. So you might hit anomalies. But I hope they are just a few exceptions.
Added configuration option to activate the catcall check. Added catcall check for feature calls on non-generics. Added warning for catcalls.
cosmetics: proof of concept for removal of double new lines in code
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.
Moved `implemented_type' from CIL_CODE_GENERATOR and CLASS_C to CL_TYPE_I to simplify the code and avoid potential mistakes when using it. Supplied context type of the feature source code when generating replicated features under .NET as otherwise type evaluation might cause a compiler crash as generic parameters (if any) of the current class type might be different from those of the source class type (this fixes bug#12219, test#dotnet050).
Added `evaluated_type_in_descendant' in TYPE_A to evaluate a type in the context of a descendant class. The existing instantiation_in would not do it since it does it in a CL_TYPE_A version of the descandant class. Although not yet done, `instantiation_in' could be rewritten in a much simpler fashion by using this new routine and the existing `instantiated_in'. Full class checking: - Added `full_class_checking' option in the configuration library and removed the system option in SYSTEM_OPTIONS.full_type_checking and the associated settings in the configuration library. - Updated code in AST_FEATURE_CHECKER_GENERATOR to perform a correct full class checking. - Changed EIFFEL_CLASS_C.pass3 to properly initialize the checker to perform full class checking, also melted routine without assertions are checked normally (i.e. `to_melt_in' on DEF_PROC_I are now the same as FEATURE_I). First result of applying catcall checking on the compiler: - Fixed a validity error in `is_safe_equivalent' from TYPE_A. - Fixed a validity error in CLASS_TYPE.make
Removed useless precondition for `conformance_table' not beeing Void, since it is created in the creation routine and never reset. Therefore added this as an invariant.
Changed initialization of expanded objects under .NET to record generic type information if necessary. Changed initialization of arrays of value types in .NET to avoid leaving a value on the stack while performing unconditional branch instruction as this violates CLI rules. Fixed a recompilation issue when a single class type becomes non-single or vice versa. Fixed a recompilation issue when a generic parameter changes its expandedness status so that true generics and meta generics of the generic class are not compatible anymore. Avoided enumeration of interfaces of the generic class types that are not registered in the system. Forced enumeration of all possible conforming derivations only in precompilation mode. Corrected .NET code generation to initialize result of an expanded type as required. Changed code generation for assignment to attributes under .NET to take into account the restriction that there should be no value on the stack when an unconditional branch is performed. Used the same code to initialize entities of expaned type under .NET that include locals, result, attributes, array items, default values.
Renamed `is_deep_equal' into `is_safe_equivalent' since there is `is_deep_equal' from ANY when compiling with FreeELKS.
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.
- The Objects tool will now display all once routines under the "Once routines" row. This includes functions and procedure.
Fixed a recompilation issue that caused test#dotnet049 to fail when the external parent of a class is replaced by a non-external or vice versa.
Fixed eweasel test#term146 where check for VTUG(2) was done to late at degree 4 and thus we could try conformance between two invalid generic types.
Fixed eweasel test#incr279 by ensuring a regeneration of the byte node for all features of a class that is marked `changed4'.
Made changes that should allow generating .NET code where generic derivations with expanded parameters conform to generic derivations with reference parameters. Avoided argument conversion for method implementations that redefine an argument of one TYPED_POINTER derivation into another one. Ensured that an attribute setter implementation unboxes its argument if the attribute type is changed from reference to expanded (e.g., when implementing the setter of a generic derivation with an reference parameter in the code of a generic derivation with an expanded parameter).
Changed made due to bug fix in configuration library.
Fixed some possible problems with overrides where we called lace_class instead of original_class
Minor optimization by storing `System.root_creation_name' in a local.
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
* removed argument constraints from creation features of the root class which are not specified as the root creation feature * added support for generic root types * adapted the error codes according to ecma standard
Added a validity error that disallows inheriting different generic derivations of the same class.
Supported code generation for basic types, so that they can be attached to variables of an Eiffel type (e.g., INTEGER_64 to COMPARABLE) preserving their expanded semantics. Ensured that a creation information that might come from the code is not stored in objects for class types that are used for code generation to avoid problems with using it when not it should not be used. Corrected code generation for inline agents so that the corresponding methods are declared before use (it can be important when the agents are nested, for example). Added code to store information about local variables that might be introduced for performing reattachment of an expanded object to a reference entity in the methods that are generated to support interface of an inherited class.
refactored configuration library into two parts, parser that handles parsing and writing configuration files, compiler that does the compiler specific part (degree 6) moved some classes around and created some new libraries to be able to use the parser and configuration system as a library in the compiler cleaned up the ec.ecf
is_frozen is now determined by an internal state flag and applicability or applying msil application optimizations.
Replaced non-existing type FORMAL_ATTRIBUTE_I by TYPE_FEATURE_I which is the new name. Added missing precondition to `formal_at_position' that states that `generic_features' cannot be Void.
No need for `has_externals' query. It was there to force a freeze when `melt_all' was called. But now we fixed `melt_all' to trigger a freeze when one of the routine to be melted is an external feature.
fixed some contracts
Marked feature {ANY}.equal as expected and non-removable because it is used by run-time.
changed some AST iterators to process inline agents fixed some problems with inline agents and refactoring fixed a problem if a class in the root cluster which is not the root class was renamed made eiffel studio a bit more robust if a file name of a class was externally renamed
Use new names for basic classes for queries/commands in BASIC_SYSTEM_I. Updated callers accordingly.
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.
Used a new feature to get a reference counterpart of the given expanded type.
Changed EIFFEL_CLASS_C.parse_ast to be a function call `parsed_ast'. This function is now
responsible to check that the stored `ast' is up-to-date. If not then we call `build_ast'
to regenerate one.
Updated callers of `ast' and `parse_ast' to use new routines `parsed_ast'.
This also fixes a bug recently introduced that the currently edited class would always be
recompiled because `parsed_ast' as a side effect of adding to DEGREE_5. This has now been
removed as the configuration is smart enough to detect which classes have changed and also
because EiffelStudio does not have the ability to compile only classes edited in EiffelStudio.
Added `file_date' in CLASS_I to query the file date.
Added `date' and `set_date' query in CLASS_AS to store the date of the last parsing (it is used
by `parsed_ast' to avoid rebuilding the AST too often when it does not need to).
Added `is_warning_generated_argument to EIFFEL_CLASS_C.build_ast so that when we are not parsing
for the compiler all syntax warnings are disabled by default. This could potentially fix bug#10638
where warning were always added.
improved documentation for CLASS_C lace_class and original_class improved refresh behavior for properties tool
Added VJRV warning control in configuration. Added `is_warning_enabled' in CLASS_C and updated AST_FEATURE_CHECKER_GENERATOR accordingly.
Fixed bug found after perform a refactoring renaming because we were still using `lace_class' rather than `original_class' in `recompute_syntactical_clients'. Fixed similar issue when comparing with `any_class' and `native_array_class' from SYSTEM_I which could yield to a bug if ANY or NATIVE_ARRAY is overriden.
- Support for agents on attributes and externals - Support for inline agents. - No freeze anymore when creating a new agent. - Removed bug in Named tuples
1. Modified cluster hierarchy text generation. 2. Integrated viewpoint support in text formatter, with which we are able to display various renamed names at different viewpoints. 3. Display correct renamed name in completion list, warnings and errors. Display current class based renamed name in documentation. 4. Integrated optimization for completion list. 5. Fixed page down/up problem in completion list. 6. Moved editor token writer to be shared.
Fixed VTCM warning for a class which does not exist.
fixed a crash if with namespace retrieval if we have overrides
fixed bug#10297 where selecting deferred did not unselect generate creation procedure fixed a bug if a new class was created and then directly removed again fixed a bug where new classes added in eiffelstudio where not compiled correctly if the were not used fixed some stone validation bugs
readded has visible again removed unused external_name feature
fixed postcondition fixed a bug in the configuration system with precompiles
Moved trunk/Src/bench/Eiffel to trunk/Src/Eiffel.
Fixed mixing paranthesis in indexing clause for the licensing. Added missing license reference in newly created Eiffel classes.
Added a check that class ANY has feature `twin'.
New compiler with new configuration system For now only the batch compiler works
Now FORMAL_CONSTRAINT_AS.constraint_type takes an argument which is the class in which FORMAL_CONSTRAINT_AS appears. It frees us from the dependency to finding out the current class from SYSTEM_I which can be Void when not compiling.
Added facility to return short signature of a class, for example, short form of HASH_TABLE [G, H -> HASHABLE] is HASH_TABLE [G, H -> ...]. It is used to save display space for class browser.
Updated with changes in AST_FEATURE_CHECKER_GENERATOR which prepare the code for flat degree 3 checking.
1. Removed all STRUCTURED_TEXT within the compiler. 2. Replaced with TEXT_FORMATTER for editor and documentation output formatting. Generally, there are five descendents for the moment. -OUTPUT_WINDOW: For simple string output. i.e. Command line, file, buffered string etc. -TEXT_FILTER: For various documentation formatting. -EB_OUPUT_MANAGER: Mainly for EB_GRAPHICAL_OUTPUT_MANAGER decoration. -EDITOR_TOKEN_WRITER: Editor tokens are translated here for colorized editor views. -TEXT_FORMATTER_DECORATOR: A decorator of TEXT_FORMATTERS. Handles context and formatting information. AST visits for outputs are mainly mediated here. There are two sets of interface, process_* and add_*. The main one is process_* which is recommended to use. add_* is from STRUCTURED_TEXT which does not exist any more. As it affected vastly, I still keep its interfaces. 3. SHARED_TEXT_ITEMS are all strings now, as items in structured text have been removed. 4. Wrote AST_OUTPUT_STRATEGY which is an AST_VISITOR processing AST to TEXT_FORMATTER. Wrote AST_DECORATED_OUTPUT_STRATEGY a client of TEXT_FORMATTER_DECORATOR. And one AST_DOCUMENTATION_OUTPUT_STRATEGY only for documentation. 5. Removed flat/short views buffering of STRUCTURED_TEXT. It is slightly slower than before, but in my opinion acceptable. 6. Wrote a AST_TYPE_OUTPUT_STRATEGY which visit a type and print its ‘text’ representation output to a TEXT_FORMATTER. 7. Rewrote TOKEN_VISITOR and a descendant EIFFEL_TOKEN_VISITOR for editor tokens in library and in the compiler. 8. Leave printer command prints simple text in current editor. Further work will be done a little later. 9. We gain 22% faster of documentation generation for the moment. Less than we expected, I think, mainly because of additions and accuracy we gain.
Renamed `has_internal_single_parent' into `has_external_main_parent'. Fixed initialization of `has_external_main_parent' to take into account the case where an Eiffel class inherits from an Eiffel class which iteself inherits from an external class. This is necessary to guarentee that the runtime features will then be properly generated.
Refactoring which separate TYPE_AS from TYPE_A.
* The TYPE_AS classes specific to the compiler have been removed, we now use the one from the
parser cluster. Only INTEGER_CONSTANT and FORMAL_CONSTRAINT_AS are compiler specific, but defined
as descendants of INTEGER_AS and FORMAL_DEC_AS.
* The return type and arguments' type are of type TYPE_A, which help us in removing many calls to
`actual_type' when the purpose was to get the TYPE_A instance as statically it was a TYPE_AS, but
dynamically it was TYPE_A.
* Rewritten the way we go from TYPE_AS to TYPE_A. This is now done in two steps.
1 - convert TYPE_AS into TYPE_A using the AST_TYPE_A_GENERATOR visitor. For Bits symbol and anchors
we get an UNEVALUATED_XX version.
2 - evaluate and check validity of TYPE_A we obtained by 1), this is done using TYPE_A_CHECKER.
TYPE_A_CHECKER is modular in the sense that it can be configured to trigger or not errors.
Useful to disable when we are in part of the UI of EiffelStudio who does not care about an
error reporting.
* Thanks to the above refactoring, I fixed eweasel tests: test#valid104, test#valid131, test#valid135.
It was due to a bug that when solving an anchor type, we did not update `feature_id', as a consequence
a comparison would yield False instead of True, because they were referring to the same anchor.
* In TYPE_A, try to add some preconditions to `associated_class' and fix all incorrect usage of it.
Use `is_valid' a lot to ensure that we have a valid type (used to check validity of types in
inheritance clause and constraints).
* Changed formatting so that we see G#x and arg#x (whereas it was Generic #x, Formal #x and arg # x)
to make things more compact.
* Updated all the other part of EiffelStudio that depended on the above changes.
* New version number 5.7.0806
Implementation of labeled tuples with a limitation which is that the identifier list is reduced to only one element, as it is causing the grammar to be too difficult. But the current implementation is fully equipped to handle multiple entries as soon as the parser is fixed.
Added a query to tell if a class has an Eiffel parent class that is generated as a single IL class type.
Changed class_c.ast to always return the most recent ast.
-add type information to the ast during degree 3 -make a type check of all features, instead of only the changed ones, if a class has been parsed again (need because we have a new ast and we need to readd the type informations) -changed parser used during degree 5 to light roundtrip parser (roundtrip parser without matchlist generation) -refactoring tool -refactored comment code to use the available information from the roundtrip ast -added a server for matchlists, that generates matchlists on demand, using the fast scanner
Refactored temporary ast, body and invariant servers into tmp_ast_server and keep information in memory until after degree 2.
Ensured that generic derivations depending on expanded class types are regenerated when skeleton of those class types changes. Changed processing of parent filters for expanded class types to take into account only "like Current" types, not any other types like formal generics as it does not make sense.
Added text of the GPL license to all classes of the compiler.
Fixed a bug related to change of external_class_name from type STRING to STRING_AS, which in case an external name doesn't exist, we may call external_name.value, where external_name is Void.
Changed type of external_class_name from STRING to STRING_AS.
1.Added complete_start_location and complete_end_location to give the pricise position of an AST node. And changed start_location/end_location to call the above 2 features. 2. Added text modification facility into AST nodes.
Included parent filters in types update for expanded types to ensure that all required class types are registred for expanded types code generation.
Ensured that when a default class type is registered, it is also added to instantiator as otherwise anchored types of the root class may remain uninstantiated.
Unified processing of class types between normal classes and tuple class. Corrected a recently introduced bug in a class type processing that might cause duplicate class types to be registered.
Recorded explicit class type declaration rather than a calculated one to
avoid issues with recompiling classes that change their expandedness
status.
Initialized class types associated with a class using `update_types' to
ensure that all structures (e.g., `derivations') are updated as well.
Used instantiation procedure unconditionally to cover the case of "like
Current" type.
Made a feature `duplicate' available in CL_TYPE_I to avoid using reverse
assignment.
Ensured that parent types are reference.
Created generic attribute descriptor not only for types that depend on
formal generic but also for those depending on anchored type ("like
Current").
Removed check whether a type has formal before calling "instantiation_in" because the latter will also be used for calculating "like Current" type.
Removed trailing spaces.
Added a check to prevent inheritance links to external classes from expanded types. Used reference class types as parents all the time. Registered a reference class type for any expanded class. Changed evaluation of a meta-type for non-generic class to preserve expandedness status of a supplied class type.
Forgot to set the current_feature of AST_CONTEXT so that we can properly report validity errors on custom attribute.
Revisited computation of directory name for code generation. Added `packet_name' in SHARED_CODE_FILES so that we have a consistent way accros various classes to build that directory name. It avoids hard-coding some knownledge about our directory structure.
Fixed precondition violation due to recent changes about creating the right type instance of NATIVE_ARRAY [G] with G formal generic parameter.
Instead of using specific routines from CLASS_C to get the E_FEATURE corresponding to where the feature is currently written, we use the new E_FEATURE.written_feature query. It makes the code more maintainable without having to know too much about CLASS_C. It also solved a bug with previous integration only using `written_feature_id', because I forgot that this attribute is only set in .NET code generation, not in classic. Thus E_FEATURE.written_feature takes that into account, and when it is not set uses the `body_index'.
Removed `feature_with_body_index' and replaced it by `feature_with_feature_id' which will also work for .NET routines which do not have a `body_index'.
Supported lookup for a feature alias in addition to a feature identifier.
Removed `extend_anchored_features' which was not used. Changed `update_anchors' so that attributes whose type is either formal or generic have a TYPE_FEATURE_I associated with them, so that we can find out in INTERNAL what is their static type.
Adjusted feature name setting to follow changes for alias name support.
Instead of relying on `parents = Void' to call `fill_parents' we now have a flag `need_new_parents' to trigger the call. It fixes incr233 and fixed120 after our bug fix of incr242 done in DEGREE_5.
Use `custom_attributes_type_check_and_code' instead of `process' to validate custom attributes.
Use AST_FEATURE_CHECKER_GENERATOR to perform type checking and BYTE_NODE generation in `pass3'. Use AST_PARENT_C_GENERATOR in `fill_parents'.
Properly initialize location information for errors, unfortunately for some errors we are not able to do it properly (thus a fixme). Removed `click_list' which was not used.
Use `associated_class' from `PARENT_AS rather than picking it up from PARENT_AS.type. Fixed `feature_named' so that it does not violate a precondition when calling `feature_table'.
Fixed incremental bug eweasel `incr241'.
Fixed eweasel tests `incr165', `incr169' and `fake004' because in `fill_parents' we were only comparing the parent class and not the parent type. Indeed if you inherit from LIST [INTEGER] and switch it to LIST [BOOLEAN] a lot of type checking needs to be done, before nothing was done because in both cases it was LIST. So now instead of using `same_parents' and `removed_parent', I've introduced `similar_parents' which returns a TUPLE with two BOOLEAN: one to say if parents are similar and the other one to say if parents have been removed. Thus making the all thing slightly faster. Unfortunately to do that I need to retrieve the old CLASS_INFO instance and this penalize a little bit the performance.
Fixed eweasel test incr233, by recording all VTCT errors during degree 5 and then making sure that all potential errors are actually errors (because a clause is really needed, and not because a class was forced a recompilation and the class is not actually used anymore in the system). This required to move part of `init' which was handling `parents' into `fill_parents' which is now called after all VTCT errors have been reported.
Reverted back to version 1.258 as the `fake005' has been fixed through INHERIT_TABLE.
Ensured that byte code is not saved in temporary byte servers when an error is encountered, as this (wrong) byte code would be used without regenerating it if a project is recompiled (e.g., this happens in eweasel test "fake005").
Fixed an issue in classic where because we set `is_external' to True for basic
classes, then a finalization using a precompiled library will result in unresolved
C externals corresponding to NATURAL_XX_REF features. This was caused by
the fact that the code in `record_precompiled_class_in_system' did not
recursively explore the content of the NATURAL_XX classes and therefore
considering that NATURAL_XX_REF were not in system, but since they are
inherited by the NATURAL_XX classes then some code was generated in the
polymorphic table and thus the unresolved externals.
To solve this, we did two things:
1 - we do not mark `is_external' to True in classic mode
2 - in `record_precompiled_class_in_system', instead of checking for
`is_external' we actually check for `has_ast'.
Allowed some of the VIFI2 error to be triggered in classic too.
Ensured that changing the status from `frozen' to non-frozen does what it
is supposed to do in classic.
In `init', in order to mark `System.set_has_expanded' it suffices to check
if current class is expanded and that it is not a basic class, instead of
doing a long boolean expression that might be expansive to compute.
Removed requirement of `il_code_generation' when using frozen class.
Make basic class `external' by default, so that we can have version of the class for .NET and classic.
Before parsing a class make sure `inst_context' is properly set. This is needed as now we use `actual_type' while parsing for manifest integers/reals.
Fixed bug where `filters' was not cleared when adding a formal or removing one. This was causing eweasel test incr236 to fail. Still the bug fix is not perfect (see the fixme entry).
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
....
Added a feature to set assembly info for classs being (pre)compiled.
Supported generation of an IL object type with class-specific data.
Supported option-controlled processing for old-style verbatim strings. Added warning for old-style verbatim strings.
Supported once manifest strings.
Fixed errors reported by gelint since our compiler does not do yet system validity checking (i.e. flat degree 3 checking).
Changed `partial_actual_type' to not take into account if `reference' was specified or not, because support for `reference X' has been removed.
Changed `meta_type' signature to take and return a CLASS_TYPE rather than a CL_TYPE_I. This was done because it was used in context where we needed a CLASS_TYPE and not a CL_TYPE_I. Moreover it enables us to gain some speed as most of the type we don't need to do `CL_TYPE_I.associated_class_type' which is expensive. Updated code using `instantiation_in' from TYPE_I since now the parameter has to be a CLASS_TYPE and not a GEN_TYPE_I.
New way to remove useless C generated classes. Before it was done when a class was removed from the universe, but we were not doing it in the case a particular CLASS_TYPE was removed from the universe. So now we have added this possibility to CLASS_TYPE, and CLASS_C now uses it when removing the C generated files.
Renamed TYPE into TYPE_AS
Incrementality for expanded. When an expanded type has its skeleton changed we need to recompile all the classes using this expanded type to ensure that the expanded are created with the proper size (since size is hardcoded in generated C code).
Updated signature of `append_signature' from CLASS_C which now takes a new argument to tell if it should display a `*' for deferred classes or not. It is False except when used when displaying queries on the system (e.g. descendants, ancestors,....)
Added a `*' in the signature of a deferred class. This only appears in formatters such as ancestors, clients, suppliers, descendants and in some error reporting messages using `append_signature'.
Removed knowledge of TO_SPECIAL since we don't need it anymore to create SPECIAL instances. Instead of create them directly in SPECIAL and through CREATION_EXPR_B. Removed `is_special_array' and use now `is_special' instead since now we cannot make the confusion between SPECIAL and TO_SPECIAL. Made SPECIAL a debuggable class since there is nothing special about this class apart creation and access which are inlined.
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.
Added assertions about upperness of class names
Removed `generate_cecil_value' and `cecil_value' which are not needed in CECIL_CLASS_TABLE because we use the version from TYPE_I instead.
Implemented constraints that are either reference or expanded: Renamed `formal_name' to `name' to match new name in FORMAL_AS/FORMAL_DEC_AS. Updated to new way of creating a FORMAL_A instance which now needs to know whether or not it has the `reference' or `expanded' constraint.
Updated code to take into account that now ANY is the ancestor of all classes even .NET classes. Prevent .NET classes to be included in compilation degrees if they have been already built.
Use NAMED_TYPE_A instead of CL_TYPE_A for type used in conversion. Fixed precondition violation in `copy_file' from `build_ast' because file we are reading from was already open. Added `parents_classes' which is something we use more than `parents', replaced most routines using `parents' to use `parents_classes'. Added `computed_list' as an attribute since PARENT_LIST is not stored in CLASS_INFO anymore. Both `parents' and `computed_parents' are computed at the end of degree 5 in `fill_parents'. Only `parents_classes' is computed during degree 5. Removed strange setting of `creation_feature'. Fixed strange error I got with class names that have only one character, sometime the generated C file for 2 classes could be generated in the same C file. When the expanded status of a class is changed, we removed all its `types'. Class names are stored in upper, so we need to use upper case version. Added `partial_actual_type' to generate an instance of TYPE_A for CLASS_TYPE_AS; it does about the same job as `actual_type' except that it could generate an invalid TYPE_A instance (e.g. it can generate the type for INTEGER [BOOLEAN] although this is not valid). Modified `update_instantiator1' so that the reference version of parent types whose base class is expanded are inserted in the `Instantiator'. Now we insert in `types' the reference and expanded version of a class, meaning that `types.count > 1' does not imply that we are handling a generic type.
Fixed `term126' from eweasel where a generic class without `types' (i.e. marked visible in the Ace file) had its feature table generated. Now we only do it if there are some types, thus new precondition `has_types' to `feature_table_file_name', `packet_number' and `feature_table_file_id'.
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.
Incorrect code to force checking of expanded which was disabled in IL code generation thus failing to check the VTEC and VLEC validity rules.
Use `twin' instead of `clone' which is now made obsolete. Use `as_lower' and `as_upper' whenever appropriate instead of cloning and then calling `to_lower' or `to_upper'.
Use `as_lower' and `as_upper' whenever appropriate instead of cloning and then calling `to_lower' or `to_upper'.
Improved `is_removable' so that it cannot be removed if it is not part of `classes' from SYSTEM_I, meaning that it has already been removed.
Better usage of `open_read' / `is_open_read' from Gobo to avoid querying the file system too many times, thus we gain a few precious seconds.
Made sure to update `anchored_features' with new computed `l_anchored_features' at the end of the loop and not each time. Also we do it even if `l_anchored_features' is empty, as if we do not do it, then it is possible that we will try to generate TYPE_FEATURE_I in IL code generation that are invalid (because the anchor has been removed and its associated class too).
Made SUPPLIER_LIST an ARRAYED_LIST. Removed `suppliers' from SUPPLIER_LIST, instead we traverse directly the TWO_WAY_SORTED_SET [DEPEND_UNIT]. Fixed precondition violation `consistency' in `remove_occurrence' because if you remove `create l.make' and `l' being of type LINKED_LIST [INTEGER] it would be violated, because we don't skip removed classes from system.
Fixed code so that when we insert a new type we `melt_all' features of associated class. This fixes eweasel bug `term114': After initial compilation, a generic class TEST1 [G] is changed to a non-generic class and the class that inherits from TEST1 is changed correspondingly. When the system is frozen, the compiler dies in degree -1.
Make sure we use a fake routine while type checking custom attributes of classes.
Added type_check and byte code generation for `assembly_attribute' indexing entry.
Fixed minor issues with newly introduced TYPED_POINTER class, but also an existing issue with POINTER class in IL code generation. It turns out that we were checking VTEC errors all the time now because we forget to exclude TYPED_POINTER as part of the classes for which we should not check VTEC. Doing the check is very expensive (on the compiler code it was freezing the compilation at the end of degree 4 for about 20s). Now in IL code generation it was always checking because we incorrectly placed a paranthesis.
To properly check creation expression in an invariant clause, we need to set AST_CONTEXT to the `invariant_feature' context, otherwise we violate the precondition in the CREATION_EVALUATOR.evaluated_type call as AST_CONTEXT.current_feature was Void
Fixed bug where when removing classes in the system was not removing the generated C files. It was known it was not happening for C++ code, but I did not realize that the ID was not part of the name of the file we were trying to remove.
Fixed new implementation of `process_skeleton' as it did not work for .NET systems where not all classes have a skeleton (eg. external classes). Added assertion in CLASS_C to reflect that `skeleton' should not be Void. Updated to new API of GENERATION_BUFFER.
Fixed typo in last integration. We were always freezing when adding a new generic derivation where it should only be done when class has some external declaration.
Fixed processing of skeleton for melted mode when handling classes with expanded attributes (fixes eweasel test melt015). The reason is that if an expanded class adds or removes attributes its skeleton is modified, but not the one of classes that are using it as an attribute. Therefore the size of objects is completely incoherent (it keeps the one from the last freeze). To ensure it works properly, we need to go through all classes of the system at each compilation. It is maybe not efficient, but I don't see another solution. However this impact is only for incremental compilation.
Added `has_externals' so that when a class has an external declaration, it is set to True. Useful for the compiler to find out if it needs to freeze or not when creating a new generic derivation of a class. Fixed issue when an external routine is added to the melted_set where we need to freeze and this was not done. This fix removes previous fix we made in `compute_byte_code' from FEATURE_I.
Because we always call externals through their encapsulation now, their is no need to create a special type of FEAT_MELTED_INFO. Part of the following commit session: Modified Files: common/parser/parser/external.l common/parser/parser/external.y common/parser/parser/external_parser.e common/parser/parser/external_scanner.e common/parser/parser/external_tokens.e eiffel/AST/external/c_extension_as.e eiffel/AST/external/cpp_extension_as.e eiffel/AST/external/dll_extension_as.e eiffel/AST/external/external_as.e eiffel/AST/external/external_extension_as.e eiffel/AST/external/external_lang_as.e eiffel/AST/external/il_extension_as.e eiffel/AST/external/inline_extension_as.e eiffel/AST/external/macro_extension_as.e eiffel/AST/external/struct_extension_as.e eiffel/AST/skeleton/body_as.e eiffel/byte_code/ext_byte_code.e eiffel/byte_code/external_bl.e eiffel/byte_code/external_bw.e eiffel/compiler/externals.e eiffel/compiler/feature_table.e eiffel/compiler/melted_info.e eiffel/compiler/pass2_control.e eiffel/generation/rout_table.e eiffel/genericity/type_c.e eiffel/inheritance/inherit_table.e eiffel/interface/c_extension_i.e eiffel/interface/c_macro_extension_i.e eiffel/interface/class_c.e eiffel/interface/cpp_extension_i.e eiffel/interface/dll_extension_i.e eiffel/interface/external_ext_i.e eiffel/interface/external_i.e eiffel/interface/feature_i.e eiffel/interface/il_extension_i.e eiffel/interface/inline_extension_i.e eiffel/interface/struct_extension_i.e eiffel/interface/system_i.e eiffel/tables/execution_unit.e Removed Files: eiffel/byte_code/c_ext_byte_code.e eiffel/byte_code/cpp_ext_byte_code.e eiffel/byte_code/dll_ext_byte_code.e eiffel/byte_code/il_ext_byte_code.e eiffel/byte_code/inline_ext_byte_code.e eiffel/byte_code/macro_ext_byte_code.e eiffel/byte_code/struct_ext_byte_code.e eiffel/compiler/ext_feat_melted_info.e eiffel/compiler/external_info.e eiffel/compiler/il_c_externals.e eiffel/generation/extern_entry.e eiffel/shared/shared_externals.e eiffel/tables/ext_execution_unit.e
Updated `check_root_class_creators' so that it accepts the following code: class TEST create make feature make (args: like x) is do end x: ARRAY [STRING] end
Removed `mark_all_used' since it is not used anymore. Updated TUPLE_CLASS_B so that there is no special `check_validity' implementation for TUPLE. Made TUPLE_CLASS_B redefine `is_tuple' accordingly. Cosmetics.
Added `is_tuple' to find out if a class is the tuple class. Used only by debugger so far.
Removed non-used local variable.
Added comments about cloning of `f_suppliers' in pass3 for invariant.
Added `convert_to' and `convert_from', and their corresponding set_ routines. Used for convertibility mechanism. Added `constraint_actual_type' which is equivalent to `actual_type' except that all formals if any are replaced by their constraint type. Renamed `is_procedure' into `is_routine' per FEATURE_I changes.
New implementation of ROUT_ID_SET which uses less space in memory. We have saved about 6% in size of COMP directory, and we have also improved performance by having just one attribute of type INTEGER for the first element of the set, and if there are 2 or more elements we create the SPECIAL [INTEGER] instance that holds the remaining items. Updated callers to `make' as it does not take an argument now.
Updated to new ETL3 syntax.
Fixed precondition violation in usage of `copy_file' from KL_BINARY_INPUT_FILE.
Updated to new interface of parsing due to use of Gobo 3.1.
Set `has_syntax_warning' before each parsing with values taken from SYSTEM_I to find out if we should create a warning each time we encounter an obsolete syntactical construct.
Removed not used anymore `is_generated' since it was not fine enough. We are better of using `is_generated' from CLASS_TYPE.
Removed non-needed local
Added new type of validity error checking: checks VLEC with instantiated generic parameter inherited from parents. It forbids the following sequence of code: class A [G] inherit ARRAY [expanded A [G]] end Added `implemented_type' which given a `class_id' and a `current_type' will find the CL_TYPE_I instance associated to `class_id' used by inheritance in `current_type'. Needed for `generate_expanded_creation_table' from SYSTEM_I, to generate the correct creation feature name, when this feature is inherited from a parent class. It fixes eweasel entry `finalize-inh-exp-creation-proc ccomp015'.
Fixed incorrect class name for `check_validity': ANY instead of STRING for correct definition of `internal_correct_mismatch'.
Removed useless local variable.
Fixed named for required routine for recoverable storable: correct_mismatch -> internal_correct_mismatch. Fixed bug in finalization where `internal_correct_mismatch' needs to be kept even if not used.
Added support for recoverable storable by generating new C variable `egc_correct_mismatch' which is the pointer to the feature `internal_correct_mismatch' from ANY.
Fixed a bug where compiler was crashing when a class has its generics changed, because we were not forcing a recomputation of its skeleton through a call to `set_changed3a'. Fixed an issue where compiler was not detecting wrong declaration of a class in a local part of a routine which references a class that got its generic changed. Fix was to force a complete `type_check' in `pass3'. We have added `need_type_check' for this purpose and this is checked in `changed3'.
Fixed bug when changing the `frozen' status of a class, not all dependencies were not recompiled and therefore non-verifiable code was generated. By doing so, it came to mind that when a class has its generics changed, we could do the same thing as when the frozen status changed. It will removes potential bug due to removal of class which is always a big issue in current implemetnation.
In order to update the debug information associated to the invariant in IL code generation, we have to do like features, i.e. recheck and regenerate the byte code with the new AST info.
Force recompilation of code when `line_generation' is on, or if we are in IL code generation. Fixed bug when calling `types.wipe_out' to clean up associated class types of current class. We also need to remove them from `System.class_types'. As a consequence, introduced `remove_types' which does the job properly. Not cleaning `System.class_types' was causing some info to be generated for even dead types (e.g. assertion level info in IL code generation).
Made current class COMPARABLE instead of PART_COMPARABLE. We still keep the `is_equal' from ANY because the way CLASS_C instances are created, there is only one with a given `class_id'. This is useful to sort CLASS_C instances by their topological order.
Added call to `checksum' in `check_parents otherwise it will crash the compiler with following class: class CRASH inherit CHAIN feature duplicate (n: INTEGER): like Current is do end end
Added comments in invariant part to say that once a CLASS_C is properly initialized, it should have access to an AST.
Fixed preconditions violation in `record_suppliers' in the case where we handle an IL external feature which has no `body_index' (since not defined in Eiffel).
Made compuation of `main_parent' only when `il_generation'.
Removed 'valid_body_index' precondition since is violated by certain .NET features since .NET features may have a body_index of 0/
Reset `types' of current class when a class has its `is_single' status changed. Added `main_parent' and `number_of_features' that are used in IL code generation to find quickly on which branch we should perform the single inheritance code generation.
Perform type checking of custom attributes at degree 3.
Fixed an invariant violation that will occur in `AST_CONTEXT.clear2' because we are cloning the head of `supplier_ids' and possibly add an element to the list afterward which causes the head still in `AST_CONTEXT' to be corrupted because the count did not change, but the BI_LINKABLE elements are incorrect.
Use local variable to perform loop for increased performance.
Added missing pre and post-conditions. Cosmetics.
Added attribuet to determine if truly a .NET class.
Improved precondition of constraint. Added `feature_of_rout_id' and improved `feature_of_feature_id' in speed.
Added `is_single' and `is_interface' (see comment for info). Improved `check_parents': - so that it tries to report as many errors as possible, i.e. not stopping checking, but goes to next parent. - added new error detection for .NET classes inheritance: we now generate both VIFI1 and VIFI2 errors.
Insert skeleton to perform system validity checking, but at the moment it does not work very well because we do not handle renaming of feature used by currently inherited feature.
Simplify code of `generate_workbench_files', `generate_descriptor_tables' and `generate_feature_table' so that most code is not duplicated. Protected `generate_feature_table' so that it is not generated when a class is precompiled.
Added `feature_of_feature_id' that in addition of looking in `feature_table' also look in `anchored_features/ and in `generic_features'.
Moved `assembly_info' from CLASS_C to CLASS_TYPE as two different generic derivation of a CLASS_C instance can be generated in two different assemblies.
Adapted code due to rename of `compiled' into `is_compiled'. Removed check statement as it was not a valid one as the generic parameter can be redefined into something else. Instead improved comments.
Added `assembly_info' and its corresponding set feature. Fixed `record_precompiled_class_in_system' so that it correctly handles external classes.
Use `extend' instead of `put_front', and `after' instead of `off' on `types' from CLASS_C. This is due because in TYPE_LIST we reduced number of exported features.
Removed `merge' that was not used anymore since we removed multiple precompiled libraries. Updated creation of `types' since now its implementation is based on an ARRAYED_LIST instead of a LINKED_LIST.
Fixed code generation so that when a class is made `frozen' or has its frozen keyword removed, we update `types' from CLASS_C correctly in case we are performing some IL code generation.
Changed `feature_table_file_id' so that it works fine when there is no `types' associated with current class (this happens when you make a generic class visible in the Ace file and that this class is not part of your system). In this case we return `class_id' which is not good as if the classes are added to the system later, the feature table file will not be generated in the same directory as the code/descriptor files.
Removed SUPPLIER_CLASS as only its `supplier: CLASS_C' attribute was used. So instead of having `syntactical_suppliers' of type LINKED_LIST [SUPPLIER_CLASS] it is now of type ARRAYED_LIST [CLASS_C]. It improves the performance and reduces number of classes in system.
Changed some LINKED_LIST into ARRAYED_LIST for increased efficiency. Tests shows that we gain about 60s when finalizing the compiler (we went from 1425s to 1365s).
Replaced use of `+' by `|' for operation on `sk_exp' as sk constants are mask and it is more logical to use `|' for this type of operation rather than `+' eventhough the effect is the same.
Added first implementation of `is_generated' to show a class that needs to be generated in IL code generation, i.e. not a precompiled class, nor an external one. It is the first implementation because in the future we will have Eiffel classes in other .NET assemblies and we will need to refine this feature.
Renamed IL_INHERIT_ERROR into VIFI.
Removed non-used attributes: pass2_done, hidden, hide_implementation.
Removed `dispose_feature' as it is not used.
Name of anchors are now using the system name from where they come from as it is important in the future to distinguish from different Eiffel assemblies.
Fixed bugs in new IL code generation of anchored types. We are now using `type_set' local to Current rather than `SYSTEM_I.type_set' so that we minimize the code generation by only generating a TYPE_FEATURE_I when needed in current class, not because some descendant class needed it. Now names of anchored TYPE_FEATURE_I is `_type_XX' where XX is the routine ID, there is no need to bound them to the class name as .NET will do an automatic merge at the level of interfaces providing the same feature with the same signature.
Fixed a bug in `formal_at_position' because we were not saving the cursor position of `generic_features' and we are doing traversal within traversal. (Found by trying to generate the ACTION_SEQUENCE and because of the recent addition of proper implementation of `generate_type_feature' in IL_CODE_GENERATOR when handling generic classes).
Now use HASH_TABLE as it offers the same functionality as EXTEND_TABLE did. Removed replication classes as it has never been implemented completely and because it is likely that if we implement it, we would do it differently. Reimplemented `default_rescue_feature' in a more efficient way. Renamed local variable of `pass3' to simplify code comprehension. Cosmetics Added some pre/post-conditions. Renamed FORMAL_ATTRIBUTE_I into TYPE_FEATURE_I. Added `update_anchors' used during IL code generation to manage anchored types.
Renamed `a_class' into `current_class' and `a_feature' into `current_feature' in AST_CONTEXT. Updated to use new creation procedure `make' from CL_TYPE_I.
Added management of formal generic parameter both for the ones defined in current class and the ones defined in parent classes. This is used for full genericity in IL generation, but we might want use it for normal eiffel as it simplify the code for generic conformance. Simplified and speed up `default_create_feature' by using `feature_of_rout_id' from FEATURE_TABLE. Improved post-condition of `is_generic'. Inherited from DEBUG_OUTPUT so that we can see in the EiffelStudio debugger the `name' along with the `class_id'. Small cosmetics.
In `feature_named' added precondition to ensure that argument is at lest not void. Protected `feature_named' not to search for a feature is the searched name is empty.
Since we can't know if a CLASS_C contains some C++ externals, we try first to delete the .c file, if we do not succeed we try the .cpp file.
Replaced `empty_body' by `is_empty'.
Added `is_generic' and used it in preconditions.
Added supports multiple inheritance for IL code generation.
Use `set_feature_name_id' from FEATURE_DEPENDANCE instead of `set_feature_name' due to recent changes in FEATURE_DEPENDANCE to keep the feature_name_id instead of the feature_name.
Changed `changed_features' to be a SEARCH_TABLE of INTEGER instead of STRING. Updated `insert_changed_feature' accordingly to accept an integer instead of a STRING. Instead of using "_inv_" has an hard-coded name for invariants in feature dependence we are now using the `feature_name' of `INVARIANT_FEAT_I' which is "_invariant". Updated hard-coded "_inv_" in commented code to "_invariant".
Use constants defined in NAMES_HEAP instead of manifest strings to represent a feature name.
Fixed various typos.
Merged branch `dev46_manu' to the trunc.
Added C++ protection code to the descriptor and feature tables C files, otherwise when they are compiled in C++ mode, it does not work anymore.
Create an empty conformance table at the beginning. It will be created when necessary. New generation of C files which does not make use of D and F directories. This has been done to improve the performance of the C compilation, especially when using `quick_finalize'. Now, all the files corresponding to one class are generated in the same C directory, therefore when you modify one class you only have to recompile one C directory and not 3 as it used to be.
Fixed a bug in the backup mechanism when used with the new lace `all' option in front of the cluster name.
For some reasons, we were checking twice the local variables names against the feature of the current classes. Now, we will do it only one: by default we will do it in `type_check' of FEATURE_I, if it is not called we call `check_local_names'.
Since `forth' cannot be used when we are `after' and also because we really want to be at the end of the list, we use `finish' instead. This adds a small overhead but that really works with contracts `on'.
Improvement regarding the finalization process when the user choose to include a precompiled library in its Ace file. The only limitation of the current implementation is that all the classes added by the user will be in the system and also there is no good topological sort on the full system but a topological sort on all the parts of the system (precompiled parts + non precompiled part).
Added a function which removes the associated C file to a class that we are going to remove. Add the generation of the `finished' file for the makefile. In most of the case the `finished' file are created by the makefile and removed by the compiler (done here).
Fixed a typo in comment
Fixed a bug with the new default create mechanism where the `default_create' procedure was called even if it has an empty body.
Modified completeley the validity checking of the constraint part of a generic class. Before, it was not able starting from scratch to detect invalid use of creation constraint clause, now it is. Fixed a bug of command/query separation for `check_constraints' defined in TYPE_A. The remaining problems are a missing incrementallity check when someone changes the creation clause of a class used as a generic parameter of a generic class.
Implementation of the new default_create mechanism. In SYSTEM_I changed the run-time licensing number.
The Eiffel parser is now wrapped in an Eiffel class and accessed by inheriting from SHARED_EIFFEL_PARSER. Fixed bug due the fact that CONSTRUCT_LIST now inherits from ARRAYED_LIST instead of FIXED_LIST.
bug fix: the dependencies were not updated correctly: each time you touched a function it appeared one more time as a client of the functions it was client of.
Fixed some problems related to the use of expanded types in generic parameter or with simple expanded types: - Fixed the byte code generation - Changed the skeleton to handle correctly expanded type as a generic parameter - Changed the attribute description to match the new skeleton - Propagation of the expanded information (which was not done before, especially with inheritance) - Changed the make routine of the TO_SPECIAL class so that it handles correctly an expanded type.
in melt_all, add an update for the DEPEND_SERVER. It is a bug fix for the dead code removal: while using precompiled library with generic classes all the body_ids are updated for the generic classes but they were not in the keys of the depend server
Fixed a bug with `default_rescue' and breakpoints. When there is a default rescue we need to generate the byte code which corresponds to it, but we cannot set a breakpoint in it.
bug fix in pass3: when recomputing the invariant, f_suppliers took the suppliers of the last feature treated when it should become Void.
API/interface/e_feature.e eiffel/AST/clickable/class_type_as.e eiffel/AST/expressions/binary_as.e eiffel/AST/expressions/un_strip_as.e eiffel/AST/expressions/unary_as.e eiffel/AST/skeleton/access_address_as.e eiffel/AST/skeleton/access_feat_as.e eiffel/AST/skeleton/bits_symbol_as.e eiffel/AST/skeleton/id_as.e eiffel/AST/skeleton/like_id_as.e eiffel/AST/skeleton/precursor_as.e eiffel/byte_code/feature_b.e eiffel/compiler/array_optimizer.e eiffel/compiler/class_dependance.e eiffel/compiler/depend_unit.e eiffel/compiler/feat_iterator.e eiffel/compiler/feature_dependance.e eiffel/compiler/feature_table.e eiffel/compiler/remover.e eiffel/compiler/select_table.e eiffel/generation/attr_entry.e eiffel/generation/entry.e eiffel/generation/poly_table.e eiffel/generation/rout_entry.e eiffel/generation/special_entry.e eiffel/inheritance/inherit_table.e eiffel/interface/attribute_i.e eiffel/interface/class_c.e eiffel/interface/external_i.e eiffel/interface/feature_i.e eiffel/interface/system_i.e eiffel/server/depend_server.e New dead code removal: the old dead code removal was going through the FEATURE_I of the system in a non-linear way which took a very long time since the FEATURE_I are not very fast to be retrieved (We were retrieving them through the FEATURE_TABLE). Now, the algorythm is basically the same, we go through the whole system marking the features alive and then their dependances, but we transfered the usefull information for the algorithm in the dependances themselves making it a more compact information to retrieve. Thus we had also to update all the calls to the feature dependances in the system.
Improved traversal speed of FIXED_LIST `parents' and `generics' by using `area' and local variables.
Cosmetics Changed a sequence clone, wipe_out of the cloned object by reference copy and create a new object.
Changed the C generation so that it generates into a string buffer first, and the it writes the content of the buffer into a file.
Due to the unification of the `melted_set', `freeze_set1' and `freeze_set2' lists in `melted_set' we need to mark the classes of `melted_set' with some flags which enable us to know what we need to generate at degree -1. I.e. should we generate the descriptor tables?, the C code? Changed the algorithm for the check of `conform_to' in positive degrees. Use an array `conf_dep_table' to speed up the search.
Use of the new `melted_set' list. We don't use anymore `freeze_set1' and `freeze_set2'. Merged some features into one: - melt_feature_table and melt_descriptor_tables - generate_feature_table and genrate_descriptor_tables Add `simple_conform_to' which is a version of `conform_to' without checking, this is very useful when you don't need to check if the conformance has been recorded (for example in final mode, where you can save 50%).
Replaced all the occurences to the old AST *_AS_B by *_AS.
Add a protection in a loop of `mark_all_used' which has been previously removed. Add a local variable to speed up the access on an attribute
Changes due to the removal of E_CLASS.
Added a new check for the creation constraint at the end of degree 4 We now inherit from HASHABLE so that we can put CLASS_C objects in a HASH_TABLE. The `hash_code' is the hash_code of the `id'
Speed up the extension of the list with `forth'
Change `create' into `create_dir' to conform to the new DIRECTORY class.
Removed DLE from the compiler. This implies some code removing and small changes to the code so that it won't include any DLE specific classes
Fixed a problems which can occurs in `remove_dep_class', we need to position the list at the beginning. Cosmetics: added semicolon between features parameters.
Cosmetics Changes to conform to the new type of `freeze_set1', `freeze_set2' and `melted_set' in SYSTEM_I Moved the traversals of the `types' list into the class TYPE_LIST Improved the access on the Rep_depend servers.
Changed the implementation of some features to fix a bug in the incrementality at degree 3. Changed the implementation of `remove_dep_class'. Changed some calls to `set_freeze' to conform to the new signature. Cosmetics Changed the way how to generate the constraint_error_list for the new check_constraints implementation Changed the way to traverse a list by using `cursor' instead of `index'
Cosmetics (Removed semicolon) Removed one unused feature in class_c
Final changes to the new FIXED_LIST in CLASS_C Cosmetics Fixed a problem with is_equal from UNIVERSE_I
Removed the MELT_ONLY stuff since we have now one version of the compiler.
Cancellation of Manu's change of pass4 feature
Did some improvements over the speed of the code. Removed useless local variable Improve the speed of many loops
Cosmetics Adaptation to the new FIXED_LIST Changed the parameter name `precursor' since it is now a keyword Removed an inheritance Fixed the inheritance removal bug
Added default_rescue stuff. Cosmetics.
Back to old ebase.
Changed corresponding to the new HASH_TABLE.
fixed a bug in CEC when a feature's parameter's separate status is changed, the corresponding callers' codes should be automatically melted.
new SEPARATE level for visible: all features are in the table (even if they are not exported)
extra protection if class has been removed
integration problem fixed
bug fix: check if creatable before backup (ace file)
unique processing modified
E_CLASS indirection removed class_name => name in CLASS_C (comig from E_CLASS)
incrementality on separate status classes used as separate are visible automatically
bug fix: if class is separate, call to `set_has_separate' in SYSTEM_I
optimization: `is_equal' called on IDs instead of `equal'
optimization
generation of descriptors is not done during merging anymore
Concurrent Eiffel
setting of `is_expanded' and `is_deferred' in E_CLASS
implementation of `is_separate'
new routine `merge' (multiple precompilation)
new routine: `generate_precomp_descriptor_tables' (generation of precompiled descriptors)
server ids are of type IDABLE (instead of INTEGER) `trace' implemented in COMPILER_ID DLE: code reorganization
new abstractions for system counters (body id, body_index)
new abstractions for system counters (class ids and type ids)
bug fix: rout_id comparison
new abstractions for system counters (only ROUTINE_ID so far)
obsolete abstraction added in E_CLASS `signature' and `append_name' removed (use E_CLASS instead) errors using E_CLASS instead of CLASS_C
new routine: `recompile_syntactical_clients'
bug fix (dle): `make' from DYNAMIC classes and descendents marked
different output routines
implementation of the API Once `Compilation_modes' stores the current mode
cosmetics new mechanism for $f: automatic freezing to generate encapsulation
trace implementation profiling implementation
implementation of the automatic backup mechanism for debugging incrementality bugs
hide option implementation
case reverse engineering
dle
abstract parser: <type> => <type_B>
bug fix: remover_off doesn't mean keep assertions
optimization (unused local)
optimization: use of local
`path' removed from PATH_NAME
PATH_NAME stuff `melt_only' is now in SHARED_MELT_ONLY
PLAIN_TEXT_FILE => RAW_FILE
new semantic of $
FIXME removed (explanation in comments) lower case for file names (DOS)
cosmetics
case stuff
fixme comment added
code generation in several subdirectories
compare_objects done at creation time
case stuff
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
*** empty log message ***
Obsolete
*** empty log message ***
`recompile: BOOLEAN' set: for pass1 recompilation:
class_id replaced by topopological_id Ability to change root class class removal
Bug correction. A feature involved in an error message is not necessarily in the TMP server.
*** empty log message ***
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.
| ViewVC Help | |
| Powered by ViewVC 1.1.23 |