literalt smt1_propt::land(literalt a, literalt b)
{
if(a==const_literal(true))
return b;
if(b==const_literal(true))
return a;
if(a==const_literal(false))
return const_literal(false);
if(b==const_literal(false))
return const_literal(false);
if(a==b)
return a;
out << "\n";
literalt l=new_variable();
out << ":assumption ; land" << "\n";
out << " (iff " << smt1_literal(l) << " (and";
out << " " << smt1_literal(a);
out << " " << smt1_literal(b);
out << "))" << "\n";
return l;
}
literalt smt1_propt::lselect(literalt a, literalt b, literalt c)
{
if(a==const_literal(true))
return b;
if(a==const_literal(false))
return c;
if(b==c)
return b;
if(a==const_literal(false))
return b;
if(b==const_literal(false))
return a;
if(a==const_literal(true))
return !b;
if(b==const_literal(true))
return !a;
out << "\n";
literalt l=new_variable();
out << ":assumption ; lselect" << "\n";
out << " (iff " << smt1_literal(l) << "(if_then_else "
<< smt1_literal(a) << " " << smt1_literal(b) << " "
<< smt1_literal(c) << ")" << "\n";
return l;
}
static variable_t*
parse_listitem(char *line, group_t *head) {
int found_comma = false;
variable_t *listitem;
variable_t *subitem;
char *p;
listitem = new_variable(NULL, VT_LISTITEM);
if (listitem == NULL)
return NULL;
p = line +1; /* skip past { */
do {
/* Skip whitespace before identifier */
skip_whitespace(&p);
subitem = parse_keyvalue(&p,head);
add_to_listitem(listitem, subitem);
skip_whitespace(&p);
if (*p == ',') {
p++;
found_comma = true;
}
if (*p == '}') {
p++;
break;
}
} while( found_comma );
return listitem;
}
void Environment::add_variable(Type *t, std::string ident)
{
MapPtr tip = this->env_v_tip();
VarInfoPtr new_variable(new Environment::var_info);
new_variable->type = t;
(*tip)[ident] = new_variable;
}
void Environment::add_field_to_cls(std::string & class_name, Type *type, std::string & ident)
{
Environment::ClsInfoPtr this_class = this->get_class(class_name);
Environment::VarInfoPtr new_variable(new Environment::var_info);
new_variable->type = type;
this_class->fields[ident] = new_variable;
}
literalt cnft::land(const bvt &bv)
{
if(bv.size()==0) return const_literal(true);
if(bv.size()==1) return bv[0];
if(bv.size()==2) return land(bv[0], bv[1]);
forall_literals(it, bv)
if(it->is_false())
return *it;
if(is_all(bv, const_literal(true)))
return const_literal(true);
bvt new_bv;
eliminate_duplicates(bv, new_bv);
bvt lits(2);
literalt literal=new_variable();
lits[1]=neg(literal);
forall_literals(it, new_bv)
{
lits[0]=pos(*it);
lcnf(lits);
}
static variable_t*
parse_keyvalue(char **ptr, group_t *head) {
char *p = *ptr;
char name[MAXIDLEN];
variable_t* var;
parse_identifier(&p, name, sizeof(name));
skip_whitespace(&p);
if (*p != '=') {
fprintf(stderr, "%s:%d: No assignment detected!\n", __func__, lineno);
return NULL;
} else {
p++;
}
skip_whitespace(&p);
/* create variable, assume string */
var = new_variable(name, VT_STRING);
/* parse value of variable */
parse_expr(&p, var, head);
*ptr = p;
return var;
}
GSList *math_string_to_infix(gchar *string)
{
GSList *infix = NULL;
gchar *expr = string;
for (; *expr; expr++) {
if (strchr("+-/*^()", *expr)) {
infix = g_slist_append(infix, new_operator(*expr));
} else if (strchr("@", *expr)) {
infix = g_slist_append(infix, new_variable(*expr));
} else if (strchr("-.1234567890", *expr)) {
gfloat value;
sscanf(expr, "%f", &value);
while (*expr && strchr(".1234567890", *expr))
expr++;
expr--;
infix = g_slist_append(infix, new_value(value));
} else if (!isspace(*expr)) {
g_print("Invalid token: [%c][%d]\n", *expr, *expr);
math_infix_free(infix, TRUE);
return NULL;
}
}
return infix;
}
svariable_t *add_game_fixed(char *name, fixed_t *fixed)
{
svariable_t *newvar;
newvar = new_variable(&global_script, name, svt_pFixed);
newvar->value.pFixed = fixed;
return newvar;
}
svariable_t *add_game_mobj(char *name, mobj_t **mo)
{
svariable_t* newvar;
newvar = new_variable(&global_script, name, svt_pMobj);
newvar->value.pMobj = mo;
return newvar;
}
bvt propt::new_variables(std::size_t width)
{
bvt result;
result.resize(width);
for(std::size_t i=0; i<width; i++)
result[i]=new_variable();
return result;
}
svariable_t *add_game_string(char *name, char **var)
{
svariable_t* newvar;
newvar = new_variable(&global_script, name, svt_pString);
newvar->value.pS = var;
return newvar;
}
svariable_t *add_game_int(char *name, int *var)
{
svariable_t* newvar;
newvar = new_variable(&global_script, name, svt_pInt);
newvar->value.pI = var;
return newvar;
}
string symbol_table::new_temporary(const string& type)
{
char c_name[15];
snprintf(c_name, 15, "T%d", temp_seed_++);
symbol_entry ent;
new_variable(string(c_name), type, ent);
return string(c_name);
}
int gettempvar()
{
variable_t*v = find_variable(state, TEMPVARNAME);
int i;
if(v)
i = v->index;
else
i = new_variable(state->method, TEMPVARNAME, 0, 0, 0);
as3_assert(i);
return i;
}
literalt z3_propt::lxor(literalt a, literalt b)
{
if(a==const_literal(false)) return b;
if(b==const_literal(false)) return a;
if(a==const_literal(true)) return lnot(b);
if(b==const_literal(true)) return lnot(a);
literalt o=new_variable();
lxor(a, b, o);
return o;
}
void varlist(int level) {
if(token == ID) {
debug(level,"VARLIST");
new_variable(id_string, 0);
debug_lex();
while(token == TK_COMMA){
debug_lex();
if(token == ID) {
new_variable(id_string, 0);
debug_lex();
} else {
/* syntax error id expected */
syntax_error("ID expected");
}
}
}
}
/* Libera el registro AL y lo retorna */
Element *get_free_AL() {
Element *ret = (Element *)malloc(sizeof(Element));
if (state[0] != 0) {
Element *aux = (Element *)malloc(sizeof(Element));
aux = new_variable();
free_AL(aux);
state[1] = 0;
}
ret = load_register(0);
return ret;
}
literalt z3_propt::land(literalt a, literalt b)
{
if(a==const_literal(true)) return b;
if(b==const_literal(true)) return a;
if(a==const_literal(false)) return const_literal(false);
if(b==const_literal(false)) return const_literal(false);
if(a==b) return a;
literalt o=new_variable();
land(a, b, o);
return o;
}
void symbol_table::new_func_params(const vector<func_arg>& args)
{
// add parameter as variable
int offset = 0;
for (auto arg : args)
{
symbol_entry arg_ent;
new_variable(arg.name, arg.type, arg_ent);
arg_ent->second.place("ebp");
arg_ent->second.offset(offset);
arg_ent->second.is_parameter(true);
offset += size_of(arg.type);
}
}
svariable_t *new_function(char *name, void (*handler)() )
{
svariable_t *newvar;
// create the new variable for the function
// add to the global script
newvar = new_variable(&global_script, name, svt_function);
// add neccesary info
newvar->value.handler = handler;
return newvar;
}
literalt boolector_propt::lxor(literalt a, literalt b)
{
if(a==const_literal(false)) return b;
if(b==const_literal(false)) return a;
if(a==const_literal(true)) return lnot(b);
if(b==const_literal(true)) return lnot(a);
literalt l=new_variable();
BtorExp *result;
result = boolector_xor(boolector_ctx, boolector_literal(a), boolector_literal(b));
boolector_assert(boolector_ctx, boolector_iff(boolector_ctx, boolector_literal(l), result));
return l;
}
literalt smt1_propt::lor(const bvt &bv)
{
out << "\n";
literalt l=new_variable();
out << ":assumption ; lor" << "\n";
out << " (iff " << smt1_literal(l) << " (or";
forall_literals(it, bv)
out << " " << smt1_literal(*it);
out << "))" << "\n";
return l;
}
literalt smt1_propt::land(const bvt &bv)
{
out << std::endl;
literalt l=new_variable();
out << ":assumption ; land" << std::endl;
out << " (iff " << smt1_literal(l) << " (and";
forall_literals(it, bv)
out << " " << smt1_literal(*it);
out << "))" << std::endl;
return l;
}
/* Libera un registro que no sea AH o AL y lo retorna *
* Siempre se retorna un registro, haya o no uno libre *
* El registro quedara marcado como libre */
Element *get_free_notA() {
int i = N - 1;
Element *ret = (Element *)malloc(sizeof(Element));
while (i > 1 && state[i] == 1) i--;
if (i > 1) {
/* Hay un registro libre, se lo retorna */
ret = load_register(i);
} else {
/* No hay registros libres, dar de alta una nueva variable en la tabla de simbolos
* y liberar un registro. */
ret = free_any_notA(new_variable());
state[ret->value] = 0;
}
return ret;
}
literalt qbf_bdd_coret::lor(literalt a, literalt b)
{
literalt nl = new_variable();
std::cout << "LOR2" << std::endl;
BDD abdd(*bdd_variable_map[a.var_no()]);
BDD bbdd(*bdd_variable_map[b.var_no()]);
if(a.sign()) abdd = ~abdd;
if(b.sign()) bbdd = ~bbdd;
*bdd_variable_map[nl.var_no()] |= abdd | bbdd;
return nl;
}
// create a new label. pass the location inside the script
svariable_t *new_label(char *labelptr)
{
svariable_t *newlabel; // labels are stored as variables
char labelname[128];
char *temp, *temp2;
// copy the label name from the script up to ':'
for(temp=labelptr, temp2 = labelname; *temp!=':'; temp++, temp2++)
*temp2 = *temp;
*temp2 = '\0'; // end string
newlabel = new_variable(current_script, labelname, svt_label);
// put neccesary data in the label
newlabel->value.labelptr = labelptr;
return newlabel;
}
literalt smt1_propt::lxor(literalt a, literalt b)
{
if(a==const_literal(false)) return b;
if(b==const_literal(false)) return a;
if(a==const_literal(true)) return lnot(b);
if(b==const_literal(true)) return lnot(a);
out << std::endl;
literalt l=new_variable();
out << ":assumption ; lxor" << std::endl;
out << " (iff " << smt1_literal(l) << " (xor";
out << " " << smt1_literal(a);
out << " " << smt1_literal(b);
out << "))" << std::endl;
return l;
}
literalt smt1_propt::lxor(const bvt &bv)
{
if(bv.size()==0) return const_literal(false);
if(bv.size()==1) return bv[0];
out << std::endl;
literalt l=new_variable();
out << ":assumption ; lxor" << std::endl;
out << " (iff " << smt1_literal(l) << " (xor";
forall_literals(it, bv)
out << " " << smt1_literal(*it);
out << "))" << std::endl;
return l;
}
literalt boolector_propt::lor(const bvt &bv)
{
literalt l=new_variable();
u_int size=bv.size()+1;
BtorExp *args[size], *result;
for(unsigned int i=0; i<bv.size(); i++)
{
args[i] = boolector_literal(bv[i]);
if (i==1)
result = boolector_or(boolector_ctx, args[0], args[1]);
else if (i>1)
result = boolector_or(boolector_ctx, result, args[i]);
}
boolector_assert(boolector_ctx, boolector_iff(boolector_ctx, boolector_literal(l), result));
return l;
}
