Ejemplo n.º 1
0
void main()
{
    // initialisation of ECLiPSe
    ec_set_option_ptr(EC_OPTION_DEFAULT_MODULE, "ptc_solver");
    ec_init();

    //quiet();

    // loading of the solver
    post_goal(term(EC_functor("lib", 1), "ptc_solver"));
    printf("ECLiPSe and the PTC solver are being loaded ...\n");
    if (EC_resume()==EC_succeed) printf("The PTC Solver has been loaded\n");
    else printf("Error: The PTC Solver did not load properly\n");

    // initialisation of the solver
    submit_string("ptc_solver__clean_up, ptc_solver__default_declarations");
    printf("The PTC Solver is initialised\n");

    //output file
    log = fopen("latest run.log", "w");

    printf("The PTC Solver is running\n");

    //calling a demonstration session
    session3();

    printf("The PTC Solver has finished\n");

    //Unloading ECLiPSe and tidying up
    ec_cleanup();

    printf("ECLiPSe and the PTC Solver have been unloaded\n\n");

    fclose(log);
}//main
Ejemplo n.º 2
0
void PuttyFinalize()
{
  if (SaveRandomSeed)
  {
    random_save_seed();
  }
  random_unref();

  sk_cleanup();
#ifndef __linux__
  win_misc_cleanup();
  win_secur_cleanup();
#endif
  ec_cleanup();
}
Ejemplo n.º 3
0
main(int argc, char **argv)
{
    char *	eclipsedir = (char *) 0;
    int		c, new_argc, err;
    int		init_flags = INIT_SHARED|INIT_PRIVATE|INIT_ENGINE|INIT_PROCESS;
    char *	session, * nsrv_hostname;
    unsigned    nsrv_port_number;
    uword	size;

    /*
     * If stdio is not a tty, get rid of the console window. This is not ideal
     * since the window flashes up briefly, but no better solution yet.
     * (The correct way would be not to build eclipse.exe as a "console
     * application" and have a WinMain() instead of main(). But then we have
     * to do all the setup of stdin/out/err, argc/argv, environment etc
     * ourselves)
     */
    if (!isatty(_fileno(stdin))
            && !isatty(_fileno(stdout))
            && !isatty(_fileno(stderr)))
    {
        FreeConsole();
    }

    /*
     * collect information from the command line
     * remove some internally used arguments from the command line
     */
    for (c = new_argc = 1; c < argc; )
    {
        if (argv[c][0] == '-' && argv[c][2] == 0)	/* single char opt */
        {
            switch (argv[c][1])
            {
            case 'a':			/* -a <worker> <session>
                                              <nsrv_hostname> <nsrv_port_no> */
                if (++c + 4 > argc) usage(argv[c-1]);
                ec_set_option_int(EC_OPTION_PARALLEL_WORKER, atoi(argv[c++]));
                session = argv[c++];
                nsrv_hostname = argv[c++];
                nsrv_port_number = atoi(argv[c++]);
                break;

            case 'c':				/* -c <shared_map_file> */
                if (++c + 1 > argc) usage(argv[c-1]);
                ec_set_option_ptr(EC_OPTION_MAPFILE, argv[c++]);
                ec_set_option_int(EC_OPTION_ALLOCATION, ALLOC_FIXED);
                init_flags &= ~INIT_SHARED;
                break;

            case 'm':				/* -m <shared_map_file> */
                if (++c + 1 > argc) usage(argv[c-1]);
                ec_set_option_ptr(EC_OPTION_MAPFILE, argv[c++]);
                ec_set_option_int(EC_OPTION_ALLOCATION, ALLOC_FIXED);
                break;

            case 'b':				/* -b <bootfile> */
                argv[new_argc++] = argv[c];		/* shift */
                if (++c + 1 > argc) usage(argv[c-1]);
                argv[new_argc++] = argv[c++];		/* shift */
                break;

            case 'e':				/* -e <goal> */
                argv[new_argc++] = argv[c];		/* shift */
                if (++c + 1 > argc) usage(argv[c-1]);
                argv[new_argc++] = argv[c++];		/* shift */
                break;

            case 'g':				/* -g <size> */
                argv[new_argc++] = argv[c];		/* shift */
                if (++c + 1 > argc) usage(argv[c-1]);
                argv[new_argc++] = argv[c];		/* shift */
                size = sizearg(argv[c++]);
                ec_set_option_long(EC_OPTION_GLOBALSIZE, size);
                if (size < MIN_GLOBAL) {
                    fprintf(stderr,"Global stack size out of range\n");
                    exit(-1);
                }
                break;

            case 'd':				/* -d <n> */
                /* delay worker startup by <n> seconds */
                if (++c + 1 > argc) usage(argv[c-1]);
                Sleep(1000 * atoi(argv[c++]));
                break;

            case 'D':				/* -D <eclipsedir> */
                if (++c + 1 > argc) usage(argv[c-1]);
                eclipsedir = argv[c++];
                break;

            case 'l':				/* -l <size> */
                argv[new_argc++] = argv[c];		/* shift */
                if (++c + 1 > argc) usage(argv[c-1]);
                argv[new_argc++] = argv[c];		/* shift */
                size = sizearg(argv[c++]);
                ec_set_option_long(EC_OPTION_LOCALSIZE, size);
                if (size < MIN_LOCAL) {
                    fprintf(stderr,"Local stack size out of range\n");
                    exit(-1);
                }
                break;

            case 'h':				/* -h <size> */
                argv[new_argc++] = argv[c];		/* shift */
                if (++c + 1 > argc) usage(argv[c-1]);
                argv[new_argc++] = argv[c];		/* shift */
                size = sizearg(argv[c++]);
                ec_set_option_long(EC_OPTION_PRIVATESIZE, size);
                if (size < MIN_PRIVATE) {
                    fprintf(stderr,"Private heap size out of range\n");
                    exit(-1);
                }
                break;

            case 's':				/* -s <size> */
                argv[new_argc++] = argv[c];		/* shift */
                if (++c + 1 > argc) usage(argv[c-1]);
                argv[new_argc++] = argv[c];		/* shift */
                size = sizearg(argv[c++]);
                ec_set_option_long(EC_OPTION_SHAREDSIZE, size);
                if (size < MIN_SHARED) {
                    fprintf(stderr,"Shared heap size out of range\n");
                    exit(-1);
                }
                break;

            case 'o':				/* enable oracles */
                c += 1;
                /* vm_options = ORACLES_ENABLED; */
                break;

            case '-':				/* -- give the rest to Prolog */
                for (; c < argc; )
                    argv[new_argc++] = argv[c++];
                break;

            default:				/* unknown: error */
                usage(argv[c]);
                break;
            }
        }
        else if (!strcmp(argv[c], "-debug_level"))
        {
            if (++c + 1 > argc) usage(argv[c-1]);
            ec_set_option_int(EC_OPTION_DEBUG_LEVEL, atoi(argv[c++]));
        }
        else /* raise error unless preceeded by a -- option */
        {
            usage(argv[c]);
        }
    }

    /*----------------------------------------------------------------
     * Entry point after longjmp(reset)
     *----------------------------------------------------------------*/

    switch (setjmp(reset))
    {
    case 0:		/* raw boot or -r from above */
        break;
    case 3:		/* restore program state */
    case 2:
        init_flags = REINIT_SHARED|INIT_ENGINE|INIT_PRIVATE;
        break;
    case 4:		/* restore execution state */
        init_flags = REINIT_SHARED|INIT_PRIVATE;
        break;
    case 1:		/* reset after fatal error */
    default:
        init_flags = INIT_ENGINE;
        switch (memory_corrupted++)
        {
        case 0:
            break;

        case 1:
            /* try to print a message */
            memory_corrupted = 2;
            fprintf(stderr,"\n*** SEPIA Fatal error: memory corrupted\n");
        /* fall to */
        case 2:
            /* we couldn't even print the message */
            exit(-1);
        }
        break;
    }

    /*
     * set up our own panic function which longjumps back to reset
     */
    ec_set_option_ptr(EC_OPTION_PANIC, main_panic);

    ec_set_option_int(EC_OPTION_INIT, init_flags);
    ec_set_option_int(EC_OPTION_ARGC, new_argc);
    ec_set_option_ptr(EC_OPTION_ARGV, argv);
    if (eclipsedir)
        ec_set_option_ptr(EC_OPTION_ECLIPSEDIR, eclipsedir);

    ec_init();
    ec_post_goal(ec_term(ec_did(":",2), ec_atom(ec_did("sepia_kernel",0)),
                         ec_atom(ec_did("standalone_toplevel",0))));
    do {
        err = ec_resume();
    } while (err == PYIELD);
    ec_cleanup();
    return err;
}
Ejemplo n.º 4
0
int
main(int argc, char **argv)
{
    char	bootfile_buf[MAX_PATH_LEN];
    char *	initfile = (char *) 0;
    char *	eclipsedir = (char *) 0;
    int		c, new_argc;
    pword	goal, module;
    int		err;
    int		init_flags = INIT_SHARED|INIT_PRIVATE|INIT_ENGINE|INIT_PROCESS;
    unsigned	startup_delay = 0;
    int		vm_options = 0;
    char *	session, * nsrv_hostname;
    unsigned    nsrv_port_number;

#ifdef PROFILE
    moncontrol(0);	/* disable profiling by default */
#endif

    /*
     * collect information from the command line
     * remove some internally used arguments from the command line
     */
    for (c = new_argc = 1; c < argc; )
    {
        if (argv[c][0] == '-' && argv[c][2] == 0)	/* single char opt */
        {
            switch (argv[c][1])
            {
            case 'a':			/* -a <worker> <session>
                                              <nsrv_hostname> <nsrv_port_no> */
                if (++c + 4 > argc) usage(argv[c-1]);
                ec_options.parallel_worker = atoi(argv[c++]);
                session = argv[c++];
                nsrv_hostname = argv[c++];
                nsrv_port_number = atoi(argv[c++]);
                break;

            case 'c':				/* -c <shared_map_file> */
                if (++c + 1 > argc) usage(argv[c-1]);
                ec_options.mapfile = argv[c++];
                ec_options.allocation = ALLOC_FIXED;
                init_flags &= ~INIT_SHARED;
                break;

            case 'm':				/* -m <shared_map_file> */
                if (++c + 1 > argc) usage(argv[c-1]);
                ec_options.mapfile = argv[c++];
                ec_options.allocation = ALLOC_FIXED;
                break;

            case 'b':				/* -b <bootfile> */
                argv[new_argc++] = argv[c];		/* shift */
                if (++c + 1 > argc) usage(argv[c-1]);
                argv[new_argc++] = argv[c++];		/* shift */
                break;

            case 'e':				/* -e <goal> */
                argv[new_argc++] = argv[c];		/* shift */
                if (++c + 1 > argc) usage(argv[c-1]);
                argv[new_argc++] = argv[c++];		/* shift */
                break;

            case 'g':				/* -g <size> */
                argv[new_argc++] = argv[c];		/* shift */
                if (++c + 1 > argc) usage(argv[c-1]);
                argv[new_argc++] = argv[c];		/* shift */
                ec_options.globalsize = sizearg(argv[c++]);
                if (ec_options.globalsize < MIN_GLOBAL) {
                    ec_bad_exit("ECLiPSe: Global stack size out of range.");
                }
                break;

            case 'd':				/* -d <n> */
                /* delay worker startup by <n> seconds */
                if (++c + 1 > argc) usage(argv[c-1]);
                startup_delay = atoi(argv[c++]);
                if (startup_delay == 0)
                    ec_options.io_option = OWN_IO;	/* every worker has its own i/o */
                else
                    sleep(startup_delay);
                break;

            case 'D':				/* -D <eclipsedir> */
                if (++c + 1 > argc) usage(argv[c-1]);
                eclipsedir = argv[c++];
                break;

            case 'l':				/* -l <size> */
                argv[new_argc++] = argv[c];		/* shift */
                if (++c + 1 > argc) usage(argv[c-1]);
                argv[new_argc++] = argv[c];		/* shift */
                ec_options.localsize = sizearg(argv[c++]);
                if (ec_options.localsize < MIN_LOCAL) {
                    ec_bad_exit("ECLiPSe: local stack size out of range.");
                }
                break;

            case 'h':				/* -h <size> */
                argv[new_argc++] = argv[c];		/* shift */
                if (++c + 1 > argc) usage(argv[c-1]);
                argv[new_argc++] = argv[c];		/* shift */
                ec_options.privatesize = sizearg(argv[c++]);
                if (ec_options.privatesize < MIN_PRIVATE) {
                    ec_bad_exit("ECLiPSe: Private heap size out of range.");
                }
                break;

            case 's':				/* -s <size> */
                argv[new_argc++] = argv[c];		/* shift */
                if (++c + 1 > argc) usage(argv[c-1]);
                argv[new_argc++] = argv[c];		/* shift */
                ec_options.sharedsize = sizearg(argv[c++]);
                if (ec_options.sharedsize < MIN_SHARED) {
                    ec_bad_exit("ECLiPSe: Shared heap size out of range.");
                }
                break;

            case 'o':				/* enable oracles */
                c += 1;
                vm_options = ORACLES_ENABLED;
                break;

            case 'p':
                argv[new_argc++] = argv[c];		/* shift */
                if (++c + 1 > argc) usage(argv[c-2]);
                argv[new_argc++] = argv[c];		/* shift */
                ec_options.option_p = atoi(argv[c++]);
                break;

            case '-':				/* -- give the rest to Prolog */
                for (; c < argc;)
                    argv[new_argc++] = argv[c++];
                break;

            default:				/* unknown: error */
                usage(argv[c]);
                break;
            }
        }
        else if (!strcmp(argv[c], "-debug_level"))
        {
            if (++c + 1 > argc) usage(argv[c-1]);
            ec_options.debug_level = atoi(argv[c++]);
        }
        else if (!strcmp(argv[c], "-layout"))
        {
            int	lflags = 0;
            char	*from = 0;
            char	*to = 0;
            long	increment = 0L;

            if (++c + 1 <= argc)
                lflags = (int) strtol(argv[c++], (char **) 0, 16);
            if (c + 1 <= argc)
                increment = strtol(argv[c++], (char **) 0, 16);
            if (c + 1 <= argc)
                from = (char *) strtol(argv[c++], (char **) 0, 16);
            if (c + 1 <= argc)
                to = (char *) strtol(argv[c++], (char **) 0, 16);

            if (ec_options.allocation == ALLOC_FIXED)
                mem_layout();
#ifdef HAVE_MMAP
            ec_layout(lflags, from, to, increment);
#else
            ec_bad_exit("ECLiPSe: The -layout scan is not supported without\nmemory mapping.");
#endif
        }
        else if (!strcmp(argv[c], "-norl"))
        {
            argv[new_argc++] = argv[c++];		/* shift */
            ec_options.rl = 0;
        }
        else /* raise error unless preceeded by a -- option */
        {
            usage(argv[c]);
        }
    }

    /*----------------------------------------------------------------
     * Initialize private heap as early as possible
     * (must be before setup_mps())
     *----------------------------------------------------------------*/
    malloc_init();
    irq_lock_init(delayed_break);

    /*----------------------------------------------------------------
     * Init message passing system
     *----------------------------------------------------------------*/
    if (ec_options.parallel_worker)
    {
        setup_mps(ec_options.parallel_worker, session, nsrv_hostname,
                  nsrv_port_number, init_flags & INIT_SHARED);
    }

    /*----------------------------------------------------------------
     * Make the connection to the shared heap, if any.
     * Because of mmap problems on some machines this should
     * happen AFTER initializing the message passing system.
     *----------------------------------------------------------------*/
    mem_init(init_flags);	/* depends on -c and -m options */


    /*----------------------------------------------------------------
     * Init parallel scheduler etc.
     *----------------------------------------------------------------*/
    if (ec_options.parallel_worker)
    {
        parallel_init(init_flags);
    }

    /*----------------------------------------------------------------
     * Init the low-level I/O stuff, ie the part which should
     * really not be done by eclipse itself...
     *----------------------------------------------------------------*/
    /* char_io_init();  does not yet exist */


    /*----------------------------------------------------------------
     * Entry point after longjmp(reset)
     *----------------------------------------------------------------*/

    switch (setjmp(reset))
    {
    case 0:		/* raw boot or -r from above */
        break;
    case 3:		/* restore program state */
    case 2:
        init_flags = REINIT_SHARED|INIT_ENGINE|INIT_PRIVATE;
        break;
    case 4:		/* restore execution state */
        init_flags = REINIT_SHARED|INIT_PRIVATE;
        break;
    case 1:		/* reset after fatal error */
    default:
        if (!(GlobalFlags & HEAP_READY) || ec_options.parallel_worker)
        {
            (void) ec_cleanup();
            exit(-1);
        }
        init_flags = INIT_ENGINE;
        switch (memory_corrupted++)
        {
        case 0:
            break;

        case 1:
            /* try to print a message */
            memory_corrupted = 2;
            ec_bad_exit("ECLiPSe: Fatal error, memory corrupted.");
        /* fall to */
        case 2:
            /* we couldn't even print the message */
            exit(-1);
        }
        break;
    }


    /*
     * set up our own panic function which longjumps back to reset
     * To access command line through global variabes
     */
    ec_options.user_panic = main_panic;
    ec_options.Argc = new_argc;
    ec_options.Argv = argv;
    ec_options.eclipse_home = (char *) 0;
    ec_options.init_flags = init_flags;
    if (eclipsedir)
        ec_options.eclipse_home = eclipsedir;


    /*
     * Init the global (shared) eclipse structures, dictionary, code...
     * Maybe load a saved state.
     * Note that we don't have an engine yet!
     */

    eclipse_global_init(init_flags);


    /*----------------------------------------------------------------
     * Setup the Prolog engine
     *----------------------------------------------------------------*/

    /*
     * If we have a PROG_AND_DATA saved state (execution state saved)
     * we are finished and enter the emulator.
     */
    if (!(init_flags & INIT_ENGINE))
    {
        err = restart_emulc();
        (void) ec_cleanup();
        exit(err);
    }

    /*
     * Initialize the Prolog engine
     */
    emu_init(init_flags, vm_options);

    /*
     * If we are not running an already booted eclipse,
     * compile $ECLIPSEDIR/lib/kernel.eco
     */
    if (init_flags & INIT_SHARED)
    {
        char msg[1024];

        initfile = strcat(strcpy(bootfile_buf, ec_eclipse_home), "/lib/kernel.eco");
        if (ec_access(initfile, R_OK) < 0)
        {
            sprintf(msg,
                    "ECLiPSe: Can't find boot file %s!\nPlease check the setting of your ECLIPSEDIR environment variable\nor use the -D <dir> command line option.",
                    initfile);
            ec_bad_exit(msg);
        }

        err = eclipse_boot(initfile);
        if (err != PSUCCEED)
        {
            (void) ec_cleanup();
            exit(err);
        }
    }

    if (init_flags & (INIT_SHARED|REINIT_SHARED))
        GlobalFlags |= HEAP_READY;	/* for the other workers */

    goal = ec_term(ec_did("main",1), ec_long(init_flags & INIT_SHARED ? 0 : 1));
    module.val.did = d_.kernel_sepia;
    module.tag.kernel = ModuleTag(d_.kernel_sepia);

    if (ec_options.parallel_worker <= 1)	/* only or first worker */
    {
        err = main_emulc_noexit(goal.val, goal.tag, module.val, module.tag);
        if (err == PYIELD)
        {
            memory_corrupted = 0;	/* assume it's ok */
            ec_post_goal(ec_term(ec_did(":",2), ec_atom(ec_did("sepia_kernel",0)),
                                 ec_atom(ec_did("standalone_toplevel",0))));
            do {
                err = ec_resume();
            } while (err == PYIELD);
        }
    }
    else
    {
        err = slave_emulc();
    }
    ec_cleanup();
    exit(err);
    /*NOTREACHED*/
}