From a53a740a2a1cb6cbfa58cc79caedd4e947ff1ca0 Mon Sep 17 00:00:00 2001 From: dos-reis Date: Sun, 28 Nov 2010 18:27:48 +0000 Subject: * clef/: Add using directive at toplevel. * etc/: Likewise. * graph/: Likewise. * hyper/: Likewise. * lib/: Likewise. * sman/: Likewise. * Makefile.am (OA_SMAN_TARGETS): New. (OA_GRAPHICS_TARGETS): Likewise. --- src/driver/main.c | 33 ++++++++++--------- src/driver/utils.c | 97 +++++++++++++++++++++++++++--------------------------- src/driver/utils.h | 52 +++++++++++++++-------------- 3 files changed, 93 insertions(+), 89 deletions(-) (limited to 'src/driver') diff --git a/src/driver/main.c b/src/driver/main.c index 7a7bc161..002ccef8 100644 --- a/src/driver/main.c +++ b/src/driver/main.c @@ -48,6 +48,8 @@ #define OPENAXIOM_GLOBAL_ENV "AXIOM" +namespace OpenAxiom { + /* Publish the system exec prefix for use by sub-processes. */ static void publish_systemdir(const char* dir) @@ -87,7 +89,7 @@ upgrade_environment(const char* sysdir) { /* Print configuration info. */ static int -print_configuration_info(openaxiom_command* command) { +print_configuration_info(Command* command) { int i; for (i = 1; i < command->core.argc; ++i) { if (strcmp(command->core.argv[i], "include") == 0) @@ -104,35 +106,35 @@ print_configuration_info(openaxiom_command* command) { return 0; } +} int main(int argc, char* argv[]) { - openaxiom_command command = { }; - openaxiom_driver driver = - openaxiom_preprocess_arguments(&command, argc, argv); + using namespace OpenAxiom; + Command command = { }; + Driver driver = preprocess_arguments(&command, argc, argv); upgrade_environment(command.root_dir); switch (driver) { - case openaxiom_null_driver: + case null_driver: return 0; /* Bye. */ - case openaxiom_config_driver: + case config_driver: return print_configuration_info(&command); - case openaxiom_core_driver: - case openaxiom_script_driver: - case openaxiom_compiler_driver: + case core_driver: + case script_driver: + case compiler_driver: putenv("LC_ALL=C"); setlocale(LC_ALL, ""); - return openaxiom_execute_core(&command, driver); + return execute_core(&command, driver); - case openaxiom_execute_driver: + case execute_driver: return oa_spawn(&command.core, - openaxiom_spawn_flags - (openaxiom_spawn_search_path | openaxiom_spawn_replace)); + SpawnFlags(spawn_search_path | spawn_replace)); - case openaxiom_sman_driver: + case sman_driver: break; default: @@ -143,8 +145,7 @@ main(int argc, char* argv[]) /* Should not happen on MS platforms. */ abort(); #else /* __WIN32__ */ - execv(openaxiom_make_path_for(command.root_dir, openaxiom_sman_driver), - argv); + execv(make_path_for(command.root_dir, sman_driver), argv); perror(strerror(errno)); return -1; #endif /* __WIN32__ */ diff --git a/src/driver/utils.c b/src/driver/utils.c index 6914c5ac..5122ca9b 100644 --- a/src/driver/utils.c +++ b/src/driver/utils.c @@ -37,6 +37,8 @@ #include #include "utils.h" +namespace OpenAxiom { + /* The basename of the file holding the OpenAxiom core executable. */ #define OPENAXIOM_CORE_EXECUTABLE \ "AXIOMsys" OPENAXIOM_EXEEXT @@ -64,7 +66,7 @@ /* Return a path to the running system, either as specified on command line through --system=, or as specified at configuration time. */ const char* -openaxiom_get_systemdir(int argc, char* argv[]) +get_systemdir(int argc, char* argv[]) { int i; @@ -84,15 +86,15 @@ openaxiom_get_systemdir(int argc, char* argv[]) /* Return the path to `driver'. */ static const char* -get_driver_name(openaxiom_driver driver) +get_driver_name(Driver driver) { switch (driver) { - case openaxiom_sman_driver: + case sman_driver: return OPENAXIOM_SMAN_PATH; - case openaxiom_script_driver: - case openaxiom_compiler_driver: - case openaxiom_core_driver: + case script_driver: + case compiler_driver: + case core_driver: return OPENAXIOM_CORE_PATH; default: @@ -103,7 +105,7 @@ get_driver_name(openaxiom_driver driver) /* Return a path for PROG specified as a relative path to PREFIX. */ const char* -openaxiom_make_path_for(const char* prefix, openaxiom_driver driver) +make_path_for(const char* prefix, Driver driver) { const int prefix_length = strlen(prefix); const char* prog = get_driver_name(driver); @@ -116,7 +118,7 @@ openaxiom_make_path_for(const char* prefix, openaxiom_driver driver) /* Allocate a nul-terminated vector for holding pointers to arguments for the base Lisp runtime. */ static void -openaxiom_allocate_argv(openaxiom_command* command, int n) { +openaxiom_allocate_argv(Command* command, int n) { command->rt_argc = n; command->rt_argv = (char**) malloc((n + 1) * sizeof(char*)); command->rt_argv[n] = 0; @@ -125,23 +127,22 @@ openaxiom_allocate_argv(openaxiom_command* command, int n) { /* Build arguments, if any, to be supplied to the runtime system of `driver'. */ void -openaxiom_build_rts_options(openaxiom_command* command, - openaxiom_driver driver) +build_rts_options(Command* command, Driver driver) { switch (driver) { - case openaxiom_config_driver: - case openaxiom_sman_driver: - case openaxiom_execute_driver: - case openaxiom_unknown_driver: + case config_driver: + case sman_driver: + case execute_driver: + case unknown_driver: break; - case openaxiom_core_driver: + case core_driver: break; - case openaxiom_compiler_driver: - case openaxiom_script_driver: + case compiler_driver: + case script_driver: switch (OPENAXIOM_BASE_RTS) { - case openaxiom_gcl_runtime: + case gcl_runtime: openaxiom_allocate_argv(command, 3); command->rt_argv[0] = (char*) "-batch"; command->rt_argv[1] = (char*) "-eval"; @@ -149,7 +150,7 @@ openaxiom_build_rts_options(openaxiom_command* command, (char*) ("(" OPENAXIOM_LISP_CORE_ENTRY_POINT ")"); break; - case openaxiom_sbcl_runtime: + case sbcl_runtime: openaxiom_allocate_argv(command, 4); command->rt_argv[0] = (char*) "--noinform"; command->rt_argv[1] = (char*) "--end-runtime-options"; @@ -157,13 +158,13 @@ openaxiom_build_rts_options(openaxiom_command* command, command->rt_argv[3] = (char*) "--end-toplevel-options"; break; - case openaxiom_clozure_runtime: + case clozure_runtime: openaxiom_allocate_argv(command, 2); command->rt_argv[0] = (char*) "--quiet"; command->rt_argv[1] = (char*) "--batch"; break; - case openaxiom_clisp_runtime: + case clisp_runtime: openaxiom_allocate_argv(command, 2); command->rt_argv[0] = (char*) "--quiet"; command->rt_argv[1] = (char*) "-norc"; @@ -180,9 +181,9 @@ openaxiom_build_rts_options(openaxiom_command* command, } #if OPENAXIOM_USE_SMAN -# define OPENAXIOM_DEFAULT_DRIVER openaxiom_sman_driver +# define OPENAXIOM_DEFAULT_DRIVER sman_driver #else -# define OPENAXIOM_DEFAULT_DRIVER openaxiom_core_driver +# define OPENAXIOM_DEFAULT_DRIVER core_driver #endif @@ -235,44 +236,43 @@ static void print_usage(void) { } /* Determine driver to be used for executing `command'. */ -openaxiom_driver -openaxiom_preprocess_arguments(openaxiom_command* command, - int argc, char** argv) +Driver +preprocess_arguments(Command* command, int argc, char** argv) { int i; int other = 1; int files = 0; - openaxiom_driver driver = openaxiom_unknown_driver; + Driver driver = unknown_driver; - command->root_dir = openaxiom_get_systemdir(argc, argv); + command->root_dir = get_systemdir(argc, argv); for (i = 1; i < argc; ++i) if(strcmp(argv[i], "--no-server") == 0) - driver = openaxiom_core_driver; + driver = core_driver; else if (strcmp(argv[i], "--server") == 0) - driver = openaxiom_sman_driver; + driver = sman_driver; else if (strcmp(argv[i], "--config") == 0) - driver = openaxiom_config_driver; + driver = config_driver; else if (strcmp(argv[i], "--execute") == 0) { - driver = openaxiom_execute_driver; + driver = execute_driver; break; } else if (strcmp(argv[i], "--help") == 0) { print_usage(); - driver = openaxiom_null_driver; + driver = null_driver; break; } else if (strcmp(argv[i], "--version") == 0) { print_version(); - driver = openaxiom_null_driver; + driver = null_driver; break; } else { /* Apparently we will invoke the Core system; we need to pass on this option. */ if (strcmp(argv[i], "--script") == 0) - driver = openaxiom_script_driver; + driver = script_driver; else if(strcmp(argv[i], "--compile") == 0) - driver = openaxiom_compiler_driver; + driver = compiler_driver; else { if (argv[i][0] == '-') /* Maybe option for the driver. */ @@ -289,7 +289,7 @@ openaxiom_preprocess_arguments(openaxiom_command* command, } /* Determine argument vector. */ - if (driver == openaxiom_execute_driver) { + if (driver == execute_driver) { command->core.argc = argc - i - 1; command->core.argv = argv + i + 1; } @@ -298,13 +298,13 @@ openaxiom_preprocess_arguments(openaxiom_command* command, command->core.argv = argv; } - if (driver != openaxiom_null_driver) { + if (driver != null_driver) { /* If we have a file but not instructed to compile, assume we are asked to interpret a script. */ if (files > 0) switch (driver) { - case openaxiom_unknown_driver: - case openaxiom_sman_driver: + case unknown_driver: + case sman_driver: command->core.argc += 1; command->core.argv = (char**) malloc((other + 2) * sizeof(char*)); @@ -312,17 +312,17 @@ openaxiom_preprocess_arguments(openaxiom_command* command, command->core.argv[1] = (char*) "--script"; for (i = 0; i < other; ++i) command->core.argv[2 + i] = argv[1 + i]; - driver = openaxiom_script_driver; + driver = script_driver; break; default: /* Driver specified by user. */ break; } - else if (driver == openaxiom_unknown_driver) + else if (driver == unknown_driver) driver = OPENAXIOM_DEFAULT_DRIVER; command->core.argv[command->core.argc] = NULL; - openaxiom_build_rts_options(command, driver); + build_rts_options(command, driver); } return driver; } @@ -334,10 +334,9 @@ openaxiom_preprocess_arguments(openaxiom_command* command, POSIX systems, this is a non-return function on success. See execv(). */ int -openaxiom_execute_core(const openaxiom_command* command, - openaxiom_driver driver) +execute_core(const Command* command, Driver driver) { - char* execpath = (char*) openaxiom_make_path_for(command->root_dir, driver); + char* execpath = (char*) make_path_for(command->root_dir, driver); #ifdef __WIN32__ char* command_line; int cur = strlen(command->core.argv[0]); @@ -410,11 +409,11 @@ openaxiom_execute_core(const openaxiom_command* command, malloc(sizeof (char*) * (command->rt_argc + command->core.argc + 2)); /* GCL has this oddity that it wants to believe that argv[0] has something to tell about what GCL's own runtime is. Silly. */ - if (OPENAXIOM_BASE_RTS == openaxiom_gcl_runtime) + if (OPENAXIOM_BASE_RTS == gcl_runtime) args[0] = (char*) ""; /* And CLISP wants to believe that argv[0] is where it hides stuff from the saved image. */ - else if (OPENAXIOM_BASE_RTS == openaxiom_clisp_runtime) + else if (OPENAXIOM_BASE_RTS == clisp_runtime) args[0] = execpath; else args[0] = command->core.argv[0]; @@ -442,3 +441,5 @@ openaxiom_execute_core(const openaxiom_command* command, return -1; #endif /* __WIN32__ */ } + +} diff --git a/src/driver/utils.h b/src/driver/utils.h index 8f56ba45..4f973973 100644 --- a/src/driver/utils.h +++ b/src/driver/utils.h @@ -42,45 +42,47 @@ # include #endif +namespace OpenAxiom { + /* A list of drivers for OpenAxiom. */ -enum openaxiom_driver { - openaxiom_unknown_driver, /* unknown driver */ - openaxiom_null_driver, /* do nothing */ - openaxiom_config_driver, /* print out configuration information */ - openaxiom_sman_driver, /* start Superman as master process */ - openaxiom_core_driver, /* start the core system as master process */ - openaxiom_script_driver, /* start the core system in script mode. */ - openaxiom_compiler_driver, /* start the core system in compiler mode. */ - openaxiom_execute_driver /* Execute a command. */ +enum Driver { + unknown_driver, /* unknown driver */ + null_driver, /* do nothing */ + config_driver, /* print out configuration information */ + sman_driver, /* start Superman as master process */ + core_driver, /* start the core system as master process */ + script_driver, /* start the core system in script mode. */ + compiler_driver, /* start the core system in compiler mode. */ + execute_driver /* Execute a command. */ }; /* A list of runtime support systems for OpenAxiom. */ -enum openaxiom_runtime { - openaxiom_unknown_runtime, - openaxiom_gcl_runtime, /* GCL-based runtime */ - openaxiom_sbcl_runtime, /* SBCL-based runtime */ - openaxiom_clisp_runtime, /* CLISP-based runtime */ - openaxiom_ecl_runtime, /* ECL-based runtime */ - openaxiom_clozure_runtime, /* Clozure CL-based runtime */ - openaxiom_bemol_runtime /* Bemol-based runtime */ +enum Runtime { + unknown_runtime, + gcl_runtime, /* GCL-based runtime */ + sbcl_runtime, /* SBCL-based runtime */ + clisp_runtime, /* CLISP-based runtime */ + ecl_runtime, /* ECL-based runtime */ + clozure_runtime, /* Clozure CL-based runtime */ + bemol_runtime /* Bemol-based runtime */ }; /* A description of external command to be executed. */ -struct openaxiom_command { - openaxiom_process core; /* arguments for actual executable. */ +struct Command { + Process core; /* arguments for actual executable. */ char** rt_argv; /* arguments to the base RT, if any. */ int rt_argc; /* number of such arguments. */ const char* root_dir; /* path to the OpenAxiom system. */ }; -const char* openaxiom_get_systemdir(int argc, char*[]); -const char* openaxiom_make_path_for(const char*, openaxiom_driver); +const char* get_systemdir(int argc, char*[]); +const char* make_path_for(const char*, Driver); -int openaxiom_execute_core(const openaxiom_command*, openaxiom_driver); -void openaxiom_build_rts_options(openaxiom_command*, openaxiom_driver); +int execute_core(const Command*, Driver); +void build_rts_options(Command*, Driver); -openaxiom_driver - openaxiom_preprocess_arguments(openaxiom_command*, int, char**); +Driver preprocess_arguments(Command*, int, char**); +} #endif /* OPENAXIOM_UTILS_INCLUDED */ -- cgit v1.2.3