Rev 2 | Blame | Compare with Previous | Last modification | View Log | RSS feed
/*
* Copyright (c) 2002-2005 The TenDRA Project <http://www.tendra.org/>.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. Neither the name of The TenDRA Project nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific, prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
* IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $Id$
*/
/*
Crown Copyright (c) 1997
This TenDRA(r) Computer Program is subject to Copyright
owned by the United Kingdom Secretary of State for Defence
acting through the Defence Evaluation and Research Agency
(DERA). It is made available to Recipients with a
royalty-free licence for its use, reproduction, transfer
to other parties and amendment for any purpose not excluding
product development provided that any such use et cetera
shall be deemed to be acceptance of the following conditions:-
(1) Its Recipients shall ensure that this Notice is
reproduced upon any copies or amended versions of it;
(2) Any amended version of it shall be clearly marked to
show both the nature of and the organisation responsible
for the relevant amendment or amendments;
(3) Its onward transfer from a recipient to another
party shall be deemed to be that party's acceptance of
these conditions;
(4) DERA gives no warranty or assurance as to its
quality or suitability for any purpose and DERA accepts
no liability whatsoever in relation to any use to which
it may be put.
*/
/*** main.c --- SID program main routine.
*
** Author: Steve Folkes <smf@hermes.mod.uk>
*
*** Commentary:
*
* This file implements the main function for SID. The main function just
* deals with exception handling. It calls the ``main_init'' function to
* initialise the error reporting routines and parse the command line
* arguments, and the ``main_1'' function to parse the grammar.
*
* The initialisation stuff should be trivial. The ``main_1'' function first
* parses the grammar and any language specific input files. The grammar
* parser is defined in the file "parser/parser.sid". The language specific
* file parsers are defined in the files "LANGUAGE-input/LANGUAGE-parser.sid".
*
* After reading in the grammar, and language specific information, it then
* calls various functions to manipulate the grammar. These functions are
* described in "transforms/grammar.[ch]".
*
* Finally, it calls an output function to output a program to recognise the
* grammar. The output functions are described in the
* "LANGUAGE-output/LANGUAGE-output.[ch]" files.
*
*** Change Log:
* $Log: main.c,v $
* Revision 1.2 1998/02/06 17:05:44 release
* Last minute pre-release polishing.
*
* Revision 1.1.1.1 1998/01/17 15:57:41 release
* First version to be checked into rolling release.
*
* Revision 1.13 1996/07/01 13:29:41 smf
* main.c:
* - updated version number.
*
* Revision 1.12 1996/07/01 09:36:04 smf
* main.c:
* - updated version numer.
*
* Revision 1.11 1996/06/28 15:12:34 smf
* main.c:
* - added extra information to version string;
* - added "build" mechanism for release system.
*
* Revision 1.10 1996/03/01 09:51:56 smf
* main.c:
* - updated version number.
*
* Revision 1.9 1996/02/29 09:53:26 smf
* main.c:
* - updated version number.
*
* Revision 1.8 1996/02/28 15:43:56 smf
* Updated version number in main.c.
* Modified build_sid to use new platform designation.
*
* Revision 1.7 1995/02/10 16:28:56 smf
* Fixed bugs "CR95_111.sid-inline-no-var-check" and "CR95_112.sid-lre-var-call".
* Updated version number.
*
* Revision 1.6 1994/12/23 09:44:18 smf
* Fixing "CR94_227.sid-exception-optimisation-bug" - updated version number.
*
* Revision 1.5 1994/12/15 09:55:01 smf
* Updated version to "1.9#4".
* Brought into line with OSSG C Coding Standards Document, as per
* "CR94_178.sid+tld-update".
*
* Revision 1.4 1994/11/11 11:35:40 smf
* Updated version number for bug fix CR94_127.sid-tail-rec.
*
* Revision 1.3 1994/08/22 09:34:15 smf
* Fixed bug DR114:ids-too-long.
*
* Revision 1.2 1994/08/18 13:42:35 smf
* Fixed bug "DR115:SID-shadow-error". Also modified "build_sid" to make
* parallel bug fixing simpler.
*
* Revision 1.1.1.1 1994/07/25 16:04:11 smf
* Initial import of SID 1.8 non shared files.
*
**/
/****************************************************************************/
#include "os-interface.h"
#include "release.h"
#include "arg-parse.h"
#include "c-check.h"
#include "c-lexer.h"
#include "c-output.h"
#include "c-parser.h"
#include "cstring.h"
#include "cstring-list.h"
#include "dstring.h"
#include "error.h"
#include "error-file.h"
#include "exception.h"
#include "gen-errors.h"
#include "grammar.h"
#include "istream.h"
#include "lexer.h"
#include "ostream.h"
#include "output.h"
#include "parser.h"
#include "rule.h"
#include "syntax.h"
/*--------------------------------------------------------------------------*/
#define USAGE "\
\tusage:[option ...]in-file ... out-file ...\n\
\twhere option is one of:"
#ifndef VERSION
#define VERSION "sid: version 1.10.0 (ansi-c, pre-ansi-c, test)"
#endif /* !defined (VERSION) */
#ifndef RELEASE
#define RELEASE "unknown"
#endif /* !defined (RELEASE) */
#ifndef BANNER
#define BANNER ""
#endif /* !defined (BANNER) */
/*--------------------------------------------------------------------------*/
typedef struct PhaseListT {
CStringP phase;
void (*proc)(BoolT);
} PhaseListT, *PhaseListP;
typedef struct LangListT {
CStringP language;
GenericP (*init_proc)(OutputInfoP, CStringListP);
void (*input_proc)(GenericP, GrammarP);
unsigned num_input_files;
void (*output_proc)(GenericP, GrammarP);
unsigned num_output_files;
} LangListT, *LangListP;
/*--------------------------------------------------------------------------*/
static void
main_handle_phase_all(BoolT enable)
{
rule_set_inline_singles(enable);
rule_set_inline_tail_calls(enable);
rule_set_inline_all_basics(enable);
rule_set_inline_non_tail_calls(enable);
rule_set_multiple_inlining(enable);
}
/*--------------------------------------------------------------------------*/
static GenericP
main_init_c(OutputInfoP out_info, CStringListP options, BoolT ansi)
{
COutputInfoP c_out_info = ALLOCATE(COutputInfoT);
CStringListEntryP entry;
c_out_info_init(c_out_info, out_info);
if (ansi) {
c_out_info_set_prototypes(c_out_info, TRUE);
}
for (entry = cstring_list_head(options); entry;
entry = cstring_list_entry_deallocate(entry)) {
CStringP option = cstring_list_entry_string(entry);
if (cstring_equal(option, "prototypes") ||
cstring_equal(option, "proto")) {
c_out_info_set_prototypes(c_out_info, TRUE);
} else if (cstring_equal(option, "no-prototypes") ||
cstring_equal(option, "no-proto")) {
c_out_info_set_prototypes(c_out_info, FALSE);
} else if (cstring_equal(option, "split")) {
c_out_info_set_split(c_out_info, (unsigned)5000);
} else if (cstring_starts(option, "split=")) {
unsigned limit;
if (!cstring_to_unsigned(option + 6, &limit)) {
E_bad_split_size(option + 6);
UNREACHED;
}
c_out_info_set_split(c_out_info, limit);
} else if (cstring_equal(option, "no-split")) {
c_out_info_set_split(c_out_info, (unsigned)0);
} else if (cstring_equal(option, "numeric-ids") ||
cstring_equal(option, "numeric")) {
c_out_info_set_numeric_ids(c_out_info, TRUE);
} else if (cstring_equal(option, "no-numeric-ids") ||
cstring_equal(option, "no-numeric")) {
c_out_info_set_numeric_ids(c_out_info, FALSE);
} else if (cstring_equal(option, "casts") ||
cstring_equal(option, "cast")) {
c_out_info_set_casts(c_out_info, TRUE);
} else if (cstring_equal(option, "no-casts") ||
cstring_equal(option, "no-cast")) {
c_out_info_set_casts(c_out_info, FALSE);
} else if (cstring_equal(option, "unreachable-macros") ||
cstring_equal(option, "unreachable-macro")) {
c_out_info_set_unreachable(c_out_info, TRUE);
} else if (cstring_equal(option, "unreachable-comments") ||
cstring_equal(option, "unreachable-comment")) {
c_out_info_set_unreachable(c_out_info, FALSE);
} else if (cstring_equal(option, "lines") ||
cstring_equal(option, "line")) {
c_out_info_set_lines(c_out_info, TRUE);
} else if (cstring_equal(option, "no-lines") ||
cstring_equal(option, "no-line")) {
c_out_info_set_lines(c_out_info, FALSE);
} else {
CStringP lang;
lang = (ansi ? "ansi-c" : "pre-ansi-c");
E_bad_language_option(lang, option);
}
}
return((GenericP)c_out_info);
}
static GenericP
main_init_ansi_c(OutputInfoP out_info, CStringListP options)
{
return(main_init_c(out_info, options, TRUE));
}
static GenericP
main_init_pre_ansi_c(OutputInfoP out_info, CStringListP options)
{
return(main_init_c(out_info, options, FALSE));
}
static void
main_input_c(GenericP gclosure, GrammarP grammar)
{
COutputInfoP c_out_info = (COutputInfoP)gclosure;
OutputInfoP out_info = c_out_info_info(c_out_info);
CLexerStreamT clstream;
c_lexer_init(&clstream, out_info_get_istream(out_info, (unsigned)1));
c_current_stream = &clstream;
c_current_out_info = c_out_info;
c_current_table = grammar_table(grammar);
c_parse_grammar();
c_lexer_close(&clstream);
if (error_max_reported_severity() >= ERROR_SEVERITY_ERROR) {
exit(EXIT_FAILURE);
UNREACHED;
}
c_check_grammar(grammar);
}
static void
main_output_c(GenericP gclosure, GrammarP grammar)
{
COutputInfoP c_out_info = (COutputInfoP)gclosure;
grammar_compute_mutations(grammar);
out_info_set_current_ostream(c_out_info_info(c_out_info), (unsigned)0);
c_output_parser(c_out_info, grammar);
out_info_set_current_ostream(c_out_info_info(c_out_info), (unsigned)1);
c_output_header(c_out_info, grammar);
}
static GenericP
main_init_test(OutputInfoP info, CStringListP options)
{
CStringListEntryP entry;
UNUSED(info);
for (entry = cstring_list_head(options); entry;
entry = cstring_list_entry_deallocate(entry)) {
CStringP option = cstring_list_entry_string(entry);
E_bad_language_option("test", option);
}
return(NIL(GenericP));
}
static void
main_input_test(GenericP gclosure, GrammarP grammar)
{
UNUSED(gclosure);
UNUSED(grammar);
}
static void
main_output_test(GenericP gclosure, GrammarP grammar)
{
UNUSED(gclosure);
UNUSED(grammar);
}
/*--------------------------------------------------------------------------*/
static BoolT main_did_one_off = FALSE;
static BoolT main_did_other = FALSE;
static OutputInfoP main_info_closure;
static CStringListT main_language_options;
static OStreamT dump_stream;
static PhaseListT main_phase_list[] = {
{"singles", rule_set_inline_singles},
{"tail", rule_set_inline_tail_calls},
{"basics", rule_set_inline_all_basics},
{"other", rule_set_inline_non_tail_calls},
{"multi", rule_set_multiple_inlining},
{"all", main_handle_phase_all},
{NIL(CStringP), NIL(void(*)(BoolT))}
};
static LangListT main_language_list[] = {
{"ansi-c", main_init_ansi_c, main_input_c, 2, main_output_c, 2},
{"pre-ansi-c", main_init_pre_ansi_c, main_input_c, 2, main_output_c, 2},
{"iso-c", main_init_ansi_c, main_input_c, 2, main_output_c, 2},
{"pre-iso-c", main_init_pre_ansi_c, main_input_c, 2, main_output_c, 2},
{"test", main_init_test, main_input_test, 1, main_output_test, 0},
{NIL(CStringP), NIL(GenericP(*)(OutputInfoP, CStringListP)),
NIL(void(*)(GenericP, GrammarP)), 0,
NIL(void(*)(GenericP, GrammarP)), 0}
};
static LangListP main_language = &(main_language_list[0]);
/*--------------------------------------------------------------------------*/
static void
main_handle_dump_file(CStringP option, ArgUsageP usage, GenericP gclosure,
CStringP dump_file)
{
UNUSED(option);
UNUSED(usage);
UNUSED(gclosure);
main_did_other = TRUE;
if (ostream_is_open(&dump_stream)) {
E_multiple_dump_files();
UNREACHED;
} else if (!ostream_open(&dump_stream, dump_file)) {
E_cannot_open_dump_file(dump_file);
UNREACHED;
}
}
static void
main_handle_help(CStringP option, ArgUsageP usage, GenericP gclosure)
{
UNUSED(option);
UNUSED(gclosure);
main_did_one_off = TRUE;
write_arg_usage(ostream_error, usage);
write_newline(ostream_error);
ostream_flush(ostream_error);
}
static void
main_handle_factor_limit(CStringP option, ArgUsageP usage, GenericP gclosure,
CStringP limit_str)
{
unsigned limit;
UNUSED(option);
UNUSED(usage);
UNUSED(gclosure);
main_did_other = TRUE;
if ((!cstring_to_unsigned(limit_str, &limit)) || (limit == 0)) {
E_bad_factor_limit(limit_str);
UNREACHED;
}
rule_set_factor_limit(limit);
}
static void
main_handle_inlining(CStringP option, ArgUsageP usage, GenericP gclosure,
CStringP inline_str)
{
UNUSED(option);
UNUSED(usage);
UNUSED(gclosure);
main_did_other = TRUE;
while (*inline_str) {
BoolT enable = TRUE;
DStringT dstring;
CStringP phase;
PhaseListP entry;
if ((syntax_downcase(inline_str[0]) == 'n') &&
(syntax_downcase(inline_str[1]) == 'o')) {
inline_str += 2;
enable = FALSE;
}
dstring_init(&dstring);
while ((*inline_str) && (*inline_str != ',')) {
dstring_append_char(&dstring, syntax_downcase(*inline_str++));
}
if (*inline_str == ',') {
inline_str++;
}
phase = dstring_destroy_to_cstring(&dstring);
for (entry = main_phase_list; entry->phase; entry++) {
if (cstring_equal(phase, entry->phase)) {
if (entry->proc) {
(*(entry->proc))(enable);
}
goto next;
}
}
E_bad_inlining_phase(phase);
UNREACHED;
next:;
}
}
static void
main_handle_language(CStringP option, ArgUsageP usage, GenericP gclosure,
CStringP language_str)
{
LangListP entry;
UNUSED(option);
UNUSED(usage);
UNUSED(gclosure);
main_did_other = TRUE;
for (entry = main_language_list; entry->language; entry++) {
if (cstring_equal(language_str, entry->language)) {
main_language = entry;
return;
}
}
E_bad_language(language_str);
UNREACHED;
}
static void
main_handle_show_errors(CStringP option, ArgUsageP usage, GenericP gclosure)
{
UNUSED(option);
UNUSED(usage);
UNUSED(gclosure);
main_did_one_off = TRUE;
write_error_file(ostream_output);
ostream_flush(ostream_output);
}
static void
main_handle_switch(CStringP option, ArgUsageP usage, GenericP gclosure,
CStringP opt)
{
UNUSED(option);
UNUSED(usage);
UNUSED(gclosure);
main_did_other = TRUE;
cstring_list_append(&main_language_options, opt);
}
static void
main_handle_tab_width(CStringP option, ArgUsageP usage, GenericP gclosure,
CStringP width_str)
{
unsigned width;
UNUSED(option);
UNUSED(usage);
UNUSED(gclosure);
main_did_other = TRUE;
if ((!cstring_to_unsigned(width_str, &width)) || (width == 0)) {
E_bad_tab_width(width_str);
UNREACHED;
}
out_info_set_tab_width(main_info_closure, width);
}
static void
main_handle_version(CStringP option, ArgUsageP usage, GenericP gclosure)
{
UNUSED(option);
UNUSED(usage);
UNUSED(gclosure);
main_did_one_off = TRUE;
write_cstring(ostream_error, VERSION);
write_cstring(ostream_error, " (Release ");
write_cstring(ostream_error, RELEASE);
write_cstring(ostream_error, ")");
write_cstring(ostream_error, BANNER);
write_newline(ostream_error);
ostream_flush(ostream_error);
}
/*--------------------------------------------------------------------------*/
static EStringDataT main_description_strings[] = {
UB {
"description of dump-file",
" FILE\n\tCause intermediate grammars to be written to FILE."
} UE, UB {
"description of help",
"\n\tDisplay an option summary for the current mode."
} UE, UB {
"description of factor-limit",
" NUMBER\n\tSet the maximum number of rules to be generated during factorisation."
} UE, UB {
"description of inlining",
" INLINES\n\tSet which classes of rule are inlined.\n\tShould be any of 'SINGLES', 'BASICS', 'TAIL', 'OTHER', 'MULTI', or 'ALL'."
} UE, UB {
"description of language",
" LANGUAGE\n\tSet the language for the output parser."
} UE, UB {
"description of show-errors",
"\n\tDisplay the current error table on the standard output."
} UE, UB {
"description of switch",
" OPTION\n\tPass OPTION to language specific option parser."
} UE, UB {
"description of tab-width",
" NUMBER\n\tSet the number of spaces in a tab character."
} UE, UB {
"description of version",
"\n\tDisplay the version number on the standard error."
} UE, ERROR_END_STRING_LIST
};
#ifdef __TenDRA__
/* Some conversions to ArgProcP are slightly suspect */
#pragma TenDRA begin
#pragma TenDRA conversion analysis (pointer-pointer) off
#endif
static ArgListT main_arglist[] = {
{
"dump-file", 'd', AT_FOLLOWING,
(ArgProcP)main_handle_dump_file, NIL(GenericP),
UB "description of dump-file" UE
}, {
"factor-limit", 'f', AT_FOLLOWING,
(ArgProcP)main_handle_factor_limit, NIL(GenericP),
UB "description of factor-limit" UE
}, {
"help", '?', AT_EMPTY,
(ArgProcP)main_handle_help, NIL(GenericP),
UB "description of help" UE
}, {
"inline", 'i', AT_FOLLOWING,
(ArgProcP)main_handle_inlining, NIL(GenericP),
UB "description of inlining" UE
}, {
"language", 'l', AT_FOLLOWING,
(ArgProcP)main_handle_language, NIL(GenericP),
UB "description of language" UE
}, {
"show-errors", 'e', AT_EMPTY,
(ArgProcP)main_handle_show_errors, NIL(GenericP),
UB "description of show-errors" UE
}, {
"switch", 's', AT_FOLLOWING,
(ArgProcP)main_handle_switch, NIL(GenericP),
UB "description of switch" UE
}, {
"tab-width", 't', AT_FOLLOWING,
(ArgProcP)main_handle_tab_width, NIL(GenericP),
UB "description of tab-width" UE
}, {
"version", 'v', AT_EMPTY,
(ArgProcP)main_handle_version, NIL(GenericP),
UB "description of version" UE
}, ARG_PARSE_END_LIST
};
#ifdef __TenDRA__
#pragma TenDRA end
#endif
/*--------------------------------------------------------------------------*/
static void
main_init(int argc, char **argv, OutputInfoP out_info)
{
EStringP usage_estring = error_define_string("sid usage message", USAGE);
ArgUsageT closure;
CStringP error_file;
int skip;
unsigned i;
unsigned num_infiles;
unsigned num_outfiles;
error_init(argv[0], gen_errors_init_errors);
error_intern_strings(main_description_strings);
if ((error_file = getenv("SID_ERROR_FILE")) != NIL(CStringP)) {
error_file_parse(error_file, FALSE);
}
closure.usage = error_string_contents(usage_estring);
closure.arg_list = main_arglist;
main_info_closure = out_info;
arg_parse_intern_descriptions(main_arglist);
skip = arg_parse_arguments(main_arglist, usage_estring, --argc, ++argv);
argc -= skip;
argv += skip;
if (main_did_one_off && (!main_did_other) && (argc == 0)) {
exit(EXIT_SUCCESS);
UNREACHED;
}
num_infiles = main_language->num_input_files;
num_outfiles = main_language->num_output_files;
if ((unsigned)argc != (num_infiles + num_outfiles)) {
E_usage(main_language->language, num_infiles, num_outfiles, &closure);
UNREACHED;
}
out_info_set_num_input_files(out_info, num_infiles);
out_info_set_num_output_files(out_info, num_outfiles);
for (i = 0; i < num_infiles; i++) {
CStringP name = argv[i];
if (!istream_open(out_info_get_istream(out_info, i), name)) {
E_cannot_open_input_file(name);
UNREACHED;
}
out_info_set_infile_name(out_info, i, name);
}
for (i = 0; i < num_outfiles; i++) {
CStringP name = argv[num_infiles + i];
if (!ostream_open(out_info_get_ostream(out_info, i), name)) {
E_cannot_open_output_file(name);
UNREACHED;
}
out_info_set_outfile_name(out_info, i, name);
}
}
static void
main_dump_grammar(OStreamP dstream, GrammarP grammar, CStringP mesg)
{
if (dstream) {
write_cstring(dstream, mesg);
write_newline(dstream);
write_newline(dstream);
write_grammar(dstream, grammar);
}
}
static void
main_abort_if_errored(void)
{
if (error_max_reported_severity() >= ERROR_SEVERITY_ERROR) {
exit(EXIT_FAILURE);
UNREACHED;
}
}
static void
main_1(OutputInfoP out_info, OStreamP dstream)
{
LexerStreamT lstream;
GrammarT grammar;
GenericP output_closure;
output_closure = (*(main_language->init_proc))(out_info,
&main_language_options);
grammar_init(&grammar);
lexer_init(&lstream, out_info_get_istream(out_info, (unsigned)0));
sid_current_stream = &lstream;
sid_current_grammar = &grammar;
sid_parse_grammar();
lexer_close(&lstream);
main_abort_if_errored();
grammar_check_complete(&grammar);
main_abort_if_errored();
(*(main_language->input_proc))(output_closure, &grammar);
main_abort_if_errored();
main_dump_grammar(dstream, &grammar, "Original grammar:");
grammar_remove_left_recursion(&grammar);
main_dump_grammar(dstream, &grammar, "After left recursion elimination:");
main_abort_if_errored();
grammar_compute_first_sets(&grammar);
main_abort_if_errored();
grammar_factor(&grammar);
main_dump_grammar(dstream, &grammar, "After factorisation:");
main_abort_if_errored();
grammar_simplify(&grammar);
main_dump_grammar(dstream, &grammar, "After simplification:");
grammar_compute_inlining(&grammar);
grammar_check_collisions(&grammar);
main_dump_grammar(dstream, &grammar, "After everything:");
main_abort_if_errored();
grammar_recompute_alt_names(&grammar);
if (dstream) {
ostream_close(dstream);
}
(*(main_language->output_proc))(output_closure, &grammar);
}
/*--------------------------------------------------------------------------*/
int
main(int argc, char **argv)
{
HANDLE {
OutputInfoT out_info;
istream_setup();
ostream_setup();
out_info_init(&out_info, argv[0]);
ostream_init(&dump_stream);
cstring_list_init(&main_language_options);
main_init(argc, argv, &out_info);
if (ostream_is_open(&dump_stream)) {
main_1(&out_info, &dump_stream);
} else {
main_1(&out_info, NIL(OStreamP));
}
} WITH {
ExceptionP exception = EXCEPTION_EXCEPTION();
if (exception == XX_dalloc_no_memory) {
E_no_memory();
UNREACHED;
} else if (exception == XX_istream_read_error) {
CStringP file = (CStringP)EXCEPTION_VALUE();
E_read_error(file);
UNREACHED;
} else if (exception == XX_ostream_write_error) {
CStringP file = (CStringP)EXCEPTION_VALUE();
E_write_error(file);
UNREACHED;
} else {
RETHROW();
UNREACHED;
}
} END_HANDLE
exit(EXIT_SUCCESS);
UNREACHED;
}
/*
* Local variables(smf):
* compile-command: "build_sid"
* eval: (include::add-path-entry "os-interface" "library" "transforms")
* eval: (include::add-path-entry "parser" "output" "c-output" "c-input")
* eval: (include::add-path-entry "generated")
* End:
**/