RC_DEPTREE *
_rc_deptree_load(int force, int *regen) {
int fd;
int retval;
int serrno = errno;
int merrno;
time_t t;
char file[PATH_MAX];
struct stat st;
struct utimbuf ut;
FILE *fp;
t = 0;
if (rc_deptree_update_needed(&t, file) || force != 0) {
/* Test if we have permission to update the deptree */
fd = open(RC_DEPTREE_CACHE, O_WRONLY);
merrno = errno;
errno = serrno;
if (fd == -1 && merrno == EACCES)
return rc_deptree_load();
close(fd);
if (regen)
*regen = 1;
ebegin("Caching service dependencies");
retval = rc_deptree_update() ? 0 : -1;
eend (retval, "Failed to update the dependency tree");
if (retval == 0) {
stat(RC_DEPTREE_CACHE, &st);
if (st.st_mtime < t) {
eerror("Clock skew detected with `%s'", file);
eerrorn("Adjusting mtime of `" RC_DEPTREE_CACHE
"' to %s", ctime(&t));
fp = fopen(RC_DEPTREE_SKEWED, "w");
if (fp != NULL) {
fprintf(fp, "%s\n", file);
fclose(fp);
}
ut.actime = t;
ut.modtime = t;
utime(RC_DEPTREE_CACHE, &ut);
} else {
if (exists(RC_DEPTREE_SKEWED))
unlink(RC_DEPTREE_SKEWED);
}
}
if (force == -1 && regen != NULL)
*regen = retval;
}
return rc_deptree_load();
}
/* return number of processed killed, -1 on error */
static int
do_stop(const char *exec, const char *const *argv,
pid_t pid, uid_t uid,int sig,
bool quiet, bool verbose, bool test)
{
RC_PIDLIST *pids;
RC_PID *pi;
RC_PID *np;
bool killed;
int nkilled = 0;
if (pid)
pids = rc_find_pids(NULL, NULL, 0, pid);
else
pids = rc_find_pids(exec, argv, uid, pid);
if (!pids)
return 0;
LIST_FOREACH_SAFE(pi, pids, entries, np) {
if (test) {
if (!quiet)
einfo("Would send signal %d to PID %d",
sig, pi->pid);
nkilled++;
} else {
if (verbose)
ebegin("Sending signal %d to PID %d",
sig, pi->pid);
errno = 0;
killed = (kill(pi->pid, sig) == 0 ||
errno == ESRCH ? true : false);
if (verbose)
eend(killed ? 0 : 1,
"%s: failed to send signal %d to PID %d: %s",
applet, sig, pi->pid, strerror(errno));
if (!killed) {
nkilled = -1;
} else {
if (nkilled != -1)
nkilled++;
}
}
free(pi);
}
free(pids);
return nkilled;
}
int
start_stop_daemon(int argc, char **argv)
{
int devnull_fd = -1;
#ifdef TIOCNOTTY
int tty_fd = -1;
#endif
#ifdef HAVE_PAM
pam_handle_t *pamh = NULL;
int pamr;
const char *const *pamenv = NULL;
#endif
int opt;
bool start = false;
bool stop = false;
bool oknodo = false;
bool test = false;
bool quiet;
bool verbose = false;
char *exec = NULL;
char *startas = NULL;
char *name = NULL;
char *pidfile = NULL;
char *retry = NULL;
int sig = -1;
int nicelevel = 0, ionicec = -1, ioniced = 0;
bool background = false;
bool makepidfile = false;
bool interpreted = false;
bool progress = false;
uid_t uid = 0;
gid_t gid = 0;
char *home = NULL;
int tid = 0;
char *redirect_stderr = NULL;
char *redirect_stdout = NULL;
int stdout_fd;
int stderr_fd;
pid_t pid, spid;
int i;
char *svcname = getenv("RC_SVCNAME");
RC_STRINGLIST *env_list;
RC_STRING *env;
char *tmp, *newpath, *np;
char *p;
char *token;
char exec_file[PATH_MAX];
struct passwd *pw;
struct group *gr;
char line[130];
FILE *fp;
size_t len;
mode_t numask = 022;
char **margv;
unsigned int start_wait = 0;
TAILQ_INIT(&schedule);
#ifdef DEBUG_MEMORY
atexit(cleanup);
#endif
signal_setup(SIGINT, handle_signal);
signal_setup(SIGQUIT, handle_signal);
signal_setup(SIGTERM, handle_signal);
if ((tmp = getenv("SSD_NICELEVEL")))
if (sscanf(tmp, "%d", &nicelevel) != 1)
eerror("%s: invalid nice level `%s' (SSD_NICELEVEL)",
applet, tmp);
/* Get our user name and initial dir */
p = getenv("USER");
home = getenv("HOME");
if (home == NULL || p == NULL) {
pw = getpwuid(getuid());
if (pw != NULL) {
if (p == NULL)
setenv("USER", pw->pw_name, 1);
if (home == NULL) {
setenv("HOME", pw->pw_dir, 1);
home = pw->pw_dir;
}
}
}
while ((opt = getopt_long(argc, argv, getoptstring, longopts,
(int *) 0)) != -1)
switch (opt) {
case 'I': /* --ionice */
if (sscanf(optarg, "%d:%d", &ionicec, &ioniced) == 0)
eerrorx("%s: invalid ionice `%s'",
applet, optarg);
if (ionicec == 0)
ioniced = 0;
else if (ionicec == 3)
ioniced = 7;
ionicec <<= 13; /* class shift */
break;
case 'K': /* --stop */
stop = true;
break;
case 'N': /* --nice */
if (sscanf(optarg, "%d", &nicelevel) != 1)
eerrorx("%s: invalid nice level `%s'",
applet, optarg);
break;
case 'P': /* --progress */
progress = true;
break;
case 'R': /* --retry <schedule>|<timeout> */
retry = optarg;
break;
case 'S': /* --start */
start = true;
break;
case 'b': /* --background */
background = true;
break;
case 'c': /* --chuid <username>|<uid> */
/* DEPRECATED */
ewarn("WARNING: -c/--chuid is deprecated and will be removed in the future, please use -u/--user instead");
case 'u': /* --user <username>|<uid> */
{
p = optarg;
tmp = strsep(&p, ":");
changeuser = xstrdup(tmp);
if (sscanf(tmp, "%d", &tid) != 1)
pw = getpwnam(tmp);
else
pw = getpwuid((uid_t)tid);
if (pw == NULL)
eerrorx("%s: user `%s' not found",
applet, tmp);
uid = pw->pw_uid;
home = pw->pw_dir;
unsetenv("HOME");
if (pw->pw_dir)
setenv("HOME", pw->pw_dir, 1);
unsetenv("USER");
if (pw->pw_name)
setenv("USER", pw->pw_name, 1);
if (gid == 0)
gid = pw->pw_gid;
if (p) {
tmp = strsep (&p, ":");
if (sscanf(tmp, "%d", &tid) != 1)
gr = getgrnam(tmp);
else
gr = getgrgid((gid_t) tid);
if (gr == NULL)
eerrorx("%s: group `%s'"
" not found",
applet, tmp);
gid = gr->gr_gid;
}
}
break;
case 'd': /* --chdir /new/dir */
ch_dir = optarg;
break;
case 'e': /* --env */
putenv(optarg);
break;
case 'g': /* --group <group>|<gid> */
if (sscanf(optarg, "%d", &tid) != 1)
gr = getgrnam(optarg);
else
gr = getgrgid((gid_t)tid);
if (gr == NULL)
eerrorx("%s: group `%s' not found",
applet, optarg);
gid = gr->gr_gid;
break;
case 'i': /* --interpreted */
interpreted = true;
break;
case 'k':
if (parse_mode(&numask, optarg))
eerrorx("%s: invalid mode `%s'",
applet, optarg);
break;
case 'm': /* --make-pidfile */
makepidfile = true;
break;
case 'n': /* --name <process-name> */
name = optarg;
break;
case 'o': /* --oknodo */
/* DEPRECATED */
ewarn("WARNING: -o/--oknodo is deprecated and will be removed in the future");
oknodo = true;
break;
case 'p': /* --pidfile <pid-file> */
pidfile = optarg;
break;
case 's': /* --signal <signal> */
sig = parse_signal(optarg);
break;
case 't': /* --test */
test = true;
break;
case 'r': /* --chroot /new/root */
ch_root = optarg;
break;
case 'a': /* --startas <name> */
/* DEPRECATED */
ewarn("WARNING: -a/--startas is deprecated and will be removed in the future, please use -x/--exec or -n/--name instead");
startas = optarg;
break;
case 'w':
if (sscanf(optarg, "%d", &start_wait) != 1)
eerrorx("%s: `%s' not a number",
applet, optarg);
break;
case 'x': /* --exec <executable> */
exec = optarg;
break;
case '1': /* --stdout /path/to/stdout.lgfile */
redirect_stdout = optarg;
break;
case '2': /* --stderr /path/to/stderr.logfile */
redirect_stderr = optarg;
break;
case_RC_COMMON_GETOPT
}
endpwent();
argc -= optind;
argv += optind;
quiet = rc_yesno(getenv("EINFO_QUIET"));
verbose = rc_yesno(getenv("EINFO_VERBOSE"));
/* Allow start-stop-daemon --signal HUP --exec /usr/sbin/dnsmasq
* instead of forcing --stop --oknodo as well */
if (!start &&
!stop &&
sig != SIGINT &&
sig != SIGTERM &&
sig != SIGQUIT &&
sig != SIGKILL)
oknodo = true;
if (!exec)
exec = startas;
else if (!name)
name = startas;
if (!exec) {
exec = *argv;
if (!exec)
exec = name;
if (name && start)
*argv = name;
} else if (name)
*--argv = name;
else if (exec)
*--argv = exec;
if (stop || sig != -1) {
if (sig == -1)
sig = SIGTERM;
if (!*argv && !pidfile && !name && !uid)
eerrorx("%s: --stop needs --exec, --pidfile,"
" --name or --user", applet);
if (background)
eerrorx("%s: --background is only relevant with"
" --start", applet);
if (makepidfile)
eerrorx("%s: --make-pidfile is only relevant with"
" --start", applet);
if (redirect_stdout || redirect_stderr)
eerrorx("%s: --stdout and --stderr are only relevant"
" with --start", applet);
} else {
if (!exec)
eerrorx("%s: nothing to start", applet);
if (makepidfile && !pidfile)
eerrorx("%s: --make-pidfile is only relevant with"
" --pidfile", applet);
if ((redirect_stdout || redirect_stderr) && !background)
eerrorx("%s: --stdout and --stderr are only relevant"
" with --background", applet);
}
/* Expand ~ */
if (ch_dir && *ch_dir == '~')
ch_dir = expand_home(home, ch_dir);
if (ch_root && *ch_root == '~')
ch_root = expand_home(home, ch_root);
if (exec) {
if (*exec == '~')
exec = expand_home(home, exec);
/* Validate that the binary exists if we are starting */
if (*exec == '/' || *exec == '.') {
/* Full or relative path */
if (ch_root)
snprintf(exec_file, sizeof(exec_file),
"%s/%s", ch_root, exec);
else
snprintf(exec_file, sizeof(exec_file),
"%s", exec);
} else {
/* Something in $PATH */
p = tmp = xstrdup(getenv("PATH"));
*exec_file = '\0';
while ((token = strsep(&p, ":"))) {
if (ch_root)
snprintf(exec_file, sizeof(exec_file),
"%s/%s/%s",
ch_root, token, exec);
else
snprintf(exec_file, sizeof(exec_file),
"%s/%s", token, exec);
if (exists(exec_file))
break;
*exec_file = '\0';
}
free(tmp);
}
}
if (start && !exists(exec_file)) {
eerror("%s: %s does not exist", applet,
*exec_file ? exec_file : exec);
exit(EXIT_FAILURE);
}
/* If we don't have a pidfile we should check if it's interpreted
* or not. If it we, we need to pass the interpreter through
* to our daemon calls to find it correctly. */
if (interpreted && !pidfile) {
fp = fopen(exec_file, "r");
if (fp) {
p = fgets(line, sizeof(line), fp);
fclose(fp);
if (p != NULL && line[0] == '#' && line[1] == '!') {
p = line + 2;
/* Strip leading spaces */
while (*p == ' ' || *p == '\t')
p++;
/* Remove the trailing newline */
len = strlen(p) - 1;
if (p[len] == '\n')
p[len] = '\0';
token = strsep(&p, " ");
strncpy(exec_file, token, sizeof(exec_file));
opt = 0;
for (nav = argv; *nav; nav++)
opt++;
nav = xmalloc(sizeof(char *) * (opt + 3));
nav[0] = exec_file;
len = 1;
if (p)
nav[len++] = p;
for (i = 0; i < opt; i++)
nav[i + len] = argv[i];
nav[i + len] = '\0';
}
}
}
margv = nav ? nav : argv;
if (stop || sig != -1) {
if (sig == -1)
sig = SIGTERM;
if (!stop)
oknodo = true;
if (retry)
parse_schedule(retry, sig);
else if (test || oknodo)
parse_schedule("0", sig);
else
parse_schedule(NULL, sig);
i = run_stop_schedule(exec, (const char *const *)margv,
pidfile, uid, quiet, verbose, test, progress);
if (i < 0)
/* We failed to stop something */
exit(EXIT_FAILURE);
if (test || oknodo)
return i > 0 ? EXIT_SUCCESS : EXIT_FAILURE;
/* Even if we have not actually killed anything, we should
* remove information about it as it may have unexpectedly
* crashed out. We should also return success as the end
* result would be the same. */
if (pidfile && exists(pidfile))
unlink(pidfile);
if (svcname)
rc_service_daemon_set(svcname, exec,
(const char *const *)argv,
pidfile, false);
exit(EXIT_SUCCESS);
}
if (pidfile)
pid = get_pid(pidfile, true);
else
pid = 0;
if (do_stop(exec, (const char * const *)margv, pid, uid,
0, true, false, true) > 0)
eerrorx("%s: %s is already running", applet, exec);
if (test) {
if (quiet)
exit (EXIT_SUCCESS);
einfon("Would start");
while (argc-- >= 0)
printf(" %s", *argv++);
printf("\n");
eindent();
if (uid != 0)
einfo("as user id %d", uid);
if (gid != 0)
einfo("as group id %d", gid);
if (ch_root)
einfo("in root `%s'", ch_root);
if (ch_dir)
einfo("in dir `%s'", ch_dir);
if (nicelevel != 0)
einfo("with a priority of %d", nicelevel);
if (name)
einfo ("with a process name of %s", name);
eoutdent();
exit(EXIT_SUCCESS);
}
if (verbose) {
ebegin("Detaching to start `%s'", exec);
eindent();
}
/* Remove existing pidfile */
if (pidfile)
unlink(pidfile);
if (background)
signal_setup(SIGCHLD, handle_signal);
if ((pid = fork()) == -1)
eerrorx("%s: fork: %s", applet, strerror(errno));
/* Child process - lets go! */
if (pid == 0) {
pid_t mypid = getpid();
umask(numask);
#ifdef TIOCNOTTY
tty_fd = open("/dev/tty", O_RDWR);
#endif
devnull_fd = open("/dev/null", O_RDWR);
if (nicelevel) {
if (setpriority(PRIO_PROCESS, mypid, nicelevel) == -1)
eerrorx("%s: setpritory %d: %s",
applet, nicelevel,
strerror(errno));
}
if (ionicec != -1 &&
ioprio_set(1, mypid, ionicec | ioniced) == -1)
eerrorx("%s: ioprio_set %d %d: %s", applet,
ionicec, ioniced, strerror(errno));
if (ch_root && chroot(ch_root) < 0)
eerrorx("%s: chroot `%s': %s",
applet, ch_root, strerror(errno));
if (ch_dir && chdir(ch_dir) < 0)
eerrorx("%s: chdir `%s': %s",
applet, ch_dir, strerror(errno));
if (makepidfile && pidfile) {
fp = fopen(pidfile, "w");
if (! fp)
eerrorx("%s: fopen `%s': %s", applet, pidfile,
strerror(errno));
fprintf(fp, "%d\n", mypid);
fclose(fp);
}
#ifdef HAVE_PAM
if (changeuser != NULL) {
pamr = pam_start("start-stop-daemon",
changeuser, &conv, &pamh);
if (pamr == PAM_SUCCESS)
pamr = pam_acct_mgmt(pamh, PAM_SILENT);
if (pamr == PAM_SUCCESS)
pamr = pam_open_session(pamh, PAM_SILENT);
if (pamr != PAM_SUCCESS)
eerrorx("%s: pam error: %s",
applet, pam_strerror(pamh, pamr));
}
#endif
if (gid && setgid(gid))
eerrorx("%s: unable to set groupid to %d",
applet, gid);
if (changeuser && initgroups(changeuser, gid))
eerrorx("%s: initgroups (%s, %d)",
applet, changeuser, gid);
if (uid && setuid(uid))
eerrorx ("%s: unable to set userid to %d",
applet, uid);
/* Close any fd's to the passwd database */
endpwent();
#ifdef TIOCNOTTY
ioctl(tty_fd, TIOCNOTTY, 0);
close(tty_fd);
#endif
/* Clean the environment of any RC_ variables */
env_list = rc_stringlist_new();
i = 0;
while (environ[i])
rc_stringlist_add(env_list, environ[i++]);
#ifdef HAVE_PAM
if (changeuser != NULL) {
pamenv = (const char *const *)pam_getenvlist(pamh);
if (pamenv) {
while (*pamenv) {
/* Don't add strings unless they set a var */
if (strchr(*pamenv, '='))
putenv(xstrdup(*pamenv));
else
unsetenv(*pamenv);
pamenv++;
}
}
}
#endif
TAILQ_FOREACH(env, env_list, entries) {
if ((strncmp(env->value, "RC_", 3) == 0 &&
strncmp(env->value, "RC_SERVICE=", 10) != 0 &&
strncmp(env->value, "RC_SVCNAME=", 10) != 0) ||
strncmp(env->value, "SSD_NICELEVEL=", 14) == 0)
{
p = strchr(env->value, '=');
*p = '\0';
unsetenv(env->value);
continue;
}
}
rc_stringlist_free(env_list);
/* For the path, remove the rcscript bin dir from it */
if ((token = getenv("PATH"))) {
len = strlen(token);
newpath = np = xmalloc(len + 1);
while (token && *token) {
p = strchr(token, ':');
if (p) {
*p++ = '\0';
while (*p == ':')
p++;
}
if (strcmp(token, RC_LIBEXECDIR "/bin") != 0 &&
strcmp(token, RC_LIBEXECDIR "/sbin") != 0)
{
len = strlen(token);
if (np != newpath)
*np++ = ':';
memcpy(np, token, len);
np += len;
}
token = p;
}
*np = '\0';
unsetenv("PATH");
setenv("PATH", newpath, 1);
}
stdout_fd = devnull_fd;
stderr_fd = devnull_fd;
if (redirect_stdout) {
if ((stdout_fd = open(redirect_stdout,
O_WRONLY | O_CREAT | O_APPEND,
S_IRUSR | S_IWUSR)) == -1)
eerrorx("%s: unable to open the logfile"
" for stdout `%s': %s",
applet, redirect_stdout, strerror(errno));
}
if (redirect_stderr) {
if ((stderr_fd = open(redirect_stderr,
O_WRONLY | O_CREAT | O_APPEND,
S_IRUSR | S_IWUSR)) == -1)
eerrorx("%s: unable to open the logfile"
" for stderr `%s': %s",
applet, redirect_stderr, strerror(errno));
}
/* We don't redirect stdin as some daemons may need it */
if (background || quiet || redirect_stdout)
dup2(stdout_fd, STDOUT_FILENO);
if (background || quiet || redirect_stderr)
dup2(stderr_fd, STDERR_FILENO);
for (i = getdtablesize() - 1; i >= 3; --i)
close(i);
setsid();
execvp(exec, argv);
#ifdef HAVE_PAM
if (changeuser != NULL && pamr == PAM_SUCCESS)
pam_close_session(pamh, PAM_SILENT);
#endif
eerrorx("%s: failed to exec `%s': %s",
applet, exec,strerror(errno));
}
void
initialize(int argc, char **argv)
{
int i, blkbg;
char *fontname, *p;
rfork(RFNAMEG|RFNOTEG);
fontname = nil;
term = "vt100";
fk = vt100fk;
blkbg = nocolor = 0;
ARGBEGIN{
case '2':
term = "vt220";
fk = vt220fk;
break;
case 'a':
term = "ansi";
fk = ansifk;
break;
case 'b':
blkbg = 1; /* e.g., for linux colored output */
break;
case 'c':
nocolor = 1;
break;
case 'f':
fontname = EARGF(usage());
break;
case 'l':
p = EARGF(usage());
logfd = create(p, OWRITE, 0666);
if(logfd < 0)
sysfatal("could not create log file: %s: %r", p);
break;
case 'x':
fk = xtermfk;
term = "xterm";
break;
default:
usage();
break;
}ARGEND;
host_buf = malloc(host_bsize);
hostp = host_buf;
hostlength = 0;
if(initdraw(0, fontname, term) < 0){
fprint(2, "%s: initdraw failed: %r\n", term);
exits("initdraw");
}
werrstr(""); /* clear spurious error messages */
ebegin(Ehost);
histp = hist;
menu2.item = menutext2;
menu3.item = menutext3;
pagemode = 0;
blocked = 0;
NS = font->height;
CW = stringwidth(font, "m");
red = allocimage(display, Rect(0,0,1,1), screen->chan, 1, DRed);
bordercol = allocimage(display, Rect(0,0,1,1), screen->chan, 1, 0xCCCCCCCC);
cursback = allocimage(display, Rect(0, 0, CW+1, NS+1), screen->chan, 0, DNofill);
for(i=0; i<8; i++){
colors[i] = allocimage(display, Rect(0,0,1,1), screen->chan, 1,
rgbacolors[i]);
hicolors[i] = allocimage(display, Rect(0,0,1,1), screen->chan, 1,
rgbahicolors[i]);
}
bgdefault = (blkbg? display->black: display->white);
fgdefault = (blkbg? display->white: display->black);
bgcolor = bgdefault;
fgcolor = fgdefault;
resize();
if(argc > 0) {
sendnchars(strlen(argv[0]),argv[0]);
sendnchars(1,"\n");
}
}
int main(int argc, char *argv[])
/* Initialize the main stuff. Will be cleaned up later. */
{
int _735;
int _0, _1, _2;
Argc = argc;
Argv = argv;
stack_base = (char *)&_0;
eu_startup(_00, (int)CLOCKS_PER_SEC, (int)sysconf(_SC_CLK_TCK));
init_literal(); /* Sets up all the stuff in init-.c */
shift_args(argc, argv);
_4ELINUX = (3 == 3);
_4EWINDOWS = (3 == 2);
_4EDOS = (3 == 1);
#ifdef ELINUX
_4PATH_SEPARATOR = 58; /* : */
_4SLASH = 47; /* / */
_4SLASH_CHARS = _274;
/* Special chars allowed in path. */
#else
_4PATH_SEPARATOR = 59; /* ; */
_4SLASH = 92; /* \ */
_4SLASH_CHARS = _277; /* \ and / and : */
#endif
_4NOVALUE = _321;
/* For showing that the item has no value. Always on, except for constants. */
_4SymTab = _39;
/* The Symbol Table where almost everything is stored. */
_4file_name = _39;
_4file_name_entered = _39;
_4current_file_no = 1;
_4slist = _39;
_6warning_list = _39;
/* Error list. */
_10buckets = Repeat(0, 2003);
/* For calculating hashes. */
_10literal_init = 0;
RefDS(_39);
_10lastintval = _39;
/* Integers : The values of the integers sent. */
RefDS(_39);
_10lastintsym = _39;
/* Integers : Holds the position of the value. */
/* When integers are made, lastinval and lastintsym are checked to see if we already
have a symbol with that value. If so, we point to it instead of making a new one. */
_10last_sym = 0;
_10SEARCH_LIMIT = 20;
/* How long to search for a double before stopping. */
_10temps_allocated = 0;
/* A counter of how many temps were allocated. Used to allocate the stack for tasks. */
_11start_include = 0;
_11LastLineNumber = -1;
RefDS(_39);
_11all_source = _39; /* Storage spot for trace. */
_11current_source_next = 10000; /* For Scanner.c : Helps allocate for trace. */
_14previous_op = -1; /* For emit.c : Holds the last op we emitted. */
RefDS(_39);
_14current_sequence = _39; /* The current sequence we are working with. */
_14lhs_ptr = 0;
_14assignable = 0; /* For emit.c : Is this routine/op assignable to? */
_15sample_size = 0;
/* For profiling. */
_15max_stack_per_call = 1;
/* Not necessary, since it's always 1. However, backend references it, so i'll
remove it when I get to backend.c */
RefDS(_39);
DeRef(_15branch_list);
_15branch_list = _39;
_15short_circuit = 0;
_15short_circuit_B = 0; /* circuit expression? given short_circuit_B is 1 (TRUE) */
_15factors = 0;
_15lhs_subs_level = -1;
_15left_sym = 0;
RefDS(_3832);
DeRef(_15mix_msg);
_15mix_msg = _3832;
/* For compressing objects in backend. */
_16MIN2B = - 32768;
_16MAX2B = 32767;
_16MIN3B = - 8388608;
_16MAX3B = 8388607;
_735 = power(2, 31);
_16MIN4B = unary_op(UMINUS, _735);
DeRef(_735);
int ptr_;
s1_ptr ptr;
object_ptr Base;
/* Fields for keylist... */
_1 = NewS1(98);
_2 = (int)((s1_ptr)_1)->base;
Base = ((s1_ptr)_1)->base;
/* Set the elements of the keylist. This will be used later to make SymTab. */
e_arg1 = NewString("if");
e_arg2 = 8; e_arg3 = 20; e_arg4 = 0; e_arg5 = 0;
Base[1] = new_key_entry();
/* "if", SC_KEYWORD, IF, 0, 0 */
e_arg1 = NewString("end");
e_arg3 = 402;
Base[2] = new_key_entry();
/* "end", SC_KEYWORD, END, 0, 0 */
e_arg1 = NewString("then");
e_arg3 = 409;
Base[3] = new_key_entry();
/* "then", SC_KEYWORD, THEN, 0, 0 */
e_arg1 = NewString("procedure");
e_arg3 = 405;
Base[4] = new_key_entry();
/* "procedure", SC_KEYWORD, PROCEDURE, 0, 0 */
e_arg1 = NewString("else");
e_arg3 = 23;
Base[5] = new_key_entry();
/* "else", SC_KEYWORD, ELSE, 0, 0 */
e_arg1 = NewString("for");
e_arg3 = 21;
Base[6] = new_key_entry();
/* "for", SC_KEYWORD, FOR, 0, O */
e_arg1 = NewString("return");
e_arg3 = 412;
Base[7] = new_key_entry();
/* "return", SC_KEYWORD, RETURN, 0, 0 */
e_arg1 = NewString("do");
e_arg3 = 410;
Base[8] = new_key_entry();
/* "do", SC_KEYWORD, DO, 0, 0 */
e_arg1 = NewString("elsif");
e_arg3 = 413;
Base[9] = new_key_entry();
/* "elsif", SC_KEYWORD, ELSIF, 0, 0 */
e_arg1 = NewString("while");
e_arg3 = 47;
Base[10] = new_key_entry();
/* "while", SC_KEYWORD, WHILE, 0, 0 */
e_arg1 = NewString("type");
e_arg3 = 415;
Base[11] = new_key_entry();
/* "type", SC_KEYWORD, TYPE_DECL, 0, 0 */
e_arg1 = NewString("constant");
e_arg3 = 416;
Base[12] = new_key_entry();
/* "constant", SC_KEYWORD, CONSTANT, 0, 0 */
e_arg1 = NewString("to");
e_arg3 = 403;
Base[13] = new_key_entry();
/* "to", SC_KEYWORD, TO, 0, 0 */
e_arg1 = NewString("and");
e_arg3 = 8;
Base[14] = new_key_entry();
/* "and", SC_KEYWORD, AND, 0, 0 */
e_arg1 = NewString("or");
e_arg3 = 9;
Base[15] = new_key_entry();
/* "or", SC_KEYWORD, OR, 0, 0 */
e_arg1 = NewString("exit");
e_arg3 = 61;
Base[16] = new_key_entry();
/* "exit", SC_KEYWORD, EXIT, 0, 0 */
e_arg1 = NewString("function");
e_arg3 = 406;
Base[17] = new_key_entry();
/* "function", SC_KEYWORD, FUNCTION, 0, 0 */
e_arg1 = NewString("global");
e_arg3 = 411;
Base[18] = new_key_entry();
/* "global", SC_KEYWORD, GLOBAL, 0, 0 */
e_arg1 = NewString("by");
e_arg3 = 404;
Base[19] = new_key_entry();
/* "by", SC_KEYWORD, BY, 0, 0 */
e_arg1 = NewString("not");
e_arg3 = 7;
Base[20] = new_key_entry();
/* "not", SC_KEYWORD, NOT, 0, 0 */
e_arg1 = NewString("include");
e_arg3 = 417;
Base[21] = new_key_entry();
/* "include", SC_KEYWORD, INCLUDE, 0, 0 */
e_arg1 = NewString("with");
e_arg3 = 419;
Base[22] = new_key_entry();
/* "with", SC_KEYWORD, WITH, 0, 0 */
e_arg1 = NewString("without");
e_arg3 = 420;
Base[23] = new_key_entry();
/* "without", SC_KEYWORD, WITHOUT, 0, 0 */
e_arg1 = NewString("xor");
e_arg3 = 154;
Base[24] = new_key_entry();
/* "xor", SC_KEYWORD, XOR, 0, 0 */
/* Now the ops... */
e_arg1 = NewString("length");
e_arg2 = 7; e_arg3 = 501; e_arg4 = 42; e_arg5 = 1;
Base[25] = new_key_entry();
/* "length", SC_PREDEF, FUNC, LENGTH, 1 */
e_arg1 = NewString("puts");
e_arg3 = 27; e_arg4 = 44; e_arg5 = 2;
Base[26] = new_key_entry();
/* "puts", SC_PREDEF, PROC, PUTS, 2 */
e_arg1 = NewString("integer");
e_arg3 = 504; e_arg4 = 94; e_arg5 = 1;
Base[27] = new_key_entry();
/* "integer", SC_PREDEF, TYPE, IS_AN_INTEGER, 1 */
e_arg1 = NewString("sequence");
e_arg4 = 68;
Base[28] = new_key_entry();
/* "sequence", SC_PREDEF, TYPE, IS_A_SEQUENCE, 1 */
e_arg1 = NewString("position");
e_arg3 = 27; e_arg4 = 60; e_arg5 = 2;
Base[29] = new_key_entry();
/* "position", SC_PREDEF, PROC, POSITION, 2 */
e_arg1 = NewString("object");
e_arg3 = 504; e_arg4 = 40; e_arg5 = 1;
Base[30] = new_key_entry();
/* "object", SC_PREDEF, FUNC, IS_AN_OBJECT, 1 */
e_arg1 = NewString("append");
e_arg3 = 501; e_arg4 = 35; e_arg5 = 2;
Base[31] = new_key_entry();
/* "append", SC_PREDEF, FUNC, APPEND, 2 */
e_arg1 = NewString("prepend");
e_arg4 = 57;
Base[32] = new_key_entry();
/* "prepend", SC_PREDEF, FUNC, PREPEND, 2 */
e_arg1 = NewString("print");
e_arg3 = 27; e_arg4 = 19;
Base[33] = new_key_entry();
/* "print", SC_PREDEF, PROC, PRINT, 2 */
e_arg1 = NewString("printf");
e_arg4 = 38; e_arg5 = 3;
Base[34] = new_key_entry();
/* "printf", SC_PREDEF, PROC, PRINTF, 3 */
e_arg1 = NewString("clear_screen");
e_arg4 = 59; e_arg5 = 0;
Base[35] = new_key_entry();
/* "clear_screen", SC_PREDEF, PROC, CLEAR_SCREEN, 0 */
e_arg1 = NewString("floor");
e_arg3 = 501; e_arg4 = 83; e_arg5 = 1;
Base[36] = new_key_entry();
/* "floor", SC_PREDEF, FUNC, FLOOR, 1 */
e_arg1 = NewString("getc");
e_arg4 = 33;
Base[37] = new_key_entry();
/* "getc", SC_PREDEF, FUNC, GETC, 1 */
e_arg1 = NewString("gets");
e_arg3 = 501; e_arg4 = 17; e_arg5 = 1;
Base[38] = new_key_entry();
/* "gets", SC_PREDEF, FUNC, GETS, 1 */
e_arg1 = NewString("get_key");
e_arg4 = 79; e_arg5 = 0;
Base[39] = new_key_entry();
/* "get_key", SC_PREDEF, FUNC, GET_KEY, 0 */
e_arg1 = NewString("rand");
e_arg4 = 62; e_arg5 = 1;
Base[40] = new_key_entry();
/* "rand", SC_PREDEF, FUNC, RAND, 1 */
e_arg1 = NewString("repeat");
e_arg4 = 32; e_arg5 = 2;
Base[41] = new_key_entry();
/* "repeat", SC_PREDEF, FUNC, REPEAT, 2 */
e_arg1 = NewString("atom");
e_arg3 = 504; e_arg4 = 67; e_arg5 = 1;
Base[42] = new_key_entry();
/* "atom", SC_PREDEF, TYPE, IS_AN_ATOM, 1 */
e_arg1 = NewString("compare");
e_arg3 = 501; e_arg4 = 76; e_arg5 = 2;
Base[43] = new_key_entry();
/* "compare", SC_PREDEF, FUNC, COMPARE, 2 */
e_arg1 = NewString("find");
e_arg4 = 77;
Base[44] = new_key_entry();
/* "find", SC_PREDEF, FUNC, FIND, 2 */
e_arg1 = NewString("match");
e_arg4 = 78;
Base[45] = new_key_entry();
/* "match", SC_PREDEF, FUNC, MATCH, 2 */
e_arg1 = NewString("time");
e_arg4 = 70; e_arg5 = 0;
Base[46] = new_key_entry();
/* "time", SC_PREDEF, FUNC, TIME, 0 */
e_arg1 = NewString("command_line");
e_arg4 = 100;
Base[47] = new_key_entry();
/* "command_line", SC_PREDEF, FUNC, COMMAND_LINE, 0 */
e_arg1 = NewString("open");
e_arg4 = 37; e_arg5 = 2;
Base[48] = new_key_entry();
/* "open", SC_PREDEF, FUNC, OPEN, 2 */
e_arg1 = NewString("close");
e_arg3 = 27; e_arg4 = 86; e_arg5 = 1;
Base[49] = new_key_entry();
/* "close", SC_PREDEF, PROC, CLOSE, 1 */
e_arg1 = NewString("trace");
e_arg4 = 64; e_arg5 = 1;
Base[50] = new_key_entry();
/* "trace", SC_PREDEF, PROC, TRACE, 1 */
e_arg1 = NewString("getenv");
e_arg3 = 501; e_arg4 = 91;
Base[51] = new_key_entry();
/* "getenv", SC_PREDEF, FUNC, GETENV, 1 */
e_arg1 = NewString("sqrt");
e_arg4 = 41;
Base[52] = new_key_entry();
/* "sqrt", SC_PREDEF, FUNC, SQRT, 1 */
e_arg1 = NewString("sin");
e_arg4 = 80;
Base[53] = new_key_entry();
/* "sin", SC_PREDEF, FUNC, SIN, 1 */
e_arg1 = NewString("cos");
e_arg4 = 81;
Base[54] = new_key_entry();
/* "cos", SC_PREDEF, FUNC, COS, 1 */
e_arg1 = NewString("tan");
e_arg4 = 82;
Base[55] = new_key_entry();
/* "tan", SC_PREDEF, FUNC, TAN, 1 */
e_arg1 = NewString("log");
e_arg4 = 74;
Base[56] = new_key_entry();
/* "log", SC_PREDEF, FUNC, LOG, 1 */
e_arg1 = NewString("system");
e_arg3 = 27; e_arg4 = 99; e_arg5 = 2;
Base[57] = new_key_entry();
/* "system", SC_PREDEF, PROC, SYSTEM, 2 */
e_arg1 = NewString("date");
e_arg3 = 501; e_arg4 = 69; e_arg5 = 0;
Base[58] = new_key_entry();
/* "date", SC_PREDEF, FUNC, DATE, 0 */
e_arg1 = NewString("remainder");
e_arg4 = 71; e_arg5 = 2;
Base[59] = new_key_entry();
/* "remainder", SC_PREDEF, FUNC, REMAINDER, 2 */
e_arg1 = NewString("power");
e_arg4 = 72;
Base[60] = new_key_entry();
/* "power", SC_PREDEF, FUNC, POWER, 2 */
e_arg1 = NewString("machine_func");
e_arg4 = 111;
Base[61] = new_key_entry();
/* "machine_func", SC_PREDEF, FUNC, MACHINE_FUNC, 2 */
e_arg1 = NewString("machine_proc");
e_arg3 = 27; e_arg4 = 112;
Base[62] = new_key_entry();
/* "machine_proc", SC_PREDEF, PROC, MACHINE_PROC, 2 */
e_arg1 = NewString("abort");
e_arg4 = 126; e_arg5 = 1;
Base[63] = new_key_entry();
/* "abort", SC_PREDEF, PROC, ABORT, 1 */
e_arg1 = NewString("peek");
e_arg3 = 501; e_arg4 = 127;
Base[64] = new_key_entry();
/* "peek", SC_PREDEF, FUNC, PEEK, 1 */
e_arg1 = NewString("poke");
e_arg3 = 27; e_arg4 = 128; e_arg5 = 2;
Base[65] = new_key_entry();
/* "poke", SC_PREDEF, PROC, POKE, 2 */
e_arg1 = NewString("call");
e_arg3 = 27; e_arg4 = 129; e_arg5 = 1;
Base[66] = new_key_entry();
/* "call", SC_PREDEF, PROC, CALL, 1 */
e_arg1 = NewString("sprintf");
e_arg3 = 501; e_arg4 = 53; e_arg5 = 2;
Base[67] = new_key_entry();
/* "sprintf", SC_PREDEF, FUNC, SPRINTF, 2 */
e_arg1 = NewString("arctan");
e_arg4 = 73; e_arg5 = 1;
Base[68] = new_key_entry();
/* "arctan", SC_PREDEF, FUNC, ARCTAN, 1 */
e_arg1 = NewString("and_bits");
e_arg4 = 56; e_arg5 = 2;
Base[69] = new_key_entry();
/* "and_bits", SC_PREDEF, FUNC, AND_BITS, 2 */
e_arg1 = NewString("or_bits");
e_arg4 = 24; e_arg5 = 2;
Base[70] = new_key_entry();
/* "or_bits", SC_PREDEF, FUNC, OR_BITS, 2 */
e_arg1 = NewString("xor_bits");
e_arg4 = 26;
Base[71] = new_key_entry();
/* "xor_bits", SC_PREDEF, FUNC, XOR_BITS, 2 */
e_arg1 = NewString("not_bits");
e_arg4 = 51; e_arg5 = 1;
Base[72] = new_key_entry();
/* "not_bits", SC_PREDEF, FUNC, NOT_BITS, 1 */
e_arg1 = NewString("pixel");
e_arg3 = 27; e_arg4 = 130; e_arg5 = 2;
Base[73] = new_key_entry();
/* "pixel", SC_PREDEF, PROC, PIXEL, 2 */
e_arg1 = NewString("get_pixel");
e_arg3 = 501; e_arg4 = 131; e_arg5 = 1;
Base[74] = new_key_entry();
/* "get_pixel", SC_PREDEF, FUNC, GET_PIXEL, 1 */
e_arg1 = NewString("mem_copy");
e_arg3 = 27; e_arg4 = 132; e_arg5 = 3;
Base[75] = new_key_entry();
/* "mem_copy", SC_PREDEF, PROC, MEM_COPY, 3 */
e_arg1 = NewString("mem_set");
e_arg4 = 133; e_arg5 = 3;
Base[76] = new_key_entry();
/* "mem_set", SC_PREDEF, PROC, MEM_SET, 3 */
e_arg1 = NewString("c_proc");
e_arg4 = 134; e_arg5 = 2;
Base[77] = new_key_entry();
/* "c_proc", SC_PREDEF, PROC, C_PROC, 2 */
e_arg1 = NewString("c_func");
e_arg3 = 501; e_arg4 = 135;
Base[78] = new_key_entry();
/* "c_func", SC_PREDEF, FUNC, C_FUNC, 2 */
e_arg1 = NewString("routine_id");
e_arg4 = 136; e_arg5 = 1;
Base[79] = new_key_entry();
/* "routine_id", SC_PREDEF, FUNC, ROUTINE_ID, 1 */
e_arg1 = NewString("call_proc");
e_arg3 = 27; e_arg4 = 138; e_arg5 = 2;
Base[80] = new_key_entry();
/* "call_proc", SC_PREDEF, PROC, CALL_PROC, 2 */
e_arg1 = NewString("call_func");
e_arg3 = 501; e_arg4 = 139;
Base[81] = new_key_entry();
/* "call_func", SC_PREDEF, FUNC, CALL_FUNC, 2 */
e_arg1 = NewString("poke4");
e_arg3 = 27; e_arg4 = 140;
Base[82] = new_key_entry();
/* "poke4", SC_PREDEF, PROC, POKE4, 2 */
e_arg1 = NewString("peek4s");
e_arg3 = 501; e_arg4 = 141; e_arg5 = 1;
Base[83] = new_key_entry();
/* "peek4s", SC_PREDEF, FUNC, PEEK4S, 1 */
e_arg1 = NewString("peek4u");
e_arg4 = 142;
Base[84] = new_key_entry();
/* "peek4u", SC_PREDEF, FUNC, PEEK4U, 1 */
e_arg1 = NewString("profile");
e_arg3 = 27; e_arg4 = 153;
Base[85] = new_key_entry();
/* "profile", SC_PREDEF, PROC, PROFILE, 1 */
e_arg1 = NewString("equal");
e_arg3 = 501; e_arg4 = 155; e_arg5 = 2;
Base[86] = new_key_entry();
/* "equal", SC_PREDEF, FUNC, EQUAL, 2 */
e_arg1 = NewString("system_exec");
e_arg4 = 156;
Base[87] = new_key_entry();
/* "system_exec", SC_PREDEF, FUNC, SYSTEM_EXEC, 2 */
e_arg1 = NewString("platform");
e_arg4 = 157; e_arg5 = 0;
Base[88] = new_key_entry();
/* "platform", SC_PREDEF, FUNC, PLATFORM, 0 */
e_arg1 = NewString("task_create");
e_arg4 = 169; e_arg5 = 2;
Base[89] = new_key_entry();
/* "task_create", SC_PREDEF, FUNC, TASK_CREATE, 2 */
e_arg1 = NewString("task_schedule");
e_arg3 = 27; e_arg4 = 170;
Base[90] = new_key_entry();
/* "task_schedule", SC_PREDEF, PROC, TASK_SCHEDULE, 2 */
e_arg1 = NewString("task_yield");
e_arg4 = 171; e_arg5 = 0;
Base[91] = new_key_entry();
/* "task_yield", SC_PREDEF, PROC, TASK_YIELD, 0 */
e_arg1 = NewString("task_self");
e_arg3 = 501; e_arg4 = 172;
Base[92] = new_key_entry();
/* "task_self", SC_PREDEF, FUNC, TASK_SELF, 0 */
e_arg1 = NewString("task_suspend");
e_arg3 = 27; e_arg4 = 173; e_arg5 = 1;
Base[93] = new_key_entry();
/* "task_suspend", SC_PREDEF, PROC, TASK_SUSPEND, 1 */
e_arg1 = NewString("task_list");
e_arg3 = 501; e_arg4 = 174; e_arg5 = 0;
Base[94] = new_key_entry();
/* "task_list", SC_PREDEF, FUNC, TASK_LIST, 0 */
e_arg1 = NewString("task_status");
e_arg4 = 157; e_arg5 = 1;
Base[95] = new_key_entry();
/* "task_status", SC_PREDEF, FUNC, TASK_STATUS, 1 */
e_arg1 = NewString("task_clock_stop");
e_arg3 = 27; e_arg4 = 176; e_arg5 = 0;
Base[96] = new_key_entry();
/* "task_clock_stop", SC_PREDEF, PROC, TASK_CLOCK_STOP, 0 */
e_arg1 = NewString("task_clock_start");
e_arg4 = 177;
Base[97] = new_key_entry();
/* "task_clock_start", SC_PREDEF, PROC, TASK_CLOCK_START, 0 */
e_arg1 = NewString("_toplevel_");
e_arg4 = 0;
Base[98] = new_key_entry();
/* "_toplevel_", SC_PREDEF, PROC, 0, 0 */
/* _toplevel_ is an extremely important part of SymTab. When we pass off
SymTab through the backend, this is then executed as if it were a proc.
This contains all code not in functions or procedures. A user cannot call
this directly because _ isn't allowed to start routines, I think. */
_8keylist = MAKE_SEQ(_1);
/* Generating fields for token_name now. token_name is used by LexName to get
a correct message from a token. This way, instead of sending strings to be matched,
we send numbers from scanner. If the number we send doesn't match scanner's, then
we search through this list to find a name for the token to tell the user what was
expected and what we got. If we're unable to find the token, we return '...'.
In the future, this may only be used to output "expected %s", which would mean less
tokens to hold. Also, less redundancy by telling the user what they sent with the line
holding the stuff they sent too! */
_1 = NewS1(59);
_2 = (int)((s1_ptr)_1)->base;
Base = ((s1_ptr)_1)->base;
Base[1] = new_lex_entry(8, NewString("and"));
Base[2] = new_lex_entry(502, NewString("a number"));
Base[3] = new_lex_entry(-1, NewString("!"));
Base[4] = new_lex_entry(404, NewString("by"));
Base[5] = new_lex_entry(-23, NewString(":"));
Base[6] = new_lex_entry(-30, NewString(","));
Base[7] = new_lex_entry(15, NewString("&"));
Base[8] = new_lex_entry(416, NewString("constant"));
Base[9] = new_lex_entry(14, NewString("/"));
Base[10] = new_lex_entry(410, NewString("do"));
Base[11] = new_lex_entry(23, NewString("else"));
Base[12] = new_lex_entry(413, NewString("elsif"));
Base[13] = new_lex_entry(402, NewString("end"));
Base[14] = new_lex_entry(-21, NewString("the end of file."));
Base[15] = new_lex_entry(155, NewString("="));
Base[16] = new_lex_entry(61, NewString("exit"));
Base[17] = new_lex_entry(21, NewString("for"));
Base[18] = new_lex_entry(501, NewString("a function"));
Base[19] = new_lex_entry(406, NewString("function"));
Base[20] = new_lex_entry(411, NewString("global"));
Base[21] = new_lex_entry(6, NewString(">"));
Base[22] = new_lex_entry(2, NewString(">="));
Base[23] = new_lex_entry(20, NewString("if"));
Base[24] = new_lex_entry(-20, NewString("an illegal character"));
Base[25] = new_lex_entry(417, NewString("include"));
Base[26] = new_lex_entry(-24, NewString("{"));
Base[27] = new_lex_entry(-26, NewString("("));
Base[28] = new_lex_entry(-28, NewString("["));
Base[29] = new_lex_entry(1, NewString("<"));
Base[30] = new_lex_entry(5, NewString("<="));
Base[31] = new_lex_entry(10, NewString("-"));
Base[32] = new_lex_entry(13, NewString("*"));
Base[33] = new_lex_entry(523, NewString("a namespace qualifier"));
Base[34] = new_lex_entry(-6, NewString("end-of-line"));
Base[35] = new_lex_entry(7, NewString("not"));
Base[36] = new_lex_entry(4, NewString("!="));
Base[37] = new_lex_entry(9, NewString("or"));
Base[38] = new_lex_entry(11, NewString("+"));
Base[39] = new_lex_entry(27, NewString("a procedure"));
Base[40] = new_lex_entry(405, NewString("procedure"));
Base[41] = new_lex_entry(515, NewString("a variable"));
Base[42] = new_lex_entry(524, NewString("a function"));
Base[43] = new_lex_entry(525, NewString("a procedure"));
Base[44] = new_lex_entry(526, NewString("a type"));
Base[45] = new_lex_entry(-25, NewString("}"));
Base[46] = new_lex_entry(-27, NewString(")"));
Base[47] = new_lex_entry(-29, NewString("]"));
Base[48] = new_lex_entry(412, NewString("return"));
Base[49] = new_lex_entry(516, NewString("a slice"));
Base[50] = new_lex_entry(503, NewString("a character string"));
Base[51] = new_lex_entry(403, NewString("to"));
Base[52] = new_lex_entry(409, NewString("then"));
Base[53] = new_lex_entry(504, NewString("a type"));
Base[54] = new_lex_entry(415, NewString("type"));
Base[55] = new_lex_entry(-100, NewString("a variable"));
Base[56] = new_lex_entry(419, NewString("with"));
Base[57] = new_lex_entry(420, NewString("without"));
Base[58] = new_lex_entry(47, NewString("while"));
Base[59] = new_lex_entry(63, NewString("?"));
_14token_name = MAKE_SEQ(_1);
/* op_result = repeat(T_UNKNOWN, MAX_OPCODE) */
_14op_result = Repeat(5, 177);
ptr = SEQ_PTR(_14op_result);
Base = ptr->base;
/* op_result[RIGHT_BRACE_N] = T_SEQUENCE */
Base[31] = 3;
/* op_result[RIGHT_BRACE_2] = T_SEQUENCE */
Base[85] = 3;
/* op_result[REPEAT] = T_SEQUENCE */
Base[32] = 3;
/* op_result[APPEND] = T_SEQUENCE */
Base[35] = 3;
/* op_result[RHS_SLICE] = T_SEQUENCE */
Base[46] = 3;
/* op_result[CONCAT] = T_SEQUENCE */
Base[15] = 3;
/* op_result[CONCAT_N] = T_SEQUENCE */
Base[159] = 3;
/* op_result[PREPEND] = T_SEQUENCE */
Base[57] = 3;
/* op_result[COMMAND_LINE] = T_SEQUENCE */
Base[100] = 3;
/* op_result[SPRINTF] = T_SEQUENCE */
Base[53] = 3;
/* op_result[ROUTINE_ID] = T_INTEGER */
Base[136] = 1;
/* op_result[GETC] = T_INTEGER */
Base[33] = 1;
/* op_result[OPEN] = T_INTEGER */
Base[37] = 1;
/* op_result[LENGTH] = T_INTEGER -- assume less than a billion */
Base[42] = 1;
/* op_result[PLENGTH] = T_INTEGER -- "" */
Base[162] = 1;
/* op_result[IS_AN_OBJECT] = T_INTEGER */
Base[40] = 1;
/* op_result[IS_AN_ATOM] = T_INTEGER */
Base[67] = 1;
/* op_result[IS_A_SEQUENCE] = T_INTEGER */
Base[68] = 1;
/* op_result[COMPARE] = T_INTEGER */
Base[76] = 1;
/* op_result[EQUAL] = T_INTEGER */
Base[155] = 1;
/* op_result[FIND] = T_INTEGER */
Base[77] = 1;
/* op_result[MATCH] = T_INTEGER */
Base[78] = 1;
/* op_result[GET_KEY] = T_INTEGER */
Base[79] = 1;
/* op_result[IS_AN_INTEGER] = T_INTEGER */
Base[94] = 1;
/* op_result[ASSIGN_I] = T_INTEGER */
Base[113] = 1;
/* op_result[RHS_SUBS_I] = T_INTEGER */
Base[114] = 1;
/* op_result[PLUS_I] = T_INTEGER */
Base[115] = 1;
/* op_result[MINUS_I] = T_INTEGER */
Base[116] = 1;
/* op_result[PLUS1_I] = T_INTEGER */
Base[117] = 1;
/* op_result[SYSTEM_EXEC] = T_INTEGER */
Base[156] = 1;
/* op_result[TIME] = T_ATOM */
Base[70] = 4;
/* op_result[TASK_STATUS] = T_INTEGER */
Base[175] = 1;
/* op_result[TASK_SELF] = T_ATOM */
Base[172] = 4;
/* op_result[TASK_CREATE] = T_ATOM */
Base[169] = 4;
/* op_result[TASK_LIST] = T_SEQUENCE */
Base[174] = 3;
/* op_result[PLATFORM] = T_INTEGER */
Base[157] = 1;
/* Initialize the error stack. */
ebegin();
_18main();
Cleanup(0);
}
