-- This file is part of SmartEiffel The GNU Eiffel Compiler.
-- Copyright (C) 1994-2002 LORIA - INRIA - U.H.P. Nancy 1 - FRANCE
-- Dominique COLNET and Suzanne COLLIN - SmartEiffel@loria.fr
-- http://SmartEiffel.loria.fr
-- SmartEiffel is free software; you can redistribute it and/or modify it
-- under the terms of the GNU General Public License as published by the Free
-- Software Foundation; either version 2, or (at your option) any later
-- version. SmartEiffel is distributed in the hope that it will be useful,but
-- WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
-- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
-- for more details. You should have received a copy of the GNU General
-- Public License along with SmartEiffel; see the file COPYING. If not,
-- write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-- Boston, MA 02111-1307, USA.
--
class SMART_EIFFEL
--
-- Singleton object to handle general purpose information about the
-- SmartEiffel global compilation process. (This singleton is shared via
-- the GLOBALS.`smart_eiffel' once function.)
--
inherit GLOBALS
feature
copyright: STRING is "[
SmartEiffel The GNU Eiffel Compiler, Eiffel tools and libraries
Release 1.0 (Friday December 6th 2002)
Copyright (C), 1994-2002 - LORIA - UHP - INRIA - FRANCE
Dominique COLNET and Suzanne COLLIN - SmartEiffel@loria.fr
http://SmartEiffel.loria.fr
]"
status: INTEGER
-- The compilation process reach different `status' which are
-- described below. Note: at time being, `status' are simply
-- numbered because I don't have yet a precise idea for
-- appropriate names.
--
-- 0 `status': live code gathering has just started but is not yet
-- finished. At this time we are not aware of all types which may
-- be created at run-time.
-- 1 `status': falling-down process has just started. During this
-- process, all call sites are considered again in order to know
-- more about effective definitions of deferred features or
-- redefinitions. At this time, because new code may be
-- considered, we are not aware of all types which may be created
-- at run-time.
-- 2 `status': after-falling-down process has just started. The goal
-- of this step is to finish the complete computation of the
-- actual set of live types. At the end of this process, all live
-- types are known and all source files should be loaded.
-- 3 `status': whole system analysis for the final safety check has
-- just started but is not yet finished.
-- 4 `status': the system is _not_ type safe (i.e. some dangerous
-- covariant redefinitions are used and the user has got
-- warnings).
-- 5 `status': the safety check test has not been performed
-- (because of the compilation mode for example), so, we do not
-- know if the system is safe or not.
-- 6 `status': whole system analysis is finished and the system is
-- type safe! Great!
is_ready: BOOLEAN is
do
Result := status.in_range(4,6)
end
short_flag: BOOLEAN
-- True when command `short' is running.
pretty_flag: BOOLEAN
-- True when command `pretty' is running.
base_class(class_name: CLASS_NAME): BASE_CLASS is
-- Retrieve the good one into the `base_class_dictionary' or launch
-- the `eiffel_parser' if this class is not yet loaded.
-- (See also `loaded_base_class'.)
require
class_name /= Void
do
Result := base_class_dictionary.reference_at(class_name)
if Result = Void then
if no_file_for(class_name.to_string) then
create Result.face_class(class_name.to_string)
elseif eiffel_parser.is_running then
error_handler.append("Internal Error #1 in SMART_EIFFEL.")
error_handler.print_as_fatal_error
else
if ace.parser_buffer_for(class_name.to_string) then
Result := eiffel_parser.analyse_class(class_name)
check
Result /= Void
implies
base_class_dictionary.has(class_name)
end
end
if Result = Void then
error_handler.add_position(class_name.start_position)
error_handler.append("Unable to load class %"")
error_handler.append(class_name.to_string)
error_handler.append("%".")
error_handler.print_as_fatal_error
end
end
end
check Result /= Void end
Result.obsolete_warning(class_name)
end
loaded_base_class(cn: CLASS_NAME): BASE_CLASS is
-- Retrieve the good one into the `base_class_dictionary'. When the
-- corresponding class `cn' is not yet loaded, the `eiffel_parser'
-- is _not_ launched and the Result is Void.
-- (See also `loaded_base_class'.)
do
Result := base_class_dictionary.reference_at(cn)
end
same_base_feature(up_rf: RUN_FEATURE; run_time_set: RUN_TIME_SET)
: BOOLEAN is
-- True when all `dynamic' features of the `run_time_set' have
-- excately the same final name and refer exactely to the same
-- `base_feature'.
require
is_ready and run_time_set.count > 1
local
i: INTEGER; f: E_FEATURE; dyn_rf: RUN_FEATURE; rc: RUN_CLASS
do
from
Result := True
i := run_time_set.count
f := up_rf.base_feature
until
not Result or else i = 0
loop
rc := run_time_set.item(i)
dyn_rf := rc.dynamic(up_rf)
if f = dyn_rf.base_feature then
if dyn_rf.name.to_string /= up_rf.name.to_string then
Result := False
end
else
Result := False
end
i := i - 1
end
end
no_file_for(class_name: STRING): BOOLEAN is
require
class_name = string_aliaser.item(class_name)
do
if as_none = class_name then
Result := True
elseif as_tuple = class_name then
Result := True
elseif as_routine = class_name then
Result := True
elseif as_procedure = class_name then
Result := True
elseif as_function = class_name then
Result := True
elseif as_predicate = class_name then
Result := True
end
end
stupid_switch(t: E_TYPE; run_time_set: RUN_TIME_SET): BOOLEAN is
-- True when `t' drives exactely to the same `t.run_type' for all
-- element of the `run_time_set'.
require
is_ready
do
if run_time_set.count <= 1 then
Result := True
else
Result := t.stupid_switch(run_time_set)
end
end
generating_type_used: BOOLEAN
-- When GENERAL `generating_type' is used.
generator_used: BOOLEAN
-- When GENERAL `generator' is used.
deep_twin_used: BOOLEAN
-- When `deep_twin' support is necessary.
scoop: BOOLEAN
-- When some SCOOP functions are used. See scoop.html for details.
feature {RUN_CLASS, CREATE_TOOLS}
set_scoop is
do
scoop := True
end
feature {GC_HANDLER,C_PRETTY_PRINTER}
root_procedure: RUN_FEATURE_3
-- The root procedure of the system to compile.
feature {PRETTY}
re_load_class(bc: BASE_CLASS): BOOLEAN is
-- Try to re-parse the `bc' class to check that this newly created
-- class is syntactically correct.
require
bc /= Void
local
name: CLASS_NAME; new_class: like bc
do
name := bc.name
check
base_class_dictionary.has(name)
end
base_class_dictionary.remove(name)
if ace.parser_buffer_for(name.to_string) then
new_class := eiffel_parser.analyse_class(name)
end
Result := new_class /= Void
end
feature {BASE_CLASS}
add_base_class(bc: BASE_CLASS) is
require
bc /= Void
local
name: CLASS_NAME
do
name := bc.name
check
not base_class_dictionary.has(name)
end
base_class_dictionary.put(bc,name)
magic_count_increment
ensure
base_class_dictionary.has(bc.name)
end
feature {FINDER}
find_path_for(arg: STRING): STRING is
do
if ace.parser_buffer_for(arg) then
Result := parser_buffer.path
parser_buffer.release
end
end
feature {SHORT}
set_short_flag is
do
short_flag := True
end
feature {PRETTY}
set_pretty_flag is
do
pretty_flag := True
end
feature
bit_n_ref_is_nyi_error(p: POSITION) is
do
error_handler.add_position(p)
error_handler.append(
"Type %"reference BIT_N%" is not yet implemented.")
error_handler.print_as_error
end
run_class(t: E_TYPE): RUN_CLASS is
require
t.run_type = t
local
rtm: STRING
do
rtm := t.run_time_mark
Result := run_class_dictionary.reference_at(rtm)
if Result = Void then
create Result.make(t,rtm)
check
run_class_dictionary.has(rtm)
end
end
ensure
Result /= Void
end
base_class_count: INTEGER is
-- Total number of base class actually loaded.
do
Result := base_class_dictionary.count
end
compile_to_c is
-- Produce C code for `root_class'/`procedure'.
local
root_class, procedure: STRING; rc: RUN_CLASS
run_count, i: INTEGER; gc_flag: BOOLEAN
do
root_class := ace.root_class_name
procedure := ace.root_procedure_name
get_started(root_class,procedure)
if nb_errors = 0 then
check
root_procedure /= Void
end
cpp.get_started
cpp.swap_on_h
gc_flag := not gc_handler.is_off
-- ---------------------------------------------------------
if ace.boost then
cpp.put_string_on_h(once "#define SE_BOOST 1%N")
end
if ace.sedb then
cpp.put_string_on_h(once "#define SE_SEDB 1%N")
end
if gc_flag then
cpp.put_string_on_h(once "#define SE_GC_LIB 1%N")
end
if exceptions_handler.used then
cpp.put_string_on_h(once "#define SE_EXCEPTIONS 1%N")
end
if scoop then
cpp.put_string_on_h(once "#define SE_SCOOP 1%N")
end
-- ---------------------------------------------------------
if scoop then
cpp.sys_runtime_h_and_c(once "scoop")
cpp.sys_runtime_h_and_c(once "scoop_thread")
system_tools.add_lib_scoop
end
-- ---------------------------------------------------------
from
cpp.put_comment_line(once "C Header Pass 1 :")
agent_pool.c_header_pass1
update_run_class_map
i := run_class_map.upper
until
i < 0
loop
rc := run_class_map.item(i)
if rc.at_run_time then
run_count := run_count + 1
end
rc.c_header_pass1
i := i - 1
end
-- ---------------------------------------------------------
from
cpp.put_comment_line(once "C Header Pass 2 :")
update_run_class_map
i := run_class_map.upper
until
i < 0
loop
rc := run_class_map.item(i)
rc.c_header_pass2
i := i - 1
end
-- ---------------------------------------------------------
from
cpp.put_comment_line(once "C Header Pass 3 :")
update_run_class_map
i := run_class_map.upper
until
i < 0
loop
rc := run_class_map.item(i)
rc.c_header_pass3
i := i - 1
end
-- ---------------------------------------------------------
from
cpp.put_comment_line(once "C Header Pass 4 :")
update_run_class_map
i := run_class_map.upper
until
i < 0
loop
rc := run_class_map.item(i)
rc.c_header_pass4
i := i - 1
end
-- Force definition of T9 and T7 :
if not run_class_dictionary.has(as_native_array_character) then
cpp.put_string(once "typedef char* T9;%N")
if ace.no_check then
cpp.put_c_function(once "void se_prinT9(T9*o)",
once "printf(%"NATIVE_ARRAY[STRING]#%%p\n%",(void*)*o);")
end
end
once_manifest_string_pool.c_define1(string_at_run_time)
cpp.customize_runtime(sys_runtime_basic)
-- ---------------------------------------------------------
if gc_flag then
gc_handler.define1
end
-- ---------------------------------------------------------
compile_routines
cpp.cecil_define
-- ---------------------------------------------------------
cpp.define_main(root_procedure)
once_manifest_string_pool.c_define2(string_at_run_time)
compile_registered_for_c_define
address_of_pool.c_define
if gc_flag then
gc_handler.define2
end
manifest_array_pool.c_define
switch_collection.c_define
agent_pool.c_define_missing_agent_launcher
cpp.define_used_basics
if scoop then
separate_tools.generate_scoop_functions(run_class_map)
end
debug
echo.put_string(once "Very Final magic_count : ")
echo.put_integer(magic_count)
echo.put_character('%N')
end
cpp.write_make_file
very_last_information
else
error_handler.append("Cannot produce C code.")
error_handler.print_as_error
end
end
compile_to_jvm is
-- Produce Java Byte Code for `root_class'/`procedure'.
local
root_class, procedure: STRING
rc: RUN_CLASS
run_count, i: INTEGER
do
root_class := ace.root_class_name
procedure := ace.root_procedure_name
get_started(root_class,procedure)
if scoop then
not_yet_implemented
end
if nb_errors = 0 then
jvm.prepare_output_directory
from
update_run_class_map
i := run_class_map.upper
until
i < 0
loop
rc := run_class_map.item(i)
if rc.at_run_time then
run_count := run_count + 1
rc.compile_to_jvm
end
i := i - 1
end
echo.print_count(once "Used Type",run_count)
agent_pool.customize_jvm_runtime
jvm.write_jvm_root_class
jvm.write_main_class(root_procedure)
very_last_information
else
error_handler.append(once "Cannot produce Java Byte Code.")
error_handler.print_as_error
end
end
feature {NONE}
base_class_dictionary: DICTIONARY[BASE_CLASS,CLASS_NAME] is
-- When looking for a BASE_CLASS using the name of the base class
-- (ie. FOO[BAR] is stored at key "FOO").
once
create Result.with_capacity(1024)
end
feature
magic_count: INTEGER
-- Grow each time a new run class is added, each time a new
-- class is loaded, each time a new feature is checked,
-- each time ...
-- Thus when `magic_count' stops growing, we are really
-- ready to run :-).
feature {RUN_CLASS,RUN_TIME_SET,RUN_FEATURE,ASSERTION_COLLECTOR,SWITCH_COLLECTION}
magic_count_increment is
do
magic_count := magic_count + 1
end
feature {GC_HANDLER}
get_run_class_map: FIXED_ARRAY[RUN_CLASS] is
do
check
run_class_map.count = run_class_dictionary.count
end
Result := run_class_map
end
feature {RUN_CLASS}
run_class_dictionary: DICTIONARY[RUN_CLASS,STRING] is
once
!!Result.with_capacity(2048)
end
feature {BASE_CLASS,TYPE_BASIC_EIFFEL_EXPANDED}
run_class_for(cn: CLASS_NAME): RUN_CLASS is
-- Assume `cn' is a simple non generic class.
require
cn /= Void
local
bc: BASE_CLASS; type_class: TYPE_CLASS
do
Result := run_class_dictionary.reference_at(cn.to_string)
if Result = Void then
bc := base_class_dictionary.reference_at(cn)
if bc /= Void then
create type_class.make(bc.name)
Result := type_class.run_class
else
error_handler.append("SMART_EIFFEL Internal error for: ")
error_handler.append(cn.to_string)
error_handler.print_as_fatal_error
end
end
ensure
Result /= Void
end
feature {RUN_CLASS}
is_tagged(rc: RUN_CLASS): BOOLEAN is
require
is_ready
rc.at_run_time
rc.current_type.is_reference
ace.boost
local
i: INTEGER; run_time_set: RUN_TIME_SET
do
from
update_run_class_map
i := run_class_map.upper
until
Result or else i < 0
loop
run_time_set := run_class_map.item(i).run_time_set
if run_time_set.count = 0 then
elseif run_time_set.has(rc) then
Result := run_time_set.count > 1
end
i := i - 1
end
end
memory_class_used: BASE_CLASS is
-- The MEMORY class when used or Void when this class is not
-- in the live code.
local
cn: CLASS_NAME
do
create cn.unknown_position(as_memory)
Result := base_class_dictionary.reference_at(cn)
end
feature -- To add more Context for some `to_runnable' :
top_rf: RUN_FEATURE is
do
if not run_feature_stack.is_empty then
Result := run_feature_stack.last
end
end
push(rf: RUN_FEATURE) is
do
run_feature_stack.add_last(rf)
ensure
run_feature_stack.count = 1 + old (run_feature_stack.count)
end
pop is
do
run_feature_stack.remove_last
ensure
run_feature_stack.count = old (run_feature_stack.count) - 1
end
feature {NONE}
run_feature_stack: FIXED_ARRAY[RUN_FEATURE] is
-- The top-most one gives the current analysis context.
once
!!Result.with_capacity(50)
end
run_class_map: FIXED_ARRAY[RUN_CLASS] is
once
create Result.with_capacity(2048)
end
update_run_class_map is
do
if run_class_map.count /= run_class_dictionary.count then
run_class_map.clear
run_class_dictionary.item_map_in(run_class_map)
end
end
falling_down is
local
rc: RUN_CLASS; i: INTEGER; n: STRING; root_type: E_TYPE
sp: POSITION; type_reference: TYPE_REFERENCE
do
if generator_used then
type_string.set_at_run_time
end
address_of_pool.falling_down
agent_pool.falling_down
from
update_run_class_map
i := run_class_map.upper
until
i < 0
loop
rc := run_class_map.item(i)
n := rc.base_class_name.to_string
if no_file_for(n) then
-- No `falling_down' for NONE, TUPLE, ROUTINE, ...
else
type_reference ?= rc.current_type
if type_reference = Void then
rc.falling_down
elseif type_reference.expanded_type.is_integer then
rc.falling_down
if reference_integer_set = Void then
create reference_integer_set.make
end
reference_integer_set.add(rc)
end
end
i := i - 1
end
if reference_integer_set /= Void then
assignment_handler.force_compatibility(reference_integer_set)
end
if smart_eiffel.scoop then
root_type := root_procedure.current_type
if not root_type.is_separate then
-- SCOOP needs the root object to be separate.
sp := root_type.start_position
root_type := separate_tools.create_type_separate(sp,
root_type)
root_type := root_type.to_runnable(type_any)
root_procedure ?=
root_type.run_class.get_feature(root_procedure.name)
check
root_procedure /= Void
end
end
end
end
afd_check is
local
rc: RUN_CLASS; i: INTEGER
do
from
update_run_class_map
i := run_class_map.upper
until
i < 0
loop
rc := run_class_map.item(i)
rc.afd_check
i := i - 1
end
cecil_pool.afd_check
end
very_last_information is
do
assignment_handler.echo_information
inspect
status
when 4 then
error_handler.append("The system is not type safe (read previous %
%warnings carefully.)")
error_handler.print_as_warning
when 5 then
echo.put_string("Type-system safety check not performed in %
%this mode (use flag -safety_check).%N")
when 6 then
echo.put_string("The system is type safe.%N")
end
eiffel_parser.show_nb_warnings
eiffel_parser.show_nb_errors
echo.put_string(fz_02)
end
feature {RUN_FEATURE_9}
afd_check_deferred(rf9: RUN_FEATURE_9) is
do
if not rf9_memory.fast_has(rf9) then
rf9_memory.add_last(rf9)
end
end
feature {NONE}
rf9_memory: FIXED_ARRAY[RUN_FEATURE_9] is
once
!!Result.with_capacity(1024)
end
check_for_deferred is
local
i: INTEGER
rf9: RUN_FEATURE
rc: RUN_CLASS
do
from
i := rf9_memory.upper
echo.print_count(once "Deferred Routine",i+1)
until
i < 0
loop
rf9 := rf9_memory.item(i)
rc := rf9.current_type.run_class
if rc.at_run_time then
error_handler.append(rf9.name.to_string)
error_handler.append(once " is a deferred feature in ")
error_handler.append(rf9.current_type.written_mark)
warning(rf9.start_position,fz_dot_blank)
end
i := i - 1
end
end
check_generic_formal_arguments is
local
i: INTEGER
do
from
i := 1
until
i > base_class_dictionary.count
loop
base_class_dictionary.item(i).check_generic_formal_arguments
i := i + 1
end
end
feature {ID_PROVIDER}
id_extra_information(tfw: TEXT_FILE_WRITE; name: STRING) is
local
bc: BASE_CLASS; rc: RUN_CLASS; path: STRING; cn: CLASS_NAME
do
if name = as_none then
else
rc := run_class_dictionary.reference_at(name)
if rc /= Void then
bc := rc.base_class
else
create cn.unknown_position(name)
bc := base_class_dictionary.reference_at(cn)
end
end
tfw.put_character('%N')
if bc /= Void then
tfw.put_string(once "class-path: %"")
path := bc.path
tfw.put_string(path)
tfw.put_character('%"')
tfw.put_character('%N')
bc.id_extra_information(tfw)
end
if rc /= Void then
rc.id_extra_information(tfw)
end
end
feature {CALL_PROC_CALL}
covariance_check(call_site: POSITION; up_rf: RUN_FEATURE
run_time_set: RUN_TIME_SET) is
require
not call_site.is_unknown
up_rf.arguments.count >= 1
not run_time_set.is_empty
local
dyn_rf: RUN_FEATURE; up_args, dyn_args: FORMAL_ARG_LIST;
r, a: INTEGER; t1, t2: E_TYPE
do
from
r := 1
up_args := up_rf.arguments
until
r > run_time_set.count
loop
dyn_rf := run_time_set.item(r).dynamic(up_rf)
from
a := 1
dyn_args := dyn_rf.arguments
until
a > up_args.count
loop
t1 := up_args.type(a)
t2 := dyn_args.type(a)
if t1.run_time_mark /= t2.run_time_mark then
error_handler.add_position(call_site)
error_handler.append(
"Unsafe covariant redefinition (type %"")
error_handler.append(t1.run_time_mark)
error_handler.append("%" redefined as %"")
error_handler.append(t2.run_time_mark)
error_handler.append("%").")
error_handler.add_position(t1.start_position)
error_handler.add_position(t2.start_position)
error_handler.print_as_warning
status := 4
end
a := a + 1
end
r := r + 1
end
end
feature {CALL_PROC_CALL,PRECURSOR_CALL,CREATE_TOOLS,E_AGENT}
argument_passing_check(call_site: POSITION
arguments: EFFECTIVE_ARG_LIST
rf: RUN_FEATURE) is
-- Check if argument passing at `call_site' position is valid or
-- not. This verification is here (i.e. not in class
-- EFFECTIVE_ARG_LIST or in class FORMAL_ARG_LIST) because
-- `arguments' or/and `formal_arg_list' may be both Void.
require
not call_site.is_unknown
rf /= Void
local
i: INTEGER; formal_arg_list: FORMAL_ARG_LIST
do
formal_arg_list := rf.arguments
if arguments = Void then
if formal_arg_list /= Void then
error_handler.add_position(call_site)
error_handler.add_position(formal_arg_list.start_position)
error_handler.append("The feature called has ")
i := formal_arg_list.count
error_handler.append_integer(i)
error_handler.append(" argument")
if i > 1 then
error_handler.extend('s')
end
error_handler.append(". (The actual argument list is empty.)")
error_handler.print_as_fatal_error
end
elseif formal_arg_list = Void then
error_handler.add_position(rf.start_position)
error_handler.add_position(arguments.start_position)
error_handler.append("There ")
i := arguments.count
if i > 1 then
error_handler.append("are ")
else
error_handler.append("is ")
end
error_handler.append_integer(i)
error_handler.append(" actual argument")
if i > 1 then error_handler.extend('s') end
error_handler.append(". (The feature found has no argument.)")
error_handler.print_as_fatal_error
else
arguments.match_with(rf)
end
end
feature {C_PRETTY_PRINTER}
define_extern_tables is
require
cpp.on_c
local
size: INTEGER
do
size := id_provider.max_id + 1
cpp.macro_def(once "SE_MAXID",size)
if generator_used then
cpp.put_extern4(fz_t7_star,once "g",size)
end
if generating_type_used then
cpp.put_extern4(fz_t7_star,once "t",size)
end
if ace.no_check then
cpp.put_extern4(once "char*",once "p",size)
c_code.copy(once "void(*se_prinT[")
size.append_in(c_code)
c_code.append(once "])(void**)")
cpp.put_extern1(c_code)
end
end
initialize_path_table is
require
ace.no_check
cpp.on_c
local
i, id: INTEGER; bc: BASE_CLASS; rc: RUN_CLASS
do
from
cpp.put_string(once "p[0]=%"???%";%N")
i := 1
until
i > base_class_dictionary.count
loop
bc := base_class_dictionary.item(i)
id := bc.id
if id > 0 then
cpp.put_string(once "p[")
cpp.put_integer(id)
cpp.put_string(once "]=")
cpp.put_string_c(bc.path)
cpp.put_string(fz_00)
end
i := i + 1
end
from
update_run_class_map
i := run_class_map.upper
until
i < 0
loop
rc := run_class_map.item(i)
if rc.at_run_time then
cpp.put_string(once "se_prinT[")
cpp.put_integer(rc.id)
cpp.put_string(once "]=((void(*)(void**))se_prinT")
cpp.put_integer(rc.id)
cpp.put_string(once ");%N")
if rc.current_type.is_generic then
cpp.put_string(once "p[")
cpp.put_integer(rc.id)
cpp.put_string(once "]=p[")
cpp.put_integer(rc.base_class.id)
cpp.put_string(once "];%N")
end
end
i := i - 1
end
ensure
cpp.on_c
end
initialize_generator is
require
cpp.on_c
local
i, id: INTEGER; bc: BASE_CLASS; rc: RUN_CLASS
do
from
i := 1
until
i > base_class_dictionary.count
loop
bc := base_class_dictionary.item(i)
id := bc.id
if id >= 0 then
cpp.put_array1('g',id)
cpp.put_character('=')
cpp.put_se_string(bc.name.to_string)
cpp.put_string(fz_00)
end
i := i + 1
end
from
update_run_class_map
i := run_class_map.upper
until
i < 0
loop
rc := run_class_map.item(i)
if rc.at_run_time then
bc := rc.base_class
if bc.name.to_string /= rc.current_type.run_time_mark then
cpp.put_array1('g',rc.id)
cpp.put_character('=')
cpp.put_array1('g',bc.id)
cpp.put_string(fz_00)
end
end
i := i - 1
end
ensure
cpp.on_c
end
initialize_generating_type is
require
cpp.on_c
local
i: INTEGER; rc: RUN_CLASS; bc: BASE_CLASS; rtm: STRING
do
from
update_run_class_map
i := run_class_map.upper
until
i < 0
loop
rc := run_class_map.item(i)
if rc.at_run_time then
cpp.put_array1('t',rc.id)
cpp.put_character('=')
bc := rc.base_class
rtm := rc.current_type.run_time_mark
if bc.name.to_string /= rtm then
cpp.put_se_string(rtm)
else
cpp.put_array1('g',rc.id)
end
cpp.put_string(fz_00)
end
i := i - 1
end
ensure
cpp.on_c
end
feature {RUN_FEATURE_3}
register_for_c_define(rf: RUN_FEATURE_3) is
require
rf /= Void
do
registered_for_c_define.add_last(rf)
end
feature {RUN_FEATURE_7, RUN_FEATURE_8, AGENT_POOL}
register_sys_runtime_basic_of(name: STRING) is
-- Add some SmartEiffel/sys/runtime/basic_* package as
-- an already used one in order to customize the runtime.
require
name.has_prefix("basic_")
local
package: STRING
do
from
package := once "basic_...................."
package.copy(name)
until
package.occurrences('_') = 1
loop
package.remove_last(1)
end
if not sys_runtime_basic.has(package) then
package := package.twin
sys_runtime_basic.add(package)
end
end
feature {RUN_CLASS}
set_deep_twin_used is
do
deep_twin_used := True
end
reference_to_separate(source_type: E_TYPE) is
require
source_type.is_reference
local
i: INTEGER
rc: RUN_CLASS
type: E_TYPE
do
from
update_run_class_map
i := run_class_map.upper
until
i < 0
loop
rc := run_class_map.item(i)
type := rc.current_type
if type.is_separate then
if type.is_a(source_type) then
type := type.actual_separate(source_type)
rc := type.run_class
if not rc.at_run_time then
rc.set_at_run_time
source_type.run_class.falling_down
end
else
error_handler.cancel
end
end
i := i - 1
end
end
feature {RUN_FEATURE_8}
set_generating_type_used is
do
generating_type_used := True
end
set_generator_used is
do
generator_used := True
end
feature {CLUSTER}
parse_include(include_name: STRING) is
require
include_name /= Void
local
bc: BASE_CLASS
do
check parser_buffer.is_ready end
echo.put_string(once "Handling include of %"")
echo.put_string(include_name)
echo.put_string(once "%" from ACE file. (Parsing %"")
echo.put_string(parser_buffer.path)
echo.put_string(once "%".)%N")
bc := eiffel_parser.analyse_buffer
check
bc /= Void
implies
base_class_dictionary.has(bc.name)
end
end
feature {NONE}
sys_runtime_basic: SET[STRING] is
-- Actually used packages of SmartEiffel/sys/runtime.
-- For example: basic_directory, basic_time, basic_*, etc.
once
!!Result.make
end
string_at_run_time: BOOLEAN is
require
is_ready
local
rc: RUN_CLASS
do
if run_class_dictionary.has(as_string) then
rc := run_class_dictionary.at(as_string)
Result := rc.at_run_time
end
end
get_started(root_class_name, root_procedure_name: STRING) is
-- Get started to compile using creation procedure `root_procedure_name'
-- of base class `root_class_name'.
require
not root_class_name.is_empty
not root_procedure_name.is_empty
local
sfn: FEATURE_NAME; root: BASE_CLASS; root_proc: E_PROCEDURE
root_type: E_TYPE; magic: INTEGER; root_name: CLASS_NAME
do
if ace.no_check then
set_generator_used
set_generating_type_used
end
ace.parse_include
create root_name.unknown_position(root_class_name)
root := base_class(root_name)
if root = Void then
error_handler.append("Cannot load root class ")
error_handler.append(root_class_name)
error_handler.append(fz_dot_blank)
error_handler.print_as_error
elseif root.is_expanded then
error_handler.add_position(root.name.start_position)
error_handler.append("The root class must not be expanded (sorry, but%
%this is a limitation of the compiler).")
error_handler.print_as_fatal_error
else
sfn := root.root_creation_search(root_procedure_name)
root_proc := root.root_procedure_check(sfn)
end
if nb_errors = 0 then
if root_proc.arguments /= Void then
error_handler.add_position(root_proc.start_position)
error_handler.append("Creation procedure must not have arguments.")
error_handler.print_as_fatal_error
end
end
if nb_errors = 0 then
root_type := run_class_for(root.name).current_type
end
if nb_errors = 0 then
root_procedure := root_proc.to_run_feature(root_type,sfn)
end
if nb_errors = 0 then
cecil_pool.fill_up
check status = 0 end
status := 1
echo_magic_count(once "Starting Falling Down")
if scoop then
echo.put_string(once "(SCOOP target verification activated)%N")
end
from
falling_down
until
magic = magic_count or else nb_errors > 0
loop
magic := magic_count
falling_down
end
echo_magic_count(once "End of Falling Down")
end
if nb_errors = 0 then
check status = 1 end
status := 2
echo_magic_count(once "Starting AFD Check")
from
afd_check
until
magic = magic_count or else nb_errors > 0
loop
magic := magic_count
afd_check
end
check_for_deferred
check_generic_formal_arguments
echo_magic_count(once "Before conversion handling")
assignment_handler.finish_falling_down
echo_magic_count(once "After conversion handling")
from
until
magic = magic_count or else nb_errors > 0
loop
echo_magic_count(once "Extra falling-down")
magic := magic_count
falling_down
afd_check
end
echo_magic_count(once "End of AFD Check")
end
if not error_handler.is_empty then
error_handler.append(
"Internal Warning #1 (Error Handler Not Empty): ")
error_handler.print_as_warning
end
if nb_errors = 0 then
safety_check
echo.print_count(once "Loaded Classe",
base_class_dictionary.count)
end
ensure
nb_errors = 0 implies root_procedure /= Void
end
compile_routines is
-- Try to give the best order to the C output.
require
root_procedure.set_is_root
local
rc, rc_string: RUN_CLASS; ct: E_TYPE; deep, i: INTEGER
stop: BOOLEAN; bcn: STRING
do
echo.put_string(once "Compiling/Sorting routines for ")
echo.put_integer(run_class_dictionary.count)
echo.put_string(once " run classes :%N")
cpp.swap_on_c
from
update_run_class_map
i := run_class_map.upper
until
i < 0
loop
rc := run_class_map.item(i)
ct := rc.current_type
if ct.is_basic_eiffel_expanded then
rc.compile_to_c(0)
elseif ct.is_string then
rc_string := rc
end
i := i - 1
end
from
update_run_class_map
i := run_class_map.upper
until
i < 0
loop
rc := run_class_map.item(i)
ct := rc.current_type
if ct.is_bit then
rc.compile_to_c(0)
end
i := i - 1
end
from
update_run_class_map
i := run_class_map.upper
until
i < 0
loop
rc := run_class_map.item(i)
bcn := rc.base_class_name.to_string
if as_native_array = bcn then
rc.compile_to_c(0)
end
i := i - 1
end
if rc_string /= Void then
rc_string.compile_to_c(0)
end
from
update_run_class_map
i := run_class_map.upper
until
i < 0
loop
rc := run_class_map.item(i)
ct := rc.current_type
bcn := ct.base_class_name.to_string
if as_array = bcn or else as_fixed_array = bcn then
rc.compile_to_c(0)
end
i := i - 1
end
from
update_run_class_map
i := run_class_map.upper
until
i < 0
loop
rc := run_class_map.item(i)
ct := rc.current_type
if ct.is_generic then
rc.compile_to_c(0)
end
i := i - 1
end
from -- General sorting:
deep := 6
until
stop
loop
from
stop := True
update_run_class_map
i := run_class_map.upper
until
i < 0
loop
rc := run_class_map.item(i)
if not rc.compile_to_c_done then
stop := False
rc.compile_to_c(deep)
end
i := i - 1
end
deep := deep - 1
end
end
c_code: STRING is
once
!!Result.make(128)
end
registered_for_c_define: FIXED_ARRAY[RUN_FEATURE_3] is
once
!!Result.with_capacity(512)
end
compile_registered_for_c_define is
local
i: INTEGER
do
from
i := registered_for_c_define.upper
until
i < 0
loop
registered_for_c_define.item(i).c_define_or_scoop_define
i := i - 1
end
end
safety_check is
-- Start final whole system analysis to decide whether this
-- system is safe or not.
require
status = 2
local
old_magic_count, i: INTEGER; do_it: BOOLEAN; rc: RUN_CLASS
do
debug
old_magic_count := magic_count
end
do_it := ace.safety_check
if do_it then
status := 6
echo_magic_count(once "Starting type safety check")
from
update_run_class_map
i := run_class_map.upper
until
i < run_class_map.lower
loop
rc := run_class_map.item(i)
if rc.at_run_time then
rc.safety_check
end
i := i - 1
end
else
status := 5
end
debug
check
old_magic_count = magic_count
end
end
ensure
status.in_range(4,6)
end
echo_magic_count(msg: STRING) is
require
msg /= Void
do
echo.put_string(msg)
echo.put_string(once " (magic_count = ")
echo.put_integer(magic_count)
echo.put_string(once ").%N")
end
reference_integer_set: SET[RUN_CLASS]
singleton_memory: SMART_EIFFEL is
once
Result := Current
end
invariant
status.in_range(0,6)
is_real_singleton: Current = singleton_memory
end -- SMART_EIFFEL