void visitForLoop(ForLoop * p)
{
p->m_attribute.m_scope = m_st->get_scope();
p->visit_children(this);
if(!is_assignment(p->m_stat_1))
this->t_error(for_assign_err, p->m_attribute);
if(!is_assignment(p->m_stat_2))
this->t_error(for_assign_err, p->m_attribute);
check_for_pred(p->m_expr);
}
void symex_target_equationt::SSA_stept::output(
const namespacet &ns,
std::ostream &out) const
{
if(source.is_set)
{
out << "Thread " << source.thread_nr;
if(source.pc->location.is_not_nil())
out << " " << source.pc->location << std::endl;
else
out << std::endl;
}
switch(type)
{
case goto_trace_stept::ASSERT: out << "ASSERT" << std::endl; break;
case goto_trace_stept::ASSUME: out << "ASSUME" << std::endl; break;
case goto_trace_stept::LOCATION: out << "LOCATION" << std::endl; break;
case goto_trace_stept::INPUT: out << "INPUT" << std::endl; break;
case goto_trace_stept::OUTPUT: out << "OUTPUT" << std::endl; break;
case goto_trace_stept::DECL:
out << "DECL" << std::endl;
out << from_expr(ns, "", ssa_lhs) << std::endl;
break;
case goto_trace_stept::ASSIGNMENT:
out << "ASSIGNMENT (";
switch(assignment_type)
{
case HIDDEN: out << "HIDDEN"; break;
case STATE: out << "STATE"; break;
default:;
}
out << ")" << std::endl;
break;
case goto_trace_stept::DEAD: out << "DEAD" << std::endl; break;
case goto_trace_stept::FUNCTION_CALL: out << "FUNCTION_CALL" << std::endl; break;
case goto_trace_stept::FUNCTION_RETURN: out << "FUNCTION_RETURN" << std::endl; break;
default: assert(false);
}
if(is_assert() || is_assume() || is_assignment())
out << from_expr(ns, "", cond_expr) << std::endl;
if(is_assert())
out << comment << std::endl;
out << "Guard: " << from_expr(ns, "", guard_expr) << std::endl;
}
int scan(FILE *target)
{
hash_t *var_map = malloc(sizeof(hash_t));
hash_init(var_map, 1024);
write_header(target);
int ret = 0;
while(next() == true){
if(is_alpha() == false){
printf("An instruction can only start with a function call or assignment\n");
return 1;
}
char *current_token = get_token();
char *temp;
strcpy(temp, current_token);
if(next() == false){
printf("Incomplete instruction\n");
return 1;
}
if(is_left()){
ret = parse_call(target, temp, var_map); /* It is a call */
} else if(is_assignment()){
ret = parse_assignment(target, temp, var_map); /* It is an assignment */
} else {
printf("Not a valid instruction\n");
return 1;
}
if(ret == 1 ){
printf("Syntax error\n");
return 1;
}
}
write_end(target);
free(var_map);
return ret;
}
void real_main (int argc, char *const argv[]) {
int i;
/* TODO: handle -i */
env_import ();
for (i = 1; i < argc && is_assignment (argv[i]); ++i)
env_parse_assignment (argv[i]);
if (i == argc)
env_print ();
else {
env_export ();
must_execvp (argv + i);
}
}
static void do_extract(t_lst *tokens, t_lst *assign_list,
t_lst *remaining_tokens)
{
t_token *token;
while ((token = twl_lst_first(tokens)))
{
if (is_assignment(token->text))
{
twl_lst_push_back(assign_list,
build_assign(twl_lst_pop_front(tokens)));
}
else
{
break ;
}
}
while ((token = twl_lst_first(tokens)))
{
twl_lst_push_back(remaining_tokens, twl_lst_pop_front(tokens));
}
}
data_t *eval(const data_t *exp, data_t *env) {
if(eval_plz_die) {
eval_plz_die = 0;
ExitThread(0);
}
if(is_self_evaluating(exp))
return (data_t*)exp;
if(is_variable(exp))
return lookup_variable_value(exp, env);
if(is_quoted_expression(exp))
return get_text_of_quotation(exp);
if(is_assignment(exp))
return eval_assignment(exp, env);
if(is_definition(exp))
return eval_definition(exp, env);
if(is_if(exp))
return eval_if(exp, env);
if(is_lambda(exp))
return make_procedure(get_lambda_parameters(exp), get_lambda_body(exp), env);
if(is_begin(exp))
return eval_sequence(get_begin_actions(exp), env);
if(is_cond(exp))
return eval(cond_to_if(exp), env);
if(is_letrec(exp))
return eval(letrec_to_let(exp), env);
if(is_let_star(exp))
return eval(let_star_to_nested_lets(exp), env);
if(is_let(exp))
return eval(let_to_combination(exp), env);
if(is_application(exp))
return apply(
eval(get_operator(exp), env),
get_list_of_values(get_operands(exp), env));
printf("Unknown expression type -- EVAL '");
return make_symbol("error");
}
int script_process_line(char *buf)
{
int ret = -ENOTSUP;
struct timespec ts = { .tv_sec = 0, .tv_nsec = 0 };
struct timespec tse;
if (_perf_measure)
ts = utils_get_time( TIME_CURRENT );
/* Skip if it's a one line comment (more to be implemented) */
if (is_comment(buf) == 1) {
DPRINTF("%s: Found comment, skipping\n", __FUNCTION__);
ret = 0;
goto cleanup;
}
else
if (strcmp(buf, "else {") == 0) {
/* Reverse the condition */
if ((_script_in_condition_and_met == 1)
|| (_script_in_condition_and_met == -10))
_script_in_condition_and_met = 0;
else
if ((_script_in_condition_and_met == 0)
|| (_script_in_condition_and_met == -20))
_script_in_condition_and_met = 1;
else
if (_script_in_condition_and_met != -1) {
DPRINTF("%s: Invalid state for else statement\n", __FUNCTION__);
ret = -EINVAL;
goto cleanup;
}
ret = 0;
goto cleanup;
}
else
if (strcmp(buf, "}") == 0) {
_script_in_condition_and_met = (_script_in_condition_and_met == 1) ? -10 : -20;
ret = 0;
goto cleanup;
}
if (_script_in_condition_and_met < -1)
_script_in_condition_and_met = 1;
if (_script_in_condition_and_met == 0) {
ret = 0;
goto cleanup;
}
/* Comparison with no ternary operator support... yet */
if (regex_match("if \\(([^(]*)([^)]*)\\)", buf)) {
if (regex_match("if \\(([^(]*) == ([^)]*)\\) {", buf)) {
char **matches = NULL;
int i, num_matches;
matches = (char **)utils_alloc( "scripting.script_process_line.matches", sizeof(char *) );
_regex_match("if \\(([^(]*) == ([^)]*)\\) {", buf, matches, &num_matches);
if (num_matches >= 2)
_script_in_condition_and_met = (valcmp(matches[0], matches[1]) == 0) ? 1 : 0;
for (i = 0; i < num_matches; i++)
matches[i] = utils_free("scripting.condition.matches[]", matches[i]);
matches = utils_free("scripting.condition.matches", matches);
}
}
else
/* Definition */
if (strncmp(buf, "define ", 7) == 0) {
tTokenizer t;
t = tokenize(buf + 7, " ");
if (t.numTokens != 2) {
ret = -EINVAL;
goto cleanup;
}
if (variable_create(trim(t.tokens[0]), trim(t.tokens[1])) != 1) {
ret = -EIO;
goto cleanup;
}
}
else
/* Operators */
if ((strstr(buf, "+=") != NULL) || (strstr(buf, "-=") != NULL) ||
(strstr(buf, "%=") != NULL) || (strstr(buf, "*=") != NULL) ||
(strstr(buf, "/=") != NULL)) {
tTokenizer t;
char *var;
char *val;
int op, vtype;
t = tokenize(buf, "=");
if (t.numTokens != 2) {
ret = -EINVAL;
goto cleanup;
}
var = trim(strdup(t.tokens[0]));
val = trim(strdup(t.tokens[1]));
op = var[ strlen(var) - 1];
var[ strlen(var) - 1] = 0;
var = trim(var);
if (val[strlen(val) - 1] == ';')
val[strlen(val) - 1] = 0;
val = trim(val);
vtype = variable_get_type(var, NULL);
if ((vtype == TYPE_INT) || (vtype == TYPE_LONG)) {
char tmp[32] = { 0 };
long value = atol(variable_get_element_as_string(var, NULL));
if (op == '+')
value += atol(val);
else
if (op == '-')
value -= atol(val);
else
if (op == '*')
value *= atol(val);
else
if (op == '%')
value %= atol(val);
else
if (op == '/')
value /= atol(val);
snprintf(tmp, sizeof(tmp), "%ld", value);
variable_set_deleted(var, 1);
variable_add(var, tmp, TYPE_QSCRIPT, -1, vtype);
ret = 0;
}
else
ret = -EINVAL;
var = utils_free("scripting.operators.var", var);
val = utils_free("scripting.operators.val", val);
free_tokens(t);
return ret;
}
else
/* Assignment */
if (is_assignment(buf)) {
tTokenizer t;
t = tokenize(buf, "=");
char *val = strdup( trim(t.tokens[1]) );
if (val[strlen(val) - 1] == ';') {
val[strlen(val) - 1] = 0;
if (is_numeric(val) || is_string(val)) {
if (is_string(val)) {
*val++;
val[strlen(val) - 1] = 0;
}
if (variable_add(trim(t.tokens[0]), val, TYPE_QSCRIPT, -1, gettype(val)) < 0) {
desc_printf(gIO, gFd, "Cannot set new value to variable %s\n", trim(t.tokens[0]));
ret = -EEXIST;
}
else
ret = 0;
}
else
if (regex_match("([^(]*)([^)]*)", val)) {
tTokenizer t2;
char *args = NULL;
char *fn;
t2 = tokenize(val, "(");
if (t2.tokens[t2.numTokens - 1][strlen(t2.tokens[t2.numTokens - 1]) - 1] != ')') {
ret = -EINVAL;
goto cleanup;
}
t2.tokens[t2.numTokens - 1][strlen(t2.tokens[t2.numTokens - 1]) - 1] = 0;
fn = strdup(t2.tokens[0]);
/* We need to make sure parenthesis won't break script line */
if (t2.numTokens > 1) {
int i;
char argstmp[8192] = { 0 };
for (i = 1; i < t2.numTokens; i++) {
strcat(argstmp, t2.tokens[i]);
if (i < t2.numTokens - 1)
strcat(argstmp, "(");
}
args = strdup(argstmp);
}
if (args != NULL) {
char args2[1024] = { 0 };
snprintf(args2, sizeof(args2), "%s", args + 1);
args2[ strlen(args2) - 1] = 0;
args = utils_free("scripting.function-call.args", args);
args = strdup( args2 );
}
free_tokens(t2);
if (_script_builtin_function(trim(t.tokens[0]), fn, args) != 0)
DPRINTF("Function %s doesn't seem to be builtin, we should try user-defined function\n", fn);
DPRINTF("%s: Should be a function with return value\n", __FUNCTION__);
args = utils_free("scripting.function-call.args", args);
fn = utils_free("scripting.function-call.fn", fn);
ret = 0;
}
else
ret = -EINVAL;
}
free_tokens(t);
}
else
if (regex_match("([^(]*)([^)]*)", buf)) {
tTokenizer t2;
char *args = NULL;
char *fn;
t2 = tokenize(buf, "(");
if (t2.tokens[t2.numTokens - 1][strlen(t2.tokens[t2.numTokens - 1]) - 1] != ';') {
ret = -EINVAL;
goto cleanup;
}
t2.tokens[t2.numTokens - 1][strlen(t2.tokens[t2.numTokens - 1]) - 1] = 0;
fn = strdup(t2.tokens[0]);
/* We need to make sure parenthesis won't break script line */
if (t2.numTokens > 1) {
int i;
char argstmp[8192] = { 0 };
for (i = 1; i < t2.numTokens; i++) {
strcat(argstmp, t2.tokens[i]);
if (i < t2.numTokens - 1)
strcat(argstmp, "(");
}
args = strdup(argstmp);
}
if (args != NULL) {
if (args[strlen(args) - 1] == ')')
args[strlen(args) - 1] = 0;
}
free_tokens(t2);
if (_script_builtin_function(NULL, fn, args) != 0)
DPRINTF("Function %s doesn't seem to be builtin, we should try user-defined function\n", fn);
args = utils_free("scripting.function-call.args", args);
fn = utils_free("scripting.function-call.fn", fn);
ret = 0;
}
else
DPRINTF("%s: Not implemented yet\n", __FUNCTION__);
cleanup:
if ((_perf_measure) && ((ts.tv_nsec > 0) && (ts.tv_sec > 0)) && (_script_in_condition_and_met > 0)) {
tse = utils_get_time( TIME_CURRENT );
desc_printf(gIO, gFd, "PERF: Line \"%s\" was being processed for %.3f microseconds (%.3f ms)\n\n",
buf, get_time_float_us( tse, ts ), get_time_float_us(tse, ts) / 1000.);
}
return ret;
}
int run_script(char *filename)
{
FILE *fp;
int opened = 0;
char buf[4096] = { 0 };
struct timespec ts = utils_get_time( TIME_CURRENT );
struct timespec tse;
if (access(filename, R_OK) != 0)
return -ENOENT;
_script_in_condition_and_met = -1;
fp = fopen(filename, "r");
if (fp == NULL)
return -EPERM;
if (gHttpHandler)
http_host_header(gIO, gFd, HTTP_CODE_OK, gHost, "text/html", NULL, myRealm, 0);
while (!feof(fp)) {
memset(buf, 0, sizeof(buf));
fgets(buf, sizeof(buf), fp);
if ((strlen(buf) > 1) && (buf[strlen(buf) - 1] == '\n'))
buf[strlen(buf) - 1] = 0;
if ((strlen(buf) > 1) && (buf[0] != '\n')) {
if (strcmp(buf, "<$") == 0)
opened = 1;
if (strcmp(buf, "$>") == 0)
opened = 0;
if ((opened) && (strcmp(buf, "<$") != 0))
script_process_line(trim(buf));
}
}
fclose(fp);
idb_free_last_select_data();
if (_perf_measure) {
tse = utils_get_time( TIME_CURRENT );
desc_printf(gIO, gFd, "PERF: File \"%s\" has been processed in %.3f microseconds (%.3f ms)\n\n",
basename(filename), get_time_float_us( tse, ts ), get_time_float_us(tse, ts) / 1000.);
}
variable_dump();
variable_free_all();
return 0;
}
object *eval(object *exp, object *env) {
object *procedure;
object *arguments;
object *result;
bool tailcall = false;
do {
if (is_self_evaluating(exp))
return exp;
if (is_variable(exp))
return lookup_variable_value(exp, env);
if (is_quoted(exp))
return text_of_quotation(exp);
if (is_assignment(exp))
return eval_assignment(exp, env);
if (is_definition(exp))
return eval_definition(exp, env);
if (is_if(exp)) {
exp = is_true(eval(if_predicate(exp), env)) ? if_consequent(exp) : if_alternative(exp);
tailcall = true;
continue;
}
if (is_lambda(exp))
return make_compound_proc(lambda_parameters(exp), lambda_body(exp), env);
if (is_begin(exp)) {
exp = begin_actions(exp);
while (!is_last_exp(exp)) {
eval(first_exp(exp), env);
exp = rest_exps(exp);
}
exp = first_exp(exp);
tailcall = true;
continue;
}
if (is_cond(exp)) {
exp = cond_to_if(exp);
tailcall = true;
continue;
}
if (is_let(exp)) {
exp = let_to_application(exp);
tailcall = true;
continue;
}
if (is_and(exp)) {
exp = and_tests(exp);
if (is_empty(exp))
return make_boolean(true);
while (!is_last_exp(exp)) {
result = eval(first_exp(exp), env);
if (is_false(result))
return result;
exp = rest_exps(exp);
}
exp = first_exp(exp);
tailcall = true;
continue;
}
if (is_or(exp)) {
exp = or_tests(exp);
if (is_empty(exp)) {
return make_boolean(false);
}
while (!is_last_exp(exp)) {
result = eval(first_exp(exp), env);
if (is_true(result))
return result;
exp = rest_exps(exp);
}
exp = first_exp(exp);
tailcall = true;
continue;
}
if (is_application(exp)) {
procedure = eval(operator(exp), env);
arguments = list_of_values(operands(exp), env);
if (is_primitive_proc(procedure) && procedure->data.primitive_proc.fn == eval_proc) {
exp = eval_expression(arguments);
env = eval_environment(arguments);
tailcall = true;
continue;
}
if (is_primitive_proc(procedure) && procedure->data.primitive_proc.fn == apply_proc) {
procedure = apply_operator(arguments);
arguments = apply_operands(arguments);
}
if (is_primitive_proc(procedure))
return (procedure->data.primitive_proc.fn)(arguments);
if (is_compound_proc(procedure)) {
env = extend_environment(procedure->data.compound_proc.parameters, arguments, procedure->data.compound_proc.env);
exp = make_begin(procedure->data.compound_proc.body);
tailcall = true;
continue;
}
return make_error(342, "unknown procedure type");
} // is_application()
} while (tailcall);
fprintf(stderr, "cannot eval unknown expression type\n");
exit(EXIT_FAILURE);
}
/* run_pipe_real() starts all the jobs, but doesn't wait for anything
* to finish. See checkjobs().
*
* return code is normally -1, when the caller has to wait for children
* to finish to determine the exit status of the pipe. If the pipe
* is a simple builtin command, however, the action is done by the
* time run_pipe_real returns, and the exit code is provided as the
* return value.
*
* The input of the pipe is always stdin, the output is always
* stdout. The outpipe[] mechanism in BusyBox-0.48 lash is bogus,
* because it tries to avoid running the command substitution in
* subshell, when that is in fact necessary. The subshell process
* now has its stdout directed to the input of the appropriate pipe,
* so this routine is noticeably simpler.
*/
static int run_pipe_real(struct pipe *pi) {
int i;
int nextin;
int flag = do_repeat ? CMD_FLAG_REPEAT : 0;
struct child_prog *child;
cmd_tbl_t *cmdtp;
char *p;
# if __GNUC__
/* Avoid longjmp clobbering */
(void) &i;
(void) &nextin;
(void) &child;
# endif
nextin = 0;
/* Check if this is a simple builtin (not part of a pipe).
* Builtins within pipes have to fork anyway, and are handled in
* pseudo_exec. "echo foo | read bar" doesn't work on bash, either.
*/
if (pi->num_progs == 1)
child = &(pi->progs[0]);
if (pi->num_progs == 1 && child->group) {
int rcode;
debug_printf("non-subshell grouping\n");
rcode = run_list_real(child->group);
return rcode;
} else if (pi->num_progs == 1 && pi->progs[0].argv != NULL) {
for (i = 0; is_assignment(child->argv[i]); i++) { /* nothing */
}
if (i != 0 && child->argv[i] == NULL) {
/* assignments, but no command: set the local environment */
for (i = 0; child->argv[i] != NULL; i++) {
/* Ok, this case is tricky. We have to decide if this is a
* local variable, or an already exported variable. If it is
* already exported, we have to export the new value. If it is
* not exported, we need only set this as a local variable.
* This junk is all to decide whether or not to export this
* variable. */
int export_me = 0;
char *name, *value;
name = xstrdup(child->argv[i]);
debug_printf("Local environment set: %s\n", name);
value = strchr(name, '=');
if (value)
*value = 0;
free(name);
p = insert_var_value(child->argv[i]);
set_local_var(p, export_me);
if (p != child->argv[i])
free(p);
}
return EXIT_SUCCESS; /* don't worry about errors in set_local_var() yet */
}
for (i = 0; is_assignment(child->argv[i]); i++) {
p = insert_var_value(child->argv[i]);
set_local_var(p, 0);
if (p != child->argv[i]) {
child->sp--;
free(p);
}
}
if (child->sp) {
char * str = NULL;
str = make_string((child->argv + i));
parse_string_outer(str, FLAG_EXIT_FROM_LOOP | FLAG_REPARSING);
free(str);
return last_return_code;
}
/* check ";", because ,example , argv consist from
* "help;flinfo" must not execute
*/
if (strchr(child->argv[i], ';')) {
printf_err("unknown command '%s' - try 'help' or use 'run' command\n", child->argv[i]);
return -1;
}
/* Look up command in command table */
if ((cmdtp = find_cmd(child->argv[i])) == NULL) {
printf_err("unknown command '%s' - try 'help'\n", child->argv[i]);
return -1; /* give up after bad command */
} else {
int rcode;
#if defined(CONFIG_CMD_BOOTD)
extern int do_bootd (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
/* avoid "bootd" recursion */
if (cmdtp->cmd == do_bootd) {
if (flag & CMD_FLAG_BOOTD) {
printf_err("'bootd' recursion detected!\n");
return -1;
} else {
flag |= CMD_FLAG_BOOTD;
}
}
#endif /* CONFIG_CMD_BOOTD */
/* found - check max args */
if ((child->argc - i) > cmdtp->maxargs) {
print_cmd_help(cmdtp);
return -1;
}
child->argv += i; /* XXX horrible hack */
/* OK - call function to do the command */
rcode = (cmdtp->cmd)(cmdtp, flag, child->argc - i, &child->argv[i]);
if (!cmdtp->repeatable)
flag_repeat = 0;
child->argv -= i; /* XXX restore hack so free() can work right */
return rcode;
}
}
return -1;
}
void symex_target_equationt::SSA_stept::output(
const namespacet &ns,
std::ostream &out) const
{
if(source.is_set)
{
out << "Thread " << source.thread_nr;
if(source.pc->source_location.is_not_nil())
out << " " << source.pc->source_location << std::endl;
else
out << std::endl;
}
switch(type)
{
case goto_trace_stept::ASSERT: out << "ASSERT " << from_expr(ns, "", cond_expr) << std::endl; break;
case goto_trace_stept::ASSUME: out << "ASSUME " << from_expr(ns, "", cond_expr) << std::endl; break;
case goto_trace_stept::LOCATION: out << "LOCATION" << std::endl; break;
case goto_trace_stept::INPUT: out << "INPUT" << std::endl; break;
case goto_trace_stept::OUTPUT: out << "OUTPUT" << std::endl; break;
case goto_trace_stept::DECL:
out << "DECL" << std::endl;
out << from_expr(ns, "", ssa_lhs) << std::endl;
break;
case goto_trace_stept::ASSIGNMENT:
out << "ASSIGNMENT (";
switch(assignment_type)
{
case HIDDEN: out << "HIDDEN"; break;
case STATE: out << "STATE"; break;
case VISIBLE_ACTUAL_PARAMETER: out << "VISIBLE_ACTUAL_PARAMETER"; break;
case HIDDEN_ACTUAL_PARAMETER: out << "HIDDEN_ACTUAL_PARAMETER"; break;
case PHI: out << "PHI"; break;
case GUARD: out << "GUARD"; break;
default:;
}
out << ")" << std::endl;
break;
case goto_trace_stept::DEAD: out << "DEAD" << std::endl; break;
case goto_trace_stept::FUNCTION_CALL: out << "FUNCTION_CALL" << std::endl; break;
case goto_trace_stept::FUNCTION_RETURN: out << "FUNCTION_RETURN" << std::endl; break;
case goto_trace_stept::CONSTRAINT: out << "CONSTRAINT" << std::endl; break;
case goto_trace_stept::SHARED_READ: out << "SHARED READ" << std::endl; break;
case goto_trace_stept::SHARED_WRITE: out << "SHARED WRITE" << std::endl; break;
case goto_trace_stept::ATOMIC_BEGIN: out << "ATOMIC_BEGIN" << std::endl; break;
case goto_trace_stept::ATOMIC_END: out << "AUTOMIC_END" << std::endl; break;
case goto_trace_stept::SPAWN: out << "SPAWN" << std::endl; break;
case goto_trace_stept::MEMORY_BARRIER: out << "MEMORY_BARRIER" << std::endl; break;
case goto_trace_stept::GOTO: out << "IF " << from_expr(ns, "", cond_expr) << " GOTO" << std::endl; break;
default: assert(false);
}
if(is_assert() || is_assume() || is_assignment() || is_constraint())
out << from_expr(ns, "", cond_expr) << std::endl;
if(is_assert() || is_constraint())
out << comment << std::endl;
if(is_shared_read() || is_shared_write())
out << from_expr(ns, "", ssa_lhs) << std::endl;
out << "Guard: " << from_expr(ns, "", guard) << std::endl;
}
/* run_pipe_real() starts all the jobs, but doesn't wait for anything
* to finish. See checkjobs().
*
* return code is normally -1, when the caller has to wait for children
* to finish to determine the exit status of the pipe. If the pipe
* is a simple builtin command, however, the action is done by the
* time run_pipe_real returns, and the exit code is provided as the
* return value.
*
* The input of the pipe is always stdin, the output is always
* stdout. The outpipe[] mechanism in BusyBox-0.48 lash is bogus,
* because it tries to avoid running the command substitution in
* subshell, when that is in fact necessary. The subshell process
* now has its stdout directed to the input of the appropriate pipe,
* so this routine is noticeably simpler.
*/
static int run_pipe_real(struct pipe *pi)
{
int i;
int nextin;
int flag = do_repeat ? CMD_FLAG_REPEAT : 0;
struct child_prog *child;
char *p;
#if __GNUC__
/* Avoid longjmp clobbering */
(void) &i;
(void) &nextin;
(void) &child;
#endif
nextin = 0;
/* Check if this is a simple builtin (not part of a pipe).
* Builtins within pipes have to fork anyway, and are handled in
* pseudo_exec. "echo foo | read bar" doesn't work on bash, either.
*/
if (pi->num_progs == 1) child = & (pi->progs[0]);
if (pi->num_progs == 1 && child->group) {
int rcode;
debug_printf("non-subshell grouping\n");
rcode = run_list_real(child->group);
return rcode;
} else if (pi->num_progs == 1 && pi->progs[0].argv != NULL) {
for (i=0; is_assignment(child->argv[i]); i++) { /* nothing */ }
if (i!=0 && child->argv[i]==NULL) {
/* assignments, but no command: set the local environment */
for (i=0; child->argv[i]!=NULL; i++) {
/* Ok, this case is tricky. We have to decide if this is a
* local variable, or an already exported variable. If it is
* already exported, we have to export the new value. If it is
* not exported, we need only set this as a local variable.
* This junk is all to decide whether or not to export this
* variable. */
int export_me=0;
char *name, *value;
name = xstrdup(child->argv[i]);
debug_printf("Local environment set: %s\n", name);
value = strchr(name, '=');
if (value)
*value=0;
free(name);
p = insert_var_value(child->argv[i]);
set_local_var(p, export_me);
if (p != child->argv[i]) free(p);
}
return EXIT_SUCCESS; /* don't worry about errors in set_local_var() yet */
}
for (i = 0; is_assignment(child->argv[i]); i++) {
p = insert_var_value(child->argv[i]);
set_local_var(p, 0);
if (p != child->argv[i]) {
child->sp--;
free(p);
}
}
if (child->sp) {
char * str = NULL;
str = make_string((child->argv + i));
parse_string_outer(str, FLAG_EXIT_FROM_LOOP | FLAG_REPARSING);
free(str);
return last_return_code;
}
/* check ";", because ,example , argv consist from
* "help;flinfo" must not execute
*/
if (strchr(child->argv[i], ';')) {
printf("Unknown command '%s' - try 'help' or use "
"'run' command\n", child->argv[i]);
return -1;
}
/* Process the command */
return cmd_process(flag, child->argc, child->argv,
&flag_repeat, NULL);
}
return -1;
}
void ssa_domaint::transform(
locationt from,
locationt to,
ai_baset &ai,
const namespacet &ns)
{
if(from->is_assign() || from->is_decl() || from->is_function_call())
{
const auto &assignments=static_cast<ssa_ait &>(ai).assignments;
const std::set<ssa_objectt> &assigns=assignments.get(from);
for(std::set<ssa_objectt>::const_iterator
o_it=assigns.begin();
o_it!=assigns.end();
o_it++)
{
if(o_it->get_expr().get_bool("#is_rhs_assign") &&
is_pointed(o_it->get_root_object()))
{
// the second part excluded cases
// when a result of malloc is at the right-handed side
const auto object_ai_it=
static_cast<ssa_ait &>(ai)[from].def_map.find(o_it->get_identifier());
if(object_ai_it!=static_cast<ssa_ait &>(ai)[from].def_map.end() &&
object_ai_it->second.def.is_assignment())
{
const exprt pointer=
get_pointer(
o_it->get_root_object(),
pointed_level(o_it->get_root_object())-1);
const auto def_pointer=
static_cast<ssa_ait &>(ai)[from]
.def_map.find(
ssa_objectt(pointer, ns).get_identifier())->second.def;
if(!def_pointer.is_assignment() ||
def_pointer.loc->location_number<
object_ai_it->second.def.loc->location_number)
{
continue;
}
}
}
irep_idt identifier=o_it->get_identifier();
def_entryt &def_entry=def_map[identifier];
def_entry.def.loc=from;
def_entry.source=from;
auto guard_it=assignments.alloc_guards_map.find({from, *o_it});
if(guard_it!=assignments.alloc_guards_map.end())
{
def_entry.def.kind=deft::ALLOCATION;
def_entry.def.guard=guard_it->second;
}
else
def_entry.def.kind=deft::ASSIGNMENT;
}
}
else if(from->is_dead())
{
const code_deadt &code_dead=to_code_dead(from->code);
const irep_idt &id=code_dead.get_identifier();
def_map.erase(id);
}
// update source in all defs
for(def_mapt::iterator
d_it=def_map.begin(); d_it!=def_map.end(); d_it++)
d_it->second.source=from;
}
object *bs_eval(object *exp, object *env)
{
tailcall:
if (is_empty_list(exp)) {
error("unable to evaluate empty list");
} else if (is_self_evaluating(exp)) {
return exp;
} else if (is_variable(exp)) {
return lookup_variable_value(exp, env);
} else if (is_quoted(exp)) {
return quoted_expression(exp);
} else if (is_assignment(exp)) {
return eval_assignment(exp, env);
} else if (is_definition(exp)) {
return eval_definition(exp, env);
} else if (is_if(exp)) {
if (is_true(bs_eval(if_predicate(exp), env))) {
exp = if_consequent(exp);
} else {
exp = if_alternate(exp);
}
goto tailcall;
} else if (is_lambda(exp)) {
return make_compound_proc(lambda_parameters(exp),
lambda_body(exp),
env);
} else if (is_begin(exp)) {
exp = begin_actions(exp);
if (is_empty_list(exp)) {
error("empty begin block");
}
while (!is_empty_list(cdr(exp))) {
bs_eval(car(exp), env);
exp = cdr(exp);
}
exp = car(exp);
goto tailcall;
} else if (is_cond(exp)) {
exp = cond_to_if(exp);
goto tailcall;
} else if (is_let(exp)) {
exp = let_to_application(exp);
goto tailcall;
} else if (is_and(exp)) {
exp = and_tests(exp);
if (is_empty_list(exp)) {
return get_boolean(1);
}
object *result;
while (!is_empty_list(cdr(exp))) {
result = bs_eval(car(exp), env);
if (is_false(result)) {
return result;
}
exp = cdr(exp);
}
exp = car(exp);
goto tailcall;
} else if (is_or(exp)) {
exp = or_tests(exp);
if (is_empty_list(exp)) {
return get_boolean(0);
}
object *result;
while (!is_empty_list(cdr(exp))) {
result = bs_eval(car(exp), env);
if (is_true(result)) {
return result;
}
exp = cdr(exp);
}
exp = car(exp);
goto tailcall;
} else if (is_application(exp)) {
object *procedure = bs_eval(application_operator(exp), env);
object *parameters = eval_parameters(application_operands(exp), env);
// handle eval specially for tailcall requirement.
if (is_primitive_proc(procedure) &&
procedure->value.primitive_proc == eval_proc) {
exp = eval_expression(parameters);
env = eval_environment(parameters);
goto tailcall;
}
// handle apply specially for tailcall requirement.
if (is_primitive_proc(procedure) &&
procedure->value.primitive_proc == apply_proc) {
procedure = apply_operator(parameters);
parameters = apply_operands(parameters);
}
if (is_primitive_proc(procedure)) {
return (procedure->value.primitive_proc)(parameters);
} else if (is_compound_proc(procedure)) {
env = extend_environment(
procedure->value.compound_proc.parameters,
parameters,
procedure->value.compound_proc.env);
exp = make_begin(procedure->value.compound_proc.body);
goto tailcall;
} else {
error("unable to apply unknown procedure type");
}
} else {
error("unable to evaluate expression");
}
}
static pSlipObject slip_eval(pSlip gd, pSlipObject exp, pSlipEnvironment env)
{
pSlipObject proc;
pSlipObject args;
tailcall:
if (is_self_evaluating(exp) == S_TRUE)
{
return exp;
}
else if (is_variable(exp) == S_TRUE)
{
return lookup_variable_value(gd, exp, env);
}
else if (is_quoted(gd, exp) == S_TRUE)
{
return text_of_quotation(exp);
}
else if (is_assignment(gd, exp) == S_TRUE)
{
return eval_assignment(gd, exp, env);
}
else if (is_definition(gd, exp) == S_TRUE)
{
return eval_definition(gd, exp, env);
}
else if (is_if(gd, exp) == S_TRUE)
{
exp = is_true(gd, slip_eval(gd, if_predicate(exp), env)) == S_TRUE ? if_consequent(exp) : if_alternative(gd, exp);
goto tailcall;
}
else if (is_lambda(gd, exp) == S_TRUE)
{
return s_NewCompoundProc(gd, lambda_parameters(exp), lambda_body(exp), env);
}
else if (is_begin(gd, exp) == S_TRUE)
{
exp = begin_actions(exp);
while (!is_last_exp(gd, exp))
{
slip_eval(gd, first_exp(exp), env);
exp = rest_exps(exp);
}
exp = first_exp(exp);
goto tailcall;
}
else if (is_cond(gd, exp) == S_TRUE)
{
exp = cond_to_if(gd, exp);
goto tailcall;
}
else if (is_let(gd, exp) == S_TRUE)
{
exp = let_to_application(gd, exp);
goto tailcall;
}
else if (is_application(exp) == S_TRUE)
{
proc = slip_eval(gd, slip_operator(exp), env);
if (proc == NULL)
return gd->singleton_False;
if (proc->type == eType_PRIMITIVE_PROC || proc->type == eType_COMPOUND_PROC)
{
args = list_of_values(gd, operands(exp), env);
if (args == NULL)
return gd->singleton_False;
if (sIsObject_PrimitiveProc(proc) == S_TRUE)
{
return proc->data.prim_proc.func(gd, args);
}
else if (sIsObject_CompoundProc(proc) == S_TRUE)
{
env = setup_environment(gd, proc->data.comp_proc.env, proc->data.comp_proc.params, args);
exp = make_begin(gd, proc->data.comp_proc.code);
goto tailcall;
}
else
{
throw_error(gd, "unknown procedure type\n");
return gd->singleton_False;
}
}
else
return proc;
}
else
{
throw_error(gd, "cannot eval unknown expression type\n");
return NULL;
}
throw_error(gd, "what??\n");
return NULL;
}
int builtin_evaluate(Environment &env, std::vector<token> &&tokens, const fdmask &fds) {
// evaluate expression
// evaluate variable = expression
// evaluate variable += expression
// evaluate variable -= expression
// flags -- -h -o -b -- print in hex, octal, or binary
// convert the arguments to a stack.
int output = 'd';
//io_helper io(fds);
std::reverse(tokens.begin(), tokens.end());
// remove 'Evaluate'
tokens.pop_back();
// check for -h -x -o
if (tokens.size() >= 2 && tokens.back().type == '-') {
const token &t = tokens[tokens.size() - 2];
if (t.type == token::text && t.string.length() == 1) {
int flag = tolower(t.string[0]);
switch(flag) {
case 'o':
case 'h':
case 'b':
output = flag;
tokens.pop_back();
tokens.pop_back();
}
}
}
if (tokens.size() >= 2 && tokens.back().type == token::text)
{
int type = tokens[tokens.size() -2].type;
if (is_assignment(type)) {
std::string name = tokens.back().string;
tokens.pop_back();
tokens.pop_back();
int32_t i = evaluate_expression("Evaluate", std::move(tokens));
switch(type) {
case '=':
env.set(name, i);
break;
case '+=':
case '-=':
{
value old;
auto iter = env.find(name);
if (iter != env.end()) old = (const std::string &)iter->second;
switch(type) {
case '+=':
i = old.to_number() + i;
break;
case '-=':
i = old.to_number() - i;
break;
}
env.set(name, i);
}
break;
}
return 0;
}
}
int32_t i = evaluate_expression("Evaluate", std::move(tokens));
if (output == 'h') {
fdprintf(stdout, "0x%08x\n", i);
return 0;
}
if (output == 'b') {
std::string tmp("0b");
for (int j = 0; j < 32; ++j) {
tmp.push_back(i & 0x80000000 ? '1' : '0');
i <<= 1;
}
tmp.push_back('\n');
fdputs(tmp.c_str(), stdout);
return 0;
}
if (output == 'o') {
// octal.
fdprintf(stdout, "0%o\n", i);
return 0;
}
fdprintf(stdout, "%d\n", i);
return 0;
}
///////////////////////////////////////////////////////////////////
//eval
//requires two arguments:exp & tail_context
///////////////////////////////////////////////////////////////////
cellpoint eval(void)
{
if (is_true(is_self_evaluating(args_ref(1)))){
reg = args_ref(1);
}else if (is_true(is_variable(args_ref(1)))){
reg = args_ref(1);
args_push(current_env);
args_push(reg);
reg = lookup_var_val();
}else if (is_true(is_quoted(args_ref(1)))){
args_push(args_ref(1));
reg = quotation_text();
}else if (is_true(is_assignment(args_ref(1)))){
args_push(args_ref(1));
reg = eval_assignment();
}else if (is_true(is_definition(args_ref(1)))){
args_push(args_ref(1));
reg = eval_definition();
}else if (is_true(is_if(args_ref(1)))){
//eval if expression with the second argument (tail_context)
reg = args_ref(1);
args_push(args_ref(2));
args_push(reg);
reg = eval_if();
}else if (is_true(is_lambda(args_ref(1)))){
args_push(args_ref(1));
reg = eval_lambda();
}else if (is_true(is_begin(args_ref(1)))){
args_push(args_ref(1));
reg = begin_actions();
//eval the actions of begin exp with the second argument (tail_context)
args_push(args_ref(2));
args_push(reg);
reg = eval_sequence();
}else if (is_true(is_cond(args_ref(1)))){
args_push(args_ref(1));
reg = cond_2_if();
//eval the exp with the second argument (tail_context)
args_push(args_ref(2));
args_push(reg);
reg = eval();
}else if (is_true(is_and(args_ref(1)))){
reg = args_ref(1);
args_push(args_ref(2));
args_push(reg);
reg = eval_and();
}else if (is_true(is_or(args_ref(1)))){
reg = args_ref(1);
args_push(args_ref(2));
args_push(reg);
reg = eval_or();
}else if (is_true(is_let(args_ref(1)))){
//convert let to combination
args_push(args_ref(1));
reg = let_2_combination();
//evals the combination
args_push(args_ref(2));
args_push(reg);
reg = eval();
}else if (is_true(is_letstar(args_ref(1)))){
//convert let* to nested lets
args_push(args_ref(1));
reg = letstar_2_nested_lets();
//evals the nested lets
args_push(args_ref(2));
args_push(reg);
reg = eval();
}else if (is_true(is_application(args_ref(1)))){
//computes operator
args_push(args_ref(1));
reg = operator();
args_push(a_false);
args_push(reg);
reg = eval();
stack_push(&vars_stack, reg);
//computes operands
args_push(args_ref(1));
reg = operands();
args_push(reg);
reg = list_of_values();
//calls apply with the second argument (tail_context)
args_push(args_ref(2));
args_push(reg);
args_push(stack_pop(&vars_stack));
reg = apply();
}else {
printf("Unknown expression type -- EVAL\n");
error_handler();
}
args_pop(2);
return reg;
}