note name: "EIFFEL_SRC:[ES5SH]ES5SH.E" description: "System for converting Unix Makefile.SH files to VMS Makefile. files" author: "David Morgan" original: 01,Jan,1995 last: 22,Aug,1998 modified_by: "David Schwartz (davids), VMS diehard" Version: "V6.2-001" Date: "$Date$" Revision: "$Revision$" Id: "$Id$" Notes: "*** be sure to update pretty_version string in ES5SH_COMMON to match the Version here" -- -- working: -- -- changes for Eiffel 6.x -- update big_file generation (just make it a bunch of #includes), use .c for finalized (no more big_file*.x) -- -- changes for Eiffel 5.7.65176 -- -- put config file name into link.com (already in Makefile) -- add Makefile dependency: -- $(OBJECTS) :: Makefile -- -- -- Done: handle new gtk commands used in Eiffel 5.5.1126 INCLUDE_PATH and EXTERNALS macros: -- `$EIFFEL_SRC/library/vision2/implementation/gtk/Clib/vision2-gtk-config --devel --include_path` -- `$(EIFFEL_SRC)/library/vision2/implementation/gtk/Clib/vision2-gtk-config --devel --object` -- -- -- -- todo: -- -- evaluate EXTERNALS recursively so that a symbol like $ISE_PLATFORM will be replaced by the platform in link.com (instead of hard coding it in CONFIG.EIF file) -- -- use value_macro_SUBDIRS to generate dependent_subdirectories, rather than on the fly in process_subdirectory_rule -- -- -- working: process_agruments, -- process externals list to allow object, library, or option (done, needs testing) -- -- working: use ISE_PLATFORM with whatever definition -- as written, must use whatever is defined, not whatever is in Makefile -- *** I think this is not an issue, but I don't remember what it means *** -- -- -- -- class ES5SH inherit ES5SH_COMMON create make feature -- Initialization make -- convert makefiles taking into account config.eif file local l_finished_file: PLAIN_TEXT_FILE l_val, l_cwd: STRING l_make_cmd: STRING do start_date_time := current_date_time --print_output_message (<< pretty_version, " starting at ", start_date_time, "." >>) print (array_as_string (<< pretty_version, " starting at ", start_date_time, ".%N" >>)) -- -- check for -h (-help) argument; if found, display help message and ignore others. -- --if arguments_.argument_count >= 1 and then (arguments_.index_of_character_option ('?') > 0 -- if arguments_.argument_count >= 1 and then ( ("#/#/?#/h#/help#").has_substring ("#" + arguments_.argument(1) +"#") -- or else arguments_.index_of_character_option ('?') > 0 -- or else arguments_.index_of_character_option ('h') > 0 -- or else arguments_.index_of_word_option ("help") > 0 ) then -- will_process_makefiles := False -- print_help() -- else process_arguments() -- end if will_process_makefiles then print_output_message (<< " current working directory: ", execution_environment_.current_working_directory >>) debug ("nocompile") if will_perform_make then print_output_message (<< "DEBUG(nocompile): inhibiting C compilation." >>) will_perform_make := False end end -- debug -- determine values of ISE_EIFFEL, ISE_PLATFORM symbol_eiffel := "ISE_EIFFEL" value_eiffel := execution_environment_.get (symbol_eiffel) if is_nonblank (value_eiffel) then do_nothing else value_eiffel := execution_environment_.get ("EIFFEL5") if is_nonblank (value_eiffel) then symbol_eiffel := "EIFFEL5" print_warning_message ("ISE_EIFFEL is not defined; obsolete EIFFEL5 used.%N") else value_eiffel := execution_environment_.get ("EIFFEL4") if is_nonblank (value_eiffel) then symbol_eiffel := "EIFFEL4" print_warning_message ("ISE_EIFFEL is not defined; obsolete EIFFEL5 used.%N") else print_warning_message ("ISE_EIFFEL, EIFFEL5, EIFFEL4 are undefined.%N") value_eiffel := "" end end end value_eiffel_string := symbol_eiffel + "=" + value_eiffel if value_eiffel.is_equal (symbol_eiffel) or else value_eiffel.is_equal ("/" + symbol_eiffel) then -- if Eiffel 5.7 "hack" that returns getenv("foo") as "/foo") is in effect value_eiffel := execution_environment_.get_native (symbol_eiffel) value_eiffel_string.append (" (" + value_eiffel + ")") end value_platform := execution_environment_.get ("ISE_PLATFORM") debug ("windows") if value_platform.is_case_insensitive_equal ("windows") then value_platform := "VMSAlpha99" end end if value_platform = Void or else value_platform.is_empty then value_platform := execution_environment_.get("PLATFORM") if value_platform /= Void and then not value_platform.is_empty then print_warning_message ("ISE_PLATFORM is not defined; obsolete PLATFORM used.%N") else print_warning_message ("neither ISE_PLATFORM nor PLATFORM defined.%N") value_platform := "$(ISE_PLATFORM_undefined)" end end l_cwd := execution_environment_.current_working_directory l_val := as_vms_filespec (l_cwd) -- ***debug*** if value_platform.substring_index ("VMS", 1) > 0 and then not is_vms_filespec (l_cwd) then l_cwd := as_vms_filespec (l_cwd + "/") end l_val := as_vms_filespec (l_cwd) -- ***debug*** if base_directory = Void then create base_directory.make_from_string (l_cwd) --print ("debug: base_directory set to default: " + base_directory + "%N") elseif base_directory = Void then -- UNREACHABLE: save this code temporarily until I figure out what to do print_error_message ("UNREACHABLE executed!%N") l_val := execution_environment_.current_working_directory create base_directory.make_from_string (l_val) if value_platform.substring_index ("VMS", 1) > 0 and then not is_vms_filespec (base_directory) then l_val.append_character (operating_environment_.directory_separator) l_val := as_vms_filespec (l_val) create base_directory.make_from_string (as_vms_filespec(l_val)) l_val := as_vms_filespec (l_val) else end elseif is_relative_filespec (base_directory) then --AND THEN FALSE then --print (" debug: base_directory is_relative: " + base_directory + "%N") -- l_val := execution_environment_.current_working_directory -- create base_directory.make_from_string (execution_environment_.current_working_directory) -- if starts_with (l_val, "./") or else starts_with (l_val, ".\") then -- base_directory.extend (l_val.substring (3, l_val.count)) -- else -- base_directory.extend (l_val) -- end create base_directory.make_from_string (make_absolute_filespec (base_directory)) end --print (" debug: base_directory: " + printable_value (base_directory) + "%N") print_output_message (<< "Processing options: ", value_eiffel_string, ", ", symbol_platform, "=", value_platform >>) -- read configuration from configuration file if configuration_file_name = Void then -- check for logical name to specify configuration file l_val := execution_environment_.get ("ES5SH_CONFIG") if l_val /= Void and then not l_val.is_empty then create configuration_file_name.make_from_string (l_val) print_warning_message ("use of ES5SH_CONFIG logical name is deprecated, use -c %N") -- **TBS** do a VMS-style parse, using the value as the default name else -- platform specific configuration file name: ISE_EIFFEL:[studio.config.$(ISE_PLATFORM)]config.eif configuration_file_name := platform_specific_file_name (<<"studio","config">>, << >>, "config.eif") end end create configuration.make (configuration_file_name, Current) print_output_message (<< "Processing files in ", base_directory, " at ", current_time >>) process_makefiles print_output_message (<< "Processing complete at ", current_time >>) if will_perform_make then create l_finished_file.make ("complete.eif") l_make_cmd := configuration.item ("make") print_output_message (<< "Commencing C compilation -- MAKE = ", l_make_cmd >>) execution_environment_.system (l_make_cmd) if execution_environment_.return_code /= 0 then print_error_message ("Error from call to " + l_make_cmd + " -- return code: " + execution_environment_.return_code.out + "%N") end if not l_finished_file.exists then print_output_message (<< "C compilation terminated with errors at ", current_time, ".%NRun ", l_make_cmd, " in directory ", base_directory, " to see what has gone wrong." >>) else print_output_message (<< "C compilation completed successfully at ", current_time, "." >>) end end -- if will_perform_make end -- if will_process_makefiles end -- make -- ----------------------------- feature -- Attributes ----------------------------- -- generate_object_libraries: BOOLEAN -- -- if True, generate object libraries (.olb); else generate object modules (.obj) -- -- used for transitioning/testing from object library to concatenated object module generation -- generated_object_file_type: STRING is -- once -- if generate_object_libraries then -- Result := ".olb" -- else -- Result := ".obj" -- end -- end application_name: STRING -- Application name (from all: target rule in top level Makefile) finalized: BOOLEAN -- Is this a finalized (as opposed to workbench) application? precompiled_library: STRING -- If not Void, the precompiled library this application uses. build_precompile: BOOLEAN -- Is this building a precompile? application_dependencies: ES5SH_SET[STRING] --LINKED_LIST [STRING]LINKED_LIST [STRING] -- The prerequisites (objects, libraries) of the application (from the top level application target rule definition), -- less emain, preobj. Used to generate link.com list of objects/libraries dependent_subdirectories: ES5SH_SET[STRING] --LINKED_LIST [STRING] -- Names of the subdirectories in the subdirectory object targets in top level Makefile.SH cecil_dependencies: STRING -- should be LINKED_LIST[STRING] ***FIXME*** externals_list: ES5SH_SET[STRING] --ARRAYED_LIST[STRING] -- The externals (libraries, objects and options) if any are present (EXTERNALS macro found). -- Options are VMS LINK option files, not Unix link (-L) options. -- if none present, it is empty (never Void) externals_options: STRING -- externals options (Unix link options) from EXTERNALS macro. eiffel_library: STRING -- the eiffel runtime (runtime/finalized/workbench) object library (VMS filespec); -- from EIFLIB macro definition (or deduced from the cecil target???) start_date_time: STRING -- will be the date/time string processing started will_process_makefiles: BOOLEAN -- process makefiles in base_directory tree will_perform_make: BOOLEAN -- if true, perform make after processing makefiles will_concatenate_source_files: BOOLEAN -- if true, generate concatenated (big) source file in each subdirectory will_concatenate_source_file_contents: BOOLEAN -- if True, generate concatenated (big) source files by appending contents of individual source files, -- else append a "#include" directive for each individual file command_option_verbose: BOOLEAN -- -v command line option -- macro definitions encountered in each Makefile.SH (reset in open_makefiles) value_macro_OBJECTS, value_macro_OLDOBJECTS, value_macro_INCLUDE_PATH: STRING -- macro definitions encountered (expected) in top Makefile.SH value_macro_EOBJ1: STRING value_macro_SUBDIRS: STRING precompile_tag: STRING = "driver.exe" -- The tag that is used to determine that we are processing a precompile. -- it was "precompile" in Eiffel3; it is "driver.exe" in Eiffel4 and Eiffel5 -- ignored_macro_definitions: ARRAY [STRING] is -- -- macro definitions that, when empty, are not written to output Makefile because they are considered nugatory -- -- ***FIXME*** this should be a configuration option -- once -- --Result := << "LDFLAGS", "LDSHAREDFLAGS", "LIBS", "AR", "LD", "MKDEP", "MV", "CP", "RANLIB", "SHELL" >> -- Result := << "LDFLAGS", "LDSHAREDFLAGS", "LIBS", "AR", "LD", "RANLIB", "SHELL" >> -- Result.compare_objects -- end suppressed_macro_definitions: ARRAY [STRING] -- macro definitions that are suppressed in the output Makefile -- (unless handled as a special case in process_macro_definition) once Result := << "SHELL", "AR", "RANLIB" >> Result.compare_objects end echoed_unprocessed_macro_definitions: ARRAY [STRING] -- macro definitions that are always shown with unpreprocessed definition as a comment, -- even if comment_prefix configuration option is not defined -- includes suppressed_macro_definitions -- ***FIXME*** this should be a configuration option local l_res: EXTENDABLE_BOUNDED_ARRAY[STRING] once create l_res.make_empty Result := l_res l_res.compare_objects l_res.append_array (<< "INCLUDE_PATH", "CC", "CFLAGS", "EIFLIB", "OBJECTS", "OLD_OBJECTS", "EOBJ1", "X2C" >>) l_res.append_array (suppressed_macro_definitions) end unechoed_unprocessed_commands: ARRAY [STRING] -- commands that are not echoed unprocessed as comments to output Makefile once Result := << "$(CC)","$(CPP)","$(X2C)", "$(RM)" >> Result.compare_objects end unprocessed_targets: ES5SH_SET [STRING] -- targets that are echoed without processing to output Makefile once create Result.make_from_array (<< "sub_clean", "sub_clobber" >>) --default: Result.compare_objects end ---------------------------------------------------------------------------- feature -- Input/Output Makefiles -------------------------------------------------------------------------- open_makefiles (a_subdirectory : STRING) -- open input Makefile.SH and new Makefile in `a_subdirectory' or -- open in top level directory if a_subdirectory is Void require subdirectory_valid: a_subdirectory = Void or else not a_subdirectory.is_empty local file_name : FILE_NAME file_usage : STRING file_path : DIRECTORY_NAME l_msg, l_tag: STRING do -- -- (re)initialize all per-file values -- value_macro_OBJECTS := Void -- value_macro_OLDOBJECTS := Void -- value_macro_INCLUDE_PATH := Void -- open input file (Makefile.SH) file_usage := "input" create file_path.make_from_string (base_directory) if a_subdirectory /= Void and then not a_subdirectory.is_empty then file_path.extend (a_subdirectory) end create file_name.make_from_string (file_path) file_name.set_file_name ("Makefile.SH") create in_makefile.make_open_read (file_name) print_output_message (<< " Processing ", in_makefile.name >>) in_makefile.read_line -- output file (Makefile.) file_usage := "output" create file_name.make_from_string (file_path) file_name.set_file_name ("Makefile") create out_makefile.make_open_write (file_name) out_makefile.put_line (<< default_comment_prefix, " ", file_name >>) out_makefile.put_line (<< default_comment_prefix, " generated by ", pretty_version, " at " , start_date_time >>) out_makefile.put_line (<< default_comment_prefix, " configuration file: ", configuration.file_name >>) out_makefile.put_line (<< default_comment_prefix, " ", value_eiffel_string, " ", symbol_platform, "=", value_platform, "%N" >>) put_comment_prefixed_line (" for replacing spaces with commas, viz. $(subst $(SPACE),$(COMMA),$(OBJECTS))") out_makefile.put_line (<< "EMPTY =%NSPACE = $(EMPTY) $(EMPTY)%NCOMMA =,%N" >>) ensure value_macros_are_void: value_macro_OBJECTS = Void and value_macro_OLDOBJECTS = Void and value_macro_INCLUDE_PATH = Void input_makefile_open: in_makefile.is_open_read output_makefile_open: out_makefile.is_open_write rescue l_msg := "Unable to open " + file_usage + " file " + file_name if a_subdirectory /= Void and then not a_subdirectory.is_empty then l_msg.append (" in " + a_subdirectory) end print_error_message (l_msg + "%N") l_tag := exceptions_.tag_name if l_tag = Void then l_tag := "" end l_tag.append (" : " + exceptions_.meaning (exceptions_.exception)) print (" " + l_tag + "%N") end -- open_makefiles close_makefiles -- close current Makefiles do -- (re)initialize all per-file values value_macro_OBJECTS := Void value_macro_OLDOBJECTS := Void value_macro_INCLUDE_PATH := Void in_makefile.close out_makefile.close ensure value_macros_are_void: value_macro_OBJECTS = Void and value_macro_OLDOBJECTS = Void and value_macro_INCLUDE_PATH = Void input_makefile_closed: in_makefile.is_closed output_makefile_closed: out_makefile.is_closed end -- close_makefiles current_input_file_name : STRING -- the name of the current input file including the path ([.c1]Makefile.SH) do if in_makefile = Void then print_error_message ("current_input_filename: in_makefile = Void!!!!%N") Result := "" else Result := in_makefile.name end end -- current_input_file_name file_exists (a_name, a_ext: STRING; a_path: PATH_NAME): BOOLEAN -- does a file named `a_name'.`a_ext' exist in `a_path?' require name_not_void: a_name /= Void extension_not_void: a_ext /= Void path_not_void: a_path /= Void local l_path: FILE_NAME l_file: PLAIN_TEXT_FILE do create l_path.make_from_string (a_path) l_path.set_file_name (a_name) l_path.add_extension (a_ext) create l_file.make (l_path) Result := l_file.exists end -------------------------------------------------------------------------- feature -- Process arguments and configuration options -------------------------------------------------------------------------- -- Note: the original behavior of this program was to accept a single optional argument: -- the path of the top level directory to process, default is the current directory. -- If the path argument is specified, it generates Makefiles but does not perform the make. -- That behavior is still preserved, even after adding the processing of additional option arguments. process_arguments -- process command line arguments require argument_0_is_command_name: arguments_.argument_array.lower = 0 argument_count_matches_array_upper: arguments_.argument_count = arguments_.argument_array.upper local ii, jj: INTEGER l_arg: STRING l_cmd, l_val: STRING l_obj_file, l_obj_lib: BOOLEAN do --generate_object_libraries := generate_object_libraries_default will_process_makefiles := True will_perform_make := (arguments_.argument_count = 0) will_concatenate_source_files := True l_cmd := arguments_.command_line -- debug if arguments_.argument_count > 0 then print ("command: " + l_cmd + "%N") end -- check for -h (-help) argument; if found, display help message and ignore others. if arguments_.argument_count >= 1 and then (arguments_.argument (1).is_equal ("?") or else arguments_.argument (1).is_equal ("help") or else arguments_.index_of_character_option ('?') > 0 or else arguments_.index_of_character_option ('h') > 0 or else arguments_.index_of_word_option ("help") > 0 ) then will_process_makefiles := False print_help() else from ii := 1 -- arguments_.argument_array.lower (arg[0] is command) until ii > arguments_.argument_count -- arguments_.argument_array.upper loop l_val := arguments_.argument_array.item(ii) l_arg := arguments_.argument(ii) debug ("arguments") print (" debug: process argument " + ii.out + ": %"" + l_arg + "%" (" + l_arg.count.out + ")%N") from jj := 1; create l_val.make(l_arg.count * 2) until jj > l_arg.count loop l_val.append_character(l_arg @ jj); l_val.append_character(' ') jj := jj + 1 end print (" " + l_arg.count.out + " characters: " + l_val + "%N") end if l_arg.starts_with ("?") then will_process_makefiles := False print_help elseif l_arg.count >= 2 and then l_arg @ 1 = arguments_.option_sign.item then -- argument starts with a '-' if l_arg.count = 2 then -- single character argument inspect l_arg @ 2 when '?' then -- -help will_process_makefiles := False print_help() when 'h' then -- -help will_process_makefiles := False print_help() when 'b' then -- -build (synonyum for -make) will_perform_make := True when 'm' then -- -make (synonym for -build) will_perform_make := True when 'c' then -- -config if ii < arguments_.argument_count then ii := ii + 1 create configuration_file_name.make_from_string (arguments_.argument(ii) ) else print_error_message ("-c option requires %N") will_process_makefiles := False end when 'd' then -- generate verbose (debug) messages command_option_verbose := True when 'l' then if l_obj_file then print_warning_message ("-l option conflicts with -o; -o ignored%N") print_usage() end generate_object_libraries := True l_obj_lib := True when 'o' then if l_obj_lib then print_warning_message ("-o option conflicts with -l; -l ignored%N") print_usage() end generate_object_libraries := False l_obj_file := True when 'q' then command_option_verbose := False when 's' then will_concatenate_source_file_contents := True when 't' then -- -test will_process_makefiles := False will_perform_make := False test() when 'v' then -- display version and exit --print_version will_process_makefiles := False when 'y' then command_option_verbose := True when 'z' then -- -z (dont concatenate source files) will_concatenate_source_files := False else print_error_message ("invalid option: " + l_arg + "%N") print_usage() will_process_makefiles := False end -- inspect else l_val := l_arg.substring (2, l_arg.count) if l_val.is_equal ("help") then will_process_makefiles := False print_help elseif l_val.is_equal ("help") then will_process_makefiles := False print_help elseif l_val.is_equal ("verbose") then command_option_verbose := True elseif l_val.is_equal ("version") then will_process_makefiles := False else will_process_makefiles := False print_error_message ("invalid option: " + l_arg + "%N") print_usage() end end else if ii = arguments_.argument_count then create base_directory.make_from_string (arguments_.argument(ii)) else print_error_message ("invalid argument #" + ii.out + ": " + l_arg + "%N") print_usage() will_process_makefiles := False end end ii := ii + 1 end -- loop end -- if -help not found in arguments if not will_process_makefiles then will_perform_make := False end end -- process_arguments ------------------------------------------------------------------------- feature -- Process Makefile.SH files ----------------------------------------------------------------------- process_makefiles do create application_dependencies.make_empty create dependent_subdirectories.make_empty create externals_list.make_empty create externals_options.make_empty create cecil_dependencies.make_empty process_top_level_makefile process_subdirectory_makefiles end process_top_level_makefile -- create a new Makefile for the top level require no_current_input_file: in_makefile = Void local l_spit2_tag : STRING do check dependent_subdirectories_off_initially: dependent_subdirectories.off end open_makefiles (Void) process_case_stmt () process_case_stmt () process_echo_stmt () check dependent_subdirectories_off_after_process_echo: dependent_subdirectories.off end process_spit1_block () check dependent_subdirectories_off_after_process_spit1: dependent_subdirectories.off end l_spit2_tag := get_spitshell_end_tag check dependent_subdirectories_off_after_get_spitshell_end_tag: dependent_subdirectories.off end process_spit2_block (l_spit2_tag) check dependent_subdirectories_off_after_process_spit2: dependent_subdirectories.off end --process_remainder() produce_link_dot_com close_makefiles end -- process_top_level_makefile process_subdirectory_makefiles -- process Makefiles in each of `dependent_subdirectories' local l_saved_index: INTEGER do from dependent_subdirectories.start until dependent_subdirectories.off loop l_saved_index := dependent_subdirectories.index -- ***debug*** open_makefiles (dependent_subdirectories.item) process_case_stmt () process_case_stmt () process_echo_stmt () process_spit1_block () process_spit2_block (Void) out_makefile.flush --process_remainder () if will_produce_concatenated_source_file_in (dependent_subdirectories.item) then produce_concatenated_source_file (dependent_subdirectories.item) end close_makefiles --produce_make_dot_com (dependent_subdirectories.item) check dependent_subdirectories_position_unchanged: l_saved_index = dependent_subdirectories.index end dependent_subdirectories.forth end end -- process_subdirectory_makefiles -------------------------------------------------------------------------- feature -- Process elements of Makefile.SH -------------------------------------------------------------------------- process_case_stmt -- process a case block by ignoring it require input_file_readable: in_makefile /= Void and then in_makefile.is_open_read local token1 : STRING do -- skip to next token in input from token1 := first_token (in_makefile.last_string) until --starts_with_symbol (in_makefile.last_string, "case") not token1.is_empty loop out_makefile.put_line (<< in_makefile.last_string >>) in_makefile.read_line token1 := first_token (in_makefile.last_string) end -- if token1.is_equal ("case") then if starts_with_symbol (in_makefile.last_string, "case") then else -- scream bloody murder print ("Error: looking for case statement, found: '" + token1 + "' on line:%N" + in_makefile.last_string + "%N in file " + in_makefile.name + "%N") exceptions_.raise ("case label not found") end from until starts_with_symbol (in_makefile.last_string, "esac") loop in_makefile.read_line end in_makefile.read_line end -- process_case_stmt process_echo_stmt -- process an echo statement by ignoring it require input_file_readable: in_makefile /= Void and then in_makefile.is_open_read -- in_makefile.last_string.startswith ("echo") is_echo_statement: in_makefile.last_string /= Void and then starts_with_symbol (in_makefile.last_string, "echo") local token1 : STRING do debug ("echo") token1 := first_token (in_makefile.last_string); -- tok2 := second_token (in_makefile.last_string, token1); end -- debug in_makefile.read_line end get_spitshell_end_tag : STRING -- the tag that ends the spitshell block on the current line of the input makefile -- if the tag is quoted (with single quotes), remove the enclosing quote characters -- read the next input line require not_end_of_file: not in_makefile.end_of_file is_spitshell_block: starts_with (in_makefile.last_string, "$spitshell") local l_pos : INTEGER do l_pos := in_makefile.last_string.substring_index ("<<", 1) if l_pos > 0 then Result := in_makefile.last_string.substring (l_pos +2, in_makefile.last_string.count) if Result.count >= 2 then if (Result @ 1 = '%'') and then Result @ 1 = Result @ Result.count then Result.remove (Result.count) Result.remove (1) end end in_makefile.read_line end end -- get_spitshell_end_tag process_spit1_block -- process the first spitshell block (contains macro definitions) require input_file_readable: in_makefile /= Void and then in_makefile.is_open_read local l_end_tag : STRING do from l_end_tag := get_spitshell_end_tag -- usually the tag is !GROK!THIS! (I think!) until --in_makefile.end_of_file or else in_makefile.last_string.is_equal (l_end_tag) loop if in_makefile.last_string.is_empty then out_makefile.put_new_line in_makefile.read_line elseif in_makefile.last_string @ 1 = '#' then out_makefile.put_line (<< in_makefile.last_string >>) in_makefile.read_line elseif (is_macro_definition (in_makefile.last_string)) then process_macro_definition() else -- not a macro definition, just comment and continue put_comment_prefixed_line (in_makefile.last_string) in_makefile.read_line end -- is_macro_definition end -- read loop if not in_makefile.end_of_file then in_makefile.read_line -- consume line with spitshell end tag else print ("Unexpected end of file encountered.%N") end out_makefile.put_new_line() debug print ("Done with first spitshell block..." + in_makefile.last_string + "%N") end -- debug end -- process_spit1_block process_spit2_block (a_end_tag: STRING) -- process second spitshell block (contains dependency rules) -- for top level makefile, this is called after the objects and subdirectories and stuff -- to process the rest of the block. -- for subdirectory makefile it is called at the start of the block require input_file_readable: in_makefile /= Void and then in_makefile.is_open_read output_file_writable: out_makefile /= Void and then out_makefile.is_open_write local l_tag: STRING do check a_end_tag = Void implies in_makefile.last_string.substring (1,10).is_equal ("$spitshell") end from if a_end_tag /= Void then l_tag := a_end_tag else l_tag := get_spitshell_end_tag end until in_makefile.end_of_file or else in_makefile.last_string.is_equal(l_tag) loop if in_makefile.last_string.is_empty then out_makefile.put_new_line in_makefile.read_line elseif in_makefile.last_string @ 1 = '#' then out_makefile.put_line (<< in_makefile.last_string >>) in_makefile.read_line elseif is_macro_definition (in_makefile.last_string) then process_macro_definition () elseif not is_whitespace (in_makefile.last_string @ 1) and then in_makefile.last_string.has (':') then process_rule () else -- what else could this line be? Don't know; just output it as a comment print_makefile_warning ("process_spit2_block: unprocessed line") out_makefile.put_line (<< default_comment_prefix, " Warning: unprocessed: ", in_makefile.last_string >>) in_makefile.read_line end end -- loop until end of file or end of spitshell block if not in_makefile.end_of_file then in_makefile.read_line -- consume spitshell block end tag end -- add default rule if it is in the config file out_makefile.new_line if configuration.has ("default_rule") then put_comment_prefixed_line ("default_rule (from configuration file " + configuration.file_name + ")") out_makefile.put_string (configuration.item ("default_rule")) out_makefile.new_line put_comment_prefixed_line ("end default_rule") out_makefile.new_line end -- default rule --out_makefile.put_string ("%N%N") end -- process_spit2_block -- process_remainder is -- do -- from -- out_makefile.put_new_line -- until -- in_makefile.end_of_file -- loop -- put_comment_prefixed_line (in_makefile.last_string) -- in_makefile.read_line -- end -- end process_rule -- process target definition: ... : [ ... ] -- and following command and comment lines require input_file_readable: in_makefile /= Void and then in_makefile.is_open_read output_file_writable: out_makefile /= Void and then out_makefile.is_open_write current_line_nonblank: not in_makefile.last_string.is_empty is_target_rule: in_makefile.last_string.count > 2 and then not is_whitespace (in_makefile.last_string @ 1) and then in_makefile.last_string.index_of (':', 2) > 0 local l_colon_pos: INTEGER l_target, l_prereq, l_con_src: STRING do l_colon_pos := in_makefile.last_string.index_of (':', 1) --if not is_whitespace (in_makefile.last_string @ 1) and then in_makefile.last_string.has (':') then if l_colon_pos <= 0 or else is_whitespace (in_makefile.last_string @ 1) then print_makefile_error ("process_rule: non target rule encountered") out_makefile.put_line (<< in_makefile.last_string >>) else -- a rule (dependency specification): ... : [ ... ] (colon may be double) l_target := in_makefile.last_string.substring (1, l_colon_pos -1) if l_colon_pos < in_makefile.last_string.count then l_prereq := in_makefile.last_string.substring (l_colon_pos +1, in_makefile.last_string.count) if l_prereq.count > 1 and then l_prereq @ 1 = ':' then l_prereq.remove (1) end l_prereq.left_adjust else l_prereq := "" end if l_target.is_equal (".SUFFIXES") then put_comment_prefixed_line (in_makefile.last_string) delimit_target_colon (in_makefile.last_string) in_makefile.last_string.append_character (' ') in_makefile.last_string.replace_substring_all (".o ", ".obj ") in_makefile.last_string.right_adjust out_makefile.put_line (<< in_makefile.last_string >>) in_makefile.read_line -- consume current line elseif l_target.is_equal ("all") then process_rule_all (l_target, l_prereq) elseif l_target.is_equal ("cecil") then process_rule_cecil (l_target, l_prereq) elseif application_name /= Void and then l_target.is_equal (application_name) then -- ***FIXME*** what if application_name is Void already found and l_target = application_name ? process_rule_application (l_target, l_prereq) elseif l_target @ 1 = '.' and then l_target.index_of ('.', 3) > 0 then process_suffix_rule (l_target) elseif l_target.index_of ('/', 1) > 0 then -- i.e. C1/Cobj1.o in top level Makefile line: C1/Cobj1.o: Makefile -- should only occur in top level file process_subdirectory_rule (l_target, l_prereq) elseif is_current_subdirectory_object_file (l_target) then -- i.e. Cobj1.o in subdirectory C1 -- from C1/Makefile.SH line: Cobj1.o: $(OBJECTS) Makefile -- should only occur in subdirectory file put_comment_prefixed_line (in_makefile.last_string) --delimit_target_colon (in_makefile.last_string) --l_colon_pos := in_makefile.last_string.index_of (':', 1) --in_makefile.last_string.replace_substring_all (".o", generated_object_file_type) l_target.replace_substring_all (".o", generated_object_file_type) if generate_object_libraries or else dependent_subdirectories.off then --out_makefile.put_line (<< in_makefile.last_string >>) else l_con_src := concatenated_source_file_name (dependent_subdirectories.item) --in_makefile.last_string.replace_substring_all ("$(OBJECTS)", l_con_src + ".c") --out_makefile.put_line (<< in_makefile.last_string >>) l_prereq.replace_substring_all ("$(OBJECTS)", l_con_src + ".c") end out_makefile.put_line (<< l_target, " : ", l_prereq >>) skip_rule_commands if generate_object_libraries or else dependent_subdirectories.off then if configuration.target_gnu_make then out_makefile.put_line (<< "%Tlibrary/create $@ $(subst $(SPACE),$(COMMA),$(OBJECTS))" >>) else out_makefile.put_line (<< "%Tlibrary/create $@ *.obj" >>) if l_target.substring_index ("Eobj1.olb", 1) > 0 then out_makefile.put_line (<< "%T- if f$search(%"emain.obj%") .nes. %"%" then library/delete=emain $@" >>) end end else --out_makefile.put_line (<< "#%T$(CP) $(subst $(SPACE),$(COMMA),$(OBJECTS)) $@%N") out_makefile.put_line (<< "%T$(CC) $>) end if configuration.has ("create_test") then out_makefile.put_line (<< "%T$(CREATE_TEST)" >>) end out_makefile.put_new_line elseif FALSE AND THEN unprocessed_targets.has (l_target) then delimit_target_colon (in_makefile.last_string) out_makefile.put_line (<< in_makefile.last_string >>) echo_rule_commands else -- generic target delimit_target_colon (in_makefile.last_string) --perform_inchoate_replacements (in_makefile.last_string) out_makefile.put_line (<< in_makefile.last_string >>) process_rule_commands (l_target, l_prereq) end end -- (is target definition) end -- process_rule process_suffix_rule (a_target: STRING) -- process a suffix rule (eg. .c.o:) require input_file_readable: in_makefile /= Void and then in_makefile.is_open_read output_file_ready: out_makefile /= Void and then out_makefile.extendible is_suffix_rule: in_makefile.last_string.count >= 5 and then in_makefile.last_string @ 1 = '.' and then in_makefile.last_string.index_of ('.', 3) > 0 and then in_makefile.last_string.index_of (':', 3) > in_makefile.last_string.index_of ('.', 3) local l_dot2_pos: INTEGER l_source, l_target: STRING do l_dot2_pos := a_target.index_of ('.', 2) l_source := a_target.substring (1, l_dot2_pos - 1) l_target := a_target.substring (l_dot2_pos, a_target.count) if l_source.is_equal (".x") then finalized := True end if l_target.is_equal (".o") then l_target := ".obj" end out_makefile.put_line (<< l_source, l_target, " :" >>) if True then process_rule_commands (l_source + l_target, "") -- else -- from -- in_makefile.read_line -- until -- in_makefile.end_of_file or else in_makefile.last_string.is_empty -- or else not is_space_or_tab (in_makefile.last_string @ 1) -- loop -- in_makefile.last_string.replace_substring_all (" -c", "") -- --perform_inchoate_replacements (in_makefile.last_string) -- out_makefile.put_line (<< in_makefile.last_string >>) -- in_makefile.read_line -- end -- loop end end -- end process_suffix_rule process_subdirectory_rule (a_target, a_prerequisite: STRING) -- process a subdirectory rule (eg. X99/Xobj99.o: Makefile) require input_file_readable: in_makefile /= Void and then in_makefile.is_open_read output_file_ready: out_makefile /= Void and then out_makefile.extendible is_dependency_definition: in_makefile.last_string.count > 5 and then not is_whitespace (in_makefile.last_string @ 1) and then in_makefile.last_string.index_of (':', 2) > 0 target_exists_nonblank: a_target /= Void and then not a_target.is_empty target_is_subdirectory: a_target.index_of ('/', 1) > 0 local l_target, l_prereq: STRING l_slash_pos, l_dot_pos : INTEGER l_target_dir, l_target_file,l_target_dir_vms: STRING do put_comment_prefixed_line (in_makefile.last_string) l_target := a_target.twin to_vms_filespecs (l_target, 1); if is_nonblank (a_prerequisite) then l_prereq := a_prerequisite.twin to_vms_filespecs (l_prereq, 1) else l_prereq := "" end -- GNU make requires colons in VMS filespecs to be escaped if configuration.target_gnu_make then -- quote_colon_in_VMS_dependencies l_target.replace_substring_all (":", "\:") l_prereq.replace_substring_all (":", "\:") end -- get the path and file name of the (first) target l_slash_pos := a_target.index_of ('/', 1) -- must be > 0 from require target_is_subdirectory l_target_dir := a_target.substring (1, l_slash_pos -1) -- ***FIXME*** make it work even with terminating slash l_target_dir_vms := as_vms_filespec (a_target.substring (1, l_slash_pos)) l_dot_pos := a_target.index_of ('.', l_slash_pos +1) if l_dot_pos > l_slash_pos then l_target_file := a_target.substring (l_slash_pos +1, l_dot_pos -1) else l_target_file := a_target.substring (l_slash_pos +1, a_target.count) end if not l_target_dir.is_empty then dependent_subdirectories.extend (l_target_dir) end if l_target_dir.is_empty then -- skip rule if empty target directory or target file print_makefile_warning ("process_subdirectory_rule: target directory is empty!") skip_rule_commands out_makefile.put_new_line elseif l_target_file.is_empty then -- skip rule if empty target file print_makefile_warning ("process_subdirectory_rule: target file is empty!") skip_rule_commands out_makefile.put_new_line elseif l_target_file.is_equal (subdirectory_object_filename(l_target_dir)) then -- emit the commands for building the target subdirectory object, -- skip past the current line and all its directives out_makefile.put_line (<< l_target, " : ", l_prereq >>) skip_rule_commands --out_makefile.put_line (<< "%T", configuration.ignore_prefix, -- platform_specific_file_name (<<"studio","spec">>, <<"bin">>, "make.vms "), " ", -- "ISE_EIFFEL:[studio.spec.", value_platform, ".bin]make.vms ", l_target_dir_vms >>) out_makefile.put_line (<< subdirectory_make_command (l_target_dir_vms, Void) >>) elseif l_target_file.is_equal ("Makefile") then -- ****FIXME**** make case insensitive comparison?? -- skip this subdirectory rule, output comment --put_comment_prefixed_line (l_target + " : " + l_prereq) out_makefile.put_line (<< l_target, " : ", l_prereq >>) skip_rule_commands put_comment_prefixed_line ("%T(Makefile generated by finish_freezing/" + pretty_name + ")") elseif l_target_file.is_equal ("emain") then -- emit copy command for emain template out_makefile.put_line (<< l_target, " : ", l_prereq >>) skip_rule_commands -- force target extension to uppercase to workaround MMS suffix rule case sensitivity bug: -- MMS does not run .c.obj: or .C.obj: rule for .c file (must be .C) on ODS5 volume --out_makefile.put_line (<< "%TCOPY " -- + platform_specific_file_name (<<"studio","config">>, <<"templates">>, "emain.template") -- + " " + l_target_dir_vms + "emain.C %N") --out_makefile.put_line (<< "%T- COPY " + emain_vms + " " + l_target_dir_vms + "emain.C %N") out_makefile.put_line (<< "%T", configuration.ignore_prefix, "$(CP) ISE_EIFFEL:[studio.config.$(ISE_PLATFORM).templates]emain.template [.E1]emain.c" >>) out_makefile.put_line (<< subdirectory_make_command ("[.E1]", "emain.obj") >>) else out_makefile.put_line (<< l_target, " : ", l_prereq >>) --process_target_prerequisites process_rule_commands (l_target, l_prereq) end end -- process_subdirectory_rule process_rule_all (a_target, a_prerequisite: STRING) -- process all: target -- If this is the top level makefile, it will be all: (all: hello) -- If a subdirectory, it will be all: (all: Cobj1.o) -- process lines starting with all target rule and all command and comment lines require input_file_readable: in_makefile /= Void and then in_makefile.is_open_read line_starts_with_all_colon: starts_with (in_makefile.last_string, "all") and then in_makefile.last_string.has (':') --***FIXME*** need an abstraction for is_dependency_definition (target) to check that target occurs to the left of ':' local l_line: STRING l_pos: INTEGER l_appl_exe: STRING do put_comment_prefixed_line (in_makefile.last_string) l_line := in_makefile.last_string.twin -- ***fixme*** does it really need to twin? delimit_target_colon (l_line) l_pos := l_line.index_of (':', 4) -- can't occur before "all" if l_line @ l_pos = ':' then l_pos := l_pos + 1 end -- ***FIXME*** this is kinda hokey: if application_name = Void then -- processing top level Makefile --application_name := in_makefile.last_string.substring (("all:").count +1, in_makefile.last_string.count) application_name := in_makefile.last_string.substring (l_pos, in_makefile.last_string.count) application_name.left_adjust; application_name.right_adjust if application_name.is_equal (precompile_tag) then build_precompile := True l_appl_exe := "driver.exe" else l_appl_exe := application_name + ".exe" end out_makefile.put_line (<< "all : ", l_appl_exe >>) skip_rule_commands out_makefile.put_line (<< "%Topen/write fn complete.eif" >>) -- out_makefile.put_line (<< "%Tclose/nolog fn" >>) -- (file will be closed automatically, and this makes GNU make burp) -- (because it spawns a new subprocess for each command) else -- processing for (sub)directory makefiles l_line.replace_substring_all (".o", generated_object_file_type) l_line.replace_substring_all ("emain.olb", "emain.obj") -- special handling for Eobj1 (in [.E1]) to add a dependency on emain.obj if l_line.substring_index ("Eobj1" + generated_object_file_type, 1) > l_pos and then l_line.substring_index ("emain.obj", 1) = 0 then l_line.replace_substring_all ("Eobj1" + generated_object_file_type, "Eobj1" + generated_object_file_type + " emain.obj") end out_makefile.put_line (<< l_line >>) skip_rule_commands -- adding this line keeps MMS (and MMK?) from printing a warning. No effect with GNU make. ***FIXME*** MMS/MMK specific if not configuration.target_gnu_make then out_makefile.put_line (<< "%Tcontinue" >>) end end end -- process_rule_all process_rule_application (a_target, a_prerequisite: STRING) -- Process application target, eg: : $(OBJECTS) E1/emain.o Makefile require input_file_readable: in_makefile /= Void and then in_makefile.is_open_read appl_nonblank: application_name /= Void and then not application_name.is_empty appl_has_target: in_makefile.last_string.index_of (':', 1) > 0 appl_has_dependencies: in_makefile.last_string.index_of (':', 1) < in_makefile.last_string.count is_appl_target_definition: starts_with_symbol (in_makefile.last_string, application_name) and then first_token (in_makefile.last_string). is_equal (application_name) and then second_token (in_makefile.last_string, application_name). is_equal (":") local l_line, l_target, l_word : STRING l_appl_rule: STRING l_colon_pos, l_pos: INTEGER unfinished_remove_colon_pos: INTEGER do -- No longer using option from config.eif file -- Replace appl with appl.exe, unless precompile if configuration.comment_prefix /= Void then -- output dependent_subdirectories and application_dependencies out_makefile.put_text (<< "%N", configuration.comment_prefix, " dependent_subdirectories:" >>) from dependent_subdirectories.start until dependent_subdirectories.after loop out_makefile.put_text (<< " ", dependent_subdirectories.item >>) dependent_subdirectories.forth end -- loop to print out dependent_subdirectories out_makefile.put_text (<< "%N", configuration.comment_prefix, " application_dependencies:" >>) from application_dependencies.start until application_dependencies.after loop out_makefile.put_text (<< " ", application_dependencies.item >>) application_dependencies.forth end -- loop to print out application_dependencies out_makefile.put_string ("%N%N") end put_comment_prefixed_line (in_makefile.last_string) --out_makefile.put_line (<< l_appl_rule >>) create l_appl_rule.make_from_string (in_makefile.last_string) l_target := first_token (l_appl_rule) if l_target.is_equal (precompile_tag) then l_target := "driver" end l_line := l_target + ".exe : " -- rearrange prerequisites to place E1/emain first l_colon_pos := l_appl_rule.index_of (':', 1) l_pos := l_appl_rule.substring_index ("E1/emain.o", l_colon_pos +1) if l_pos > 0 then l_appl_rule.replace_substring ("", l_pos, l_pos + ("E1/emain.o").count -1) -- this will fail if ":" is last char in string l_appl_rule.insert_string (" [.E1]emain.obj ", l_colon_pos +1) end process_target_prerequisites (l_appl_rule, l_colon_pos) -- replace target string .exe or preobj_tag l_colon_pos := l_appl_rule.index_of (':', 1) l_appl_rule.replace_substring (l_line, 1, l_colon_pos) out_makefile.put_line (<< l_appl_rule >>) -- position at first space -- loop: skip target commands -- this loop reads the file until an empty line -- to suck up the rest of the commands for building the target appl -- it looks for precompiled objects and does stuff with "word" -- that is probably left over from an earlier incarnation, and that's why -- it doesn't just call skip_rule_commands from if not in_makefile.last_string.is_empty then l_pos := in_makefile.last_string.substring_index ("preobj", 1) else l_pos := 0 end -- if l_pos > 0 and not build_precompile then if l_pos > 0 then precompiled_library := in_makefile.last_string.twin -- ***fixme*** does it really need to twin? end in_makefile.read_line until in_makefile.end_of_file or else in_makefile.last_string.is_empty -- **FIXME** s.b. until non-whitespace first char? loop -- MMS chokes on comments that end with continuation character, so -- remove any such if is_continued_line (in_makefile.last_string) then strip_continuation (in_makefile.last_string) end if configuration.comment_prefix /= Void then out_makefile.put_line (<< configuration.comment_prefix, in_makefile.last_string >>) end l_pos := in_makefile.last_string.index_of ('#', 1); if l_pos > 0 then -- remove comment in_makefile.last_string.keep_head (l_pos - 1) end l_word := in_makefile.last_string.twin -- ***fixme*** does it need to twin? l_word.left_adjust if not l_word.is_empty then if not l_word.is_equal ("Makefile") then if l_word.count >= 10 and then not l_word.substring_index ("runtime", 1).is_equal(0) then application_dependencies.extend ("eiflib:runtime.olb") elseif l_word.count >= 10 and then not l_word.substring_index ("wkbench", 1).is_equal(0) then application_dependencies.extend ("eiflib:wkbench.olb") elseif -- ignore lines starting with $ not l_word.substring(1,1).is_equal("$") and then not starts_with (l_word, "ld ") then -- this is totally bizarre - it can be a whole line! application_dependencies.extend (l_word) debug ("appl") print ("DEBUG(appl): Adding " + l_word + " to application_dependencies%N") end -- debug end end -- not Makefile l_pos := l_word.substring_index ("preobj", 1) else l_pos := 0 end -- l_word.is_empty -- if l_pos > 0 and not build_precompile then if l_pos > 3 and then not l_word.substring (l_pos-3, l_pos-1).is_equal ("-o ") then precompiled_library := l_word.twin end in_makefile.read_line end -- loop -- write out the the action lines to build the appl out_makefile.put_line (<< "%T" + configuration.commandfile + "link.com" >>) if precompiled_library /= Void then precompiled_library.left_adjust precompiled_library.replace_substring_all ("\", "") precompiled_library.right_adjust end -- precompiled_library found debug ("appl") print ("DEBUG(appl): application_dependencies: %N") from application_dependencies.start until application_dependencies.after loop print (" %"" + application_dependencies.item + "%"%N") application_dependencies.forth end end -- debug end -- process_rule_application process_rule_cecil (a_target, a_prerequisite: STRING) require input_file_readable: in_makefile /= Void and then in_makefile.is_open_read is_cecil_target_definition: starts_with (in_makefile.last_string, "cecil:") or else starts_with (in_makefile.last_string, "cecil") and then second_token (in_makefile.last_string, "cecil").is_equal (":") local deletable_objects: STRING do if True then -- ***FIXME*** comment out all the cecil related targets and definitions from until starts_with_symbol (in_makefile.last_string, "clean") loop out_makefile.put_line (<< "#! ", in_makefile.last_string >>) in_makefile.read_line end -- out_makefile.put_new_line else if not in_makefile.end_of_file and then not in_makefile.last_string.is_empty then delimit_target_colon (in_makefile.last_string) out_makefile.put_string (in_makefile.last_string) end end out_makefile.put_new_line if starts_with_symbol (in_makefile.last_string, "cecil") then -- first, process the cecil: line, converting C1/cobj1.o to [.c1]cobj1.olb etc. -- (just use the dependencies that we got before) out_makefile.put_string ("cecil : ") if cecil_dependencies /= Void then out_makefile.put_string (cecil_dependencies) else out_makefile.put_string (" # none found") end out_makefile.put_new_line -- next extract the objects from runtime.olb or wkbench.olb -- skip the cecil :