struct instruction *parse_instruction(void)
{
struct expr *expr;
struct instruction *res;
switch (lookahead[0]->type)
{
case WHILE: return parse_while();
case DO: return parse_do();
case IDENTIFIER: case LPAREN:
expr = parse_expression();
switch(lookahead[0]->type)
{
case ASSIGN: return parse_assignment_instr(expr);
case EOL:
if (expr->exprtype != funcalltype)
{
if (expr->exprtype == binopexprtype
&& expr->val.binopexpr.op == EQ)
{
error(expr->pos, "unexpected =, did you mean <- ?");
exit(1);
}
else
syntaxerror("expected instruction, not expression");
}
eat(EOL);
res = funcallinstr(expr->val.funcall.fun_ident,
expr->val.funcall.args, expr->pos);
free(expr);
return res;
default:
next();
syntaxerror("unexpected %s", tok->val);
return parse_instruction();
}
case RETURN:
eat(RETURN);
if (lookahead[0]->type == EOL)
{
eat(EOL);
return return_stmt(NULL);
}
else
{
expr = parse_expression(); eat(EOL);
return return_stmt(expr);
}
case FOR: return parse_for();
case IF: return parse_if();
case SWITCH: return parse_switch();
case ENDOFFILE: return NULL;
default:
next();
syntaxerror("expected instruction, not %s", tok->val);
return parse_instruction();
}
}
VeDeviceElement *veDeviceParseElem(char *spec) {
VeDeviceElement *e;
VeDeviceEContent *content;
char *s, *dup, *name, *type, *ptr;
dup = veDupString(spec); /* save spec - may not be alterable... */
ptr = dup;
name = veNextLElem(&ptr);
if (name && strcmp(name,"elem") == 0)
name = veNextLElem(&ptr); /* skip leading "elem" if there */
if (!name) {
veError(MODULE,"veDeviceParseElem: missing name in spec: %s", spec);
veFree(dup);
return NULL;
}
if (!(type = veNextLElem(&ptr))) {
veError(MODULE,"veDeviceParseElem: missing type in spec: %s", spec);
veFree(dup);
return NULL; /* type */
}
/* parse content based upon name */
content = NULL;
s = ptr ? ptr : "";
if (strcmp(type,"trigger") == 0)
content = parse_trigger(s);
else if (strcmp(type,"switch") == 0)
content = parse_switch(s);
else if (strcmp(type,"valuator") == 0)
content = parse_valuator(s);
else if (strcmp(type,"vector") == 0)
content = parse_vector(s);
else if (strcmp(type,"keyboard") == 0)
content = parse_keyboard(s);
else
veError(MODULE,"veDeviceParseElem: unknown elem type %s in spec: %s",
type, spec);
if (!content) {
veFree(dup);
return NULL; /* parsing of content failed - don't continue */
}
e = veAllocObj(VeDeviceElement);
e->name = veDupString(name);
e->content = content;
return e;
}
/** Parse statement.
*
* @param parse Parser object.
* @return New syntax tree node.
*/
stree_stat_t *parse_stat(parse_t *parse)
{
stree_stat_t *stat;
stree_vdecl_t *vdecl_s;
stree_if_t *if_s;
stree_switch_t *switch_s;
stree_while_t *while_s;
stree_for_t *for_s;
stree_raise_t *raise_s;
stree_break_t *break_s;
stree_return_t *return_s;
stree_wef_t *wef_s;
stree_exps_t *exp_s;
#ifdef DEBUG_PARSE_TRACE
printf("Parse statement.\n");
#endif
switch (lcur_lc(parse)) {
case lc_var:
vdecl_s = parse_vdecl(parse);
stat = stree_stat_new(st_vdecl);
stat->u.vdecl_s = vdecl_s;
break;
case lc_if:
if_s = parse_if(parse);
stat = stree_stat_new(st_if);
stat->u.if_s = if_s;
break;
case lc_switch:
switch_s = parse_switch(parse);
stat = stree_stat_new(st_switch);
stat->u.switch_s = switch_s;
break;
case lc_while:
while_s = parse_while(parse);
stat = stree_stat_new(st_while);
stat->u.while_s = while_s;
break;
case lc_for:
for_s = parse_for(parse);
stat = stree_stat_new(st_for);
stat->u.for_s = for_s;
break;
case lc_raise:
raise_s = parse_raise(parse);
stat = stree_stat_new(st_raise);
stat->u.raise_s = raise_s;
break;
case lc_break:
break_s = parse_break(parse);
stat = stree_stat_new(st_break);
stat->u.break_s = break_s;
break;
case lc_return:
return_s = parse_return(parse);
stat = stree_stat_new(st_return);
stat->u.return_s = return_s;
break;
case lc_do:
case lc_with:
wef_s = parse_wef(parse);
stat = stree_stat_new(st_wef);
stat->u.wef_s = wef_s;
break;
default:
exp_s = parse_exps(parse);
stat = stree_stat_new(st_exps);
stat->u.exp_s = exp_s;
break;
}
#ifdef DEBUG_PARSE_TRACE
printf("Parsed statement %p\n", stat);
#endif
return stat;
}
/* Handle command line options. */
static void parse_args(struct eject_control *ctl, int argc, char **argv)
{
static const struct option long_opts[] =
{
{"auto", required_argument, NULL, 'a'},
{"cdrom", no_argument, NULL, 'r'},
{"cdspeed", required_argument, NULL, 'x'},
{"changerslot", required_argument, NULL, 'c'},
{"default", no_argument, NULL, 'd'},
{"floppy", no_argument, NULL, 'f'},
{"force", no_argument, NULL, 'F'},
{"help", no_argument, NULL, 'h'},
{"listspeed", no_argument, NULL, 'X'},
{"manualeject", required_argument, NULL, 'i'},
{"noop", no_argument, NULL, 'n'},
{"no-unmount", no_argument, NULL, 'm'},
{"no-partitions-unmount", no_argument, NULL, 'M' },
{"proc", no_argument, NULL, 'p'},
{"scsi", no_argument, NULL, 's'},
{"tape", no_argument, NULL, 'q'},
{"trayclose", no_argument, NULL, 't'},
{"traytoggle", no_argument, NULL, 'T'},
{"verbose", no_argument, NULL, 'v'},
{"version", no_argument, NULL, 'V'},
{0, 0, 0, 0}
};
int c;
while ((c = getopt_long(argc, argv,
"a:c:i:x:dfFhnqrstTXvVpmM", long_opts, NULL)) != -1) {
switch (c) {
case 'a':
ctl->a_option = 1;
ctl->a_arg = parse_switch(optarg, _("argument error"),
"on", "off", "1", "0", NULL);
break;
case 'c':
ctl->c_option = 1;
ctl->c_arg = strtoul_or_err(optarg, _("invalid argument to --changerslot/-c option"));
break;
case 'x':
ctl->x_option = 1;
ctl->x_arg = strtoul_or_err(optarg, _("invalid argument to --cdspeed/-x option"));
break;
case 'd':
ctl->d_option = 1;
break;
case 'f':
ctl->f_option = 1;
break;
case 'F':
ctl->F_option = 1;
break;
case 'h':
usage(stdout);
break;
case 'i':
ctl->i_option = 1;
ctl->i_arg = parse_switch(optarg, _("argument error"),
"on", "off", "1", "0", NULL);
break;
case 'm':
ctl->m_option = 1;
break;
case 'M':
ctl->M_option = 1;
break;
case 'n':
ctl->n_option = 1;
break;
case 'p':
ctl->p_option = 1;
break;
case 'q':
ctl->q_option = 1;
break;
case 'r':
ctl->r_option = 1;
break;
case 's':
ctl->s_option = 1;
break;
case 't':
ctl->t_option = 1;
break;
case 'T':
ctl->T_option = 1;
break;
case 'X':
ctl->X_option = 1;
break;
case 'v':
ctl->v_option = 1;
break;
case 'V':
printf(UTIL_LINUX_VERSION);
exit(EXIT_SUCCESS);
break;
default:
case '?':
usage(stderr);
break;
}
}
/* check for a single additional argument */
if ((argc - optind) > 1)
errx(EXIT_FAILURE, _("too many arguments"));
if ((argc - optind) == 1)
ctl->device = xstrdup(argv[optind]);
}
static void parse_option(struct setterm_control *ctl, int ac, char **av)
{
int c;
enum {
OPT_TERM = CHAR_MAX + 1,
OPT_RESET,
OPT_RESIZE,
OPT_INITIALIZE,
OPT_CURSOR,
OPT_REPEAT,
OPT_APPCURSORKEYS,
OPT_LINEWRAP,
OPT_DEFAULT,
OPT_FOREGROUND,
OPT_BACKGROUND,
OPT_ULCOLOR,
OPT_HBCOLOR,
OPT_INVERSESCREEN,
OPT_BOLD,
OPT_HALF_BRIGHT,
OPT_BLINK,
OPT_REVERSE,
OPT_UNDERLINE,
OPT_STORE,
OPT_CLEAR,
OPT_TABS,
OPT_CLRTABS,
OPT_REGTABS,
OPT_BLANK,
OPT_DUMP,
OPT_APPEND,
OPT_FILE,
OPT_MSG,
OPT_MSGLEVEL,
OPT_POWERSAVE,
OPT_POWERDOWN,
OPT_BLENGTH,
OPT_BFREQ,
OPT_VERSION,
OPT_HELP
};
static const struct option longopts[] = {
{"term", required_argument, NULL, OPT_TERM},
{"reset", no_argument, NULL, OPT_RESET},
{"resize", no_argument, NULL, OPT_RESIZE},
{"initialize", no_argument, NULL, OPT_INITIALIZE},
{"cursor", required_argument, NULL, OPT_CURSOR},
{"repeat", required_argument, NULL, OPT_REPEAT},
{"appcursorkeys", required_argument, NULL, OPT_APPCURSORKEYS},
{"linewrap", required_argument, NULL, OPT_LINEWRAP},
{"default", no_argument, NULL, OPT_DEFAULT},
{"foreground", required_argument, NULL, OPT_FOREGROUND},
{"background", required_argument, NULL, OPT_BACKGROUND},
{"ulcolor", required_argument, NULL, OPT_ULCOLOR},
{"hbcolor", required_argument, NULL, OPT_HBCOLOR},
{"inversescreen", required_argument, NULL, OPT_INVERSESCREEN},
{"bold", required_argument, NULL, OPT_BOLD},
{"half-bright", required_argument, NULL, OPT_HALF_BRIGHT},
{"blink", required_argument, NULL, OPT_BLINK},
{"reverse", required_argument, NULL, OPT_REVERSE},
{"underline", required_argument, NULL, OPT_UNDERLINE},
{"store", no_argument, NULL, OPT_STORE},
{"clear", required_argument, NULL, OPT_CLEAR},
{"tabs", optional_argument, NULL, OPT_TABS},
{"clrtabs", optional_argument, NULL, OPT_CLRTABS},
{"regtabs", optional_argument, NULL, OPT_REGTABS},
{"blank", optional_argument, NULL, OPT_BLANK},
{"dump", optional_argument, NULL, OPT_DUMP},
{"append", required_argument, NULL, OPT_APPEND},
{"file", required_argument, NULL, OPT_FILE},
{"msg", required_argument, NULL, OPT_MSG},
{"msglevel", required_argument, NULL, OPT_MSGLEVEL},
{"powersave", required_argument, NULL, OPT_POWERSAVE},
{"powerdown", optional_argument, NULL, OPT_POWERDOWN},
{"blength", optional_argument, NULL, OPT_BLENGTH},
{"bfreq", optional_argument, NULL, OPT_BFREQ},
{"version", no_argument, NULL, OPT_VERSION},
{"help", no_argument, NULL, OPT_HELP},
{NULL, 0, NULL, 0}
};
static const ul_excl_t excl[] = {
{ OPT_DEFAULT, OPT_STORE },
{ OPT_TABS, OPT_CLRTABS, OPT_REGTABS },
{ OPT_MSG, OPT_MSGLEVEL },
{ 0 }
};
int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
while ((c = getopt_long_only(ac, av, "", longopts, NULL)) != -1) {
err_exclusive_options(c, longopts, excl, excl_st);
switch (c) {
case OPT_TERM:
ctl->opt_term = set_opt_flag(ctl->opt_term);
ctl->opt_te_terminal_name = optarg;
break;
case OPT_RESET:
ctl->opt_reset = set_opt_flag(ctl->opt_reset);
break;
case OPT_RESIZE:
ctl->opt_resize = set_opt_flag(ctl->opt_resize);
break;
case OPT_INITIALIZE:
ctl->opt_initialize = set_opt_flag(ctl->opt_initialize);
break;
case OPT_CURSOR:
ctl->opt_cursor = set_opt_flag(ctl->opt_cursor);
ctl->opt_cu_on = parse_switch(optarg, _("argument error"),
"on", "off", NULL);
break;
case OPT_REPEAT:
ctl->opt_repeat = set_opt_flag(ctl->opt_repeat);
ctl->opt_rep_on = parse_switch(optarg, _("argument error"),
"on", "off", NULL);
break;
case OPT_APPCURSORKEYS:
ctl->opt_appcursorkeys = set_opt_flag(ctl->opt_appcursorkeys);
ctl->opt_appck_on = parse_switch(optarg, _("argument error"),
"on", "off", NULL);
break;
case OPT_LINEWRAP:
ctl->opt_linewrap = set_opt_flag(ctl->opt_linewrap);
ctl->opt_li_on = parse_switch(optarg, _("argument error"),
"on", "off", NULL);
break;
case OPT_DEFAULT:
ctl->opt_default = set_opt_flag(ctl->opt_default);
break;
case OPT_FOREGROUND:
ctl->opt_foreground = set_opt_flag(ctl->opt_foreground);
ctl->opt_fo_color = parse_febg_color(optarg);
break;
case OPT_BACKGROUND:
ctl->opt_background = set_opt_flag(ctl->opt_background);
ctl->opt_ba_color = parse_febg_color(optarg);
break;
case OPT_ULCOLOR:
ctl->opt_ulcolor = set_opt_flag(ctl->opt_ulcolor);
ctl->opt_ul_color = parse_ulhb_color(av, &optind);
break;
case OPT_HBCOLOR:
ctl->opt_hbcolor = set_opt_flag(ctl->opt_hbcolor);
ctl->opt_hb_color = parse_ulhb_color(av, &optind);
break;
case OPT_INVERSESCREEN:
ctl->opt_inversescreen = set_opt_flag(ctl->opt_inversescreen);
ctl->opt_invsc_on = parse_switch(optarg, _("argument error"),
"on", "off", NULL);
break;
case OPT_BOLD:
ctl->opt_bold = set_opt_flag(ctl->opt_bold);
ctl->opt_bo_on = parse_switch(optarg, _("argument error"),
"on", "off", NULL);
break;
case OPT_HALF_BRIGHT:
ctl->opt_halfbright = set_opt_flag(ctl->opt_halfbright);
ctl->opt_hb_on = parse_switch(optarg, _("argument error"),
"on", "off", NULL);
break;
case OPT_BLINK:
ctl->opt_blink = set_opt_flag(ctl->opt_blink);
ctl->opt_bl_on = parse_switch(optarg, _("argument error"),
"on", "off", NULL);
break;
case OPT_REVERSE:
ctl->opt_reverse = set_opt_flag(ctl->opt_reverse);
ctl->opt_re_on = parse_switch(optarg, _("argument error"),
"on", "off", NULL);
break;
case OPT_UNDERLINE:
ctl->opt_underline = set_opt_flag(ctl->opt_underline);
ctl->opt_un_on = parse_switch(optarg, _("argument error"),
"on", "off", NULL);
break;
case OPT_STORE:
ctl->opt_store = set_opt_flag(ctl->opt_store);
break;
case OPT_CLEAR:
ctl->opt_clear = set_opt_flag(ctl->opt_clear);
ctl->opt_cl_all = parse_switch(optarg, _("argument error"),
"all", "reset", NULL);
break;
case OPT_TABS:
ctl->opt_tabs = set_opt_flag(ctl->opt_tabs);
parse_tabs(av, optarg, &optind, ctl->opt_tb_array);
break;
case OPT_CLRTABS:
ctl->opt_clrtabs = set_opt_flag(ctl->opt_clrtabs);
parse_tabs(av, optarg, &optind, ctl->opt_tb_array);
break;
case OPT_REGTABS:
ctl->opt_regtabs = set_opt_flag(ctl->opt_regtabs);
ctl->opt_rt_len = parse_regtabs(av, optarg, &optind);
break;
case OPT_BLANK:
ctl->opt_blank = set_opt_flag(ctl->opt_blank);
ctl->opt_bl_min = parse_blank(av, optarg, &optind);
break;
case OPT_DUMP:
ctl->opt_snap = set_opt_flag(ctl->opt_snap);
ctl->opt_sn_num = parse_snap(av, optarg, &optind);
break;
case OPT_APPEND:
ctl->opt_append = set_opt_flag(ctl->opt_append);
ctl->opt_sn_num = parse_snap(av, optarg, &optind);
break;
case OPT_FILE:
ctl->opt_snapfile = set_opt_flag(ctl->opt_snapfile);
ctl->opt_sn_name = optarg;
break;
case OPT_MSG:
ctl->opt_msg = set_opt_flag(ctl->opt_msg);
ctl->opt_msg_on = parse_switch(optarg, _("argument error"),
"on", "off", NULL);
break;
case OPT_MSGLEVEL:
ctl->opt_msglevel = set_opt_flag(ctl->opt_msglevel);
ctl->opt_msglevel_num = parse_msglevel(optarg);
if (ctl->opt_msglevel_num == 0) {
ctl->opt_msg = set_opt_flag(ctl->opt_msg);
ctl->opt_msg_on |= 1;
}
break;
case OPT_POWERSAVE:
ctl->opt_powersave = set_opt_flag(ctl->opt_powersave);
ctl->opt_ps_mode = parse_powersave(optarg);
break;
case OPT_POWERDOWN:
ctl->opt_powerdown = set_opt_flag(ctl->opt_powerdown);
ctl->opt_pd_min = parse_blank(av, optarg, &optind);
break;
case OPT_BLENGTH:
ctl->opt_blength = set_opt_flag(ctl->opt_blength);
ctl->opt_blength_l = parse_blength(av, optarg, &optind);
break;
case OPT_BFREQ:
ctl->opt_bfreq = set_opt_flag(ctl->opt_bfreq);
ctl->opt_bfreq_f = parse_bfreq(av, optarg, &optind);
break;
case OPT_VERSION:
printf(UTIL_LINUX_VERSION);
exit(EXIT_SUCCESS);
case OPT_HELP:
usage();
default:
errtryhelp(EXIT_FAILURE);
}
}
}
int main(int argc, char* argv[]) {
try {
TCLAP::CmdLine cmd("Command description message", ' ', "0.2");
TCLAP::SwitchArg lex_switch("l", "lex", "Process up to the Lexer phase");
TCLAP::SwitchArg parse_switch("p", "parse",
"Process up to the Parser phase");
TCLAP::SwitchArg sem_switch("s", "sem",
"Process up to the Semantic Analyser phase");
TCLAP::SwitchArg tup_switch("t", "tup",
"Process up to the Tuple phase");
TCLAP::SwitchArg compile_switch("c", "compile",
"Process all phases and compile (default)",
true);
TCLAP::SwitchArg quiet_switch("q", "quiet",
"Only display error messages (default)", true);
TCLAP::SwitchArg verbose_switch("v", "verbose",
"Display all Trace messages");
TCLAP::ValueArg< std::string > out_arg("o", "out",
"Output file (default -out=STDOUT)",
false, "out", "string");
TCLAP::ValueArg< std::string > err_arg("e", "err",
"Error file (default -err=STDOUT)",
false, "err", "string");
TCLAP::UnlabeledMultiArg<std::string> input_args("input", "Input files", true, "string");
std::vector<TCLAP::Arg*> args;
args.push_back(&lex_switch);
args.push_back(&parse_switch);
args.push_back(&sem_switch);
args.push_back(&tup_switch);
args.push_back(&compile_switch);
cmd.xorAdd(args);
cmd.add(quiet_switch);
cmd.add(verbose_switch);
cmd.add(out_arg);
cmd.add(err_arg);
cmd.add(input_args);
cmd.parse(argc, argv);
std::vector< std::string > inputFiles = input_args.getValue();
if (inputFiles.size() == 0) {
fprintf(stderr, "No input files. Please specify 1 or more .cs13 files using -I <file>\n");
return -1;
}
Administrator *admin;
std::string err = err_arg.getValue();
if (err.compare("err") != 0) {
// Have to create the error file to be able to write to it
std::ofstream filestream(err_arg.getValue());
if (!filestream) {
fprintf(stderr, "Error creating %s\n", err_arg.getValue().c_str());
return -1;
}
filestream.clear();
filestream.close();
admin = new Administrator(inputFiles, err_arg.getValue());
} else {
admin = new Administrator(inputFiles);
}
std::string out = out_arg.getValue();
if (out.compare("out") != 0) {
admin->set_output_file(out_arg.getValue());
}
if (verbose_switch.isSet()) {
admin->ShowTrace(true);
}
if (lex_switch.isSet()) {
admin->LexerPhase();
} else if (parse_switch.isSet()) {
admin->ParserPhase();
} else if (sem_switch.getValue()) {
admin->SemanticAnalysisPhase();
} else if (tup_switch.isSet()) {
admin->TupleGenerationPhase();
} else {
admin->Compile();
}
} catch(TCLAP::ArgException &e) {
fprintf(stderr, "error: %s for arg %s\n", e.error().c_str(), e.argId().c_str());
}
return 0;
}
