char *
btor_int_to_const (BtorMemMgr * mm, int x, int len)
{
char msb, *result;
int i;
assert (mm != NULL);
assert (len > 0);
BTOR_NEWN (mm, result, len + 1);
msb = (x & (1 << MSB_INT)) ? '1' : '0';
for (i = len - 1; i >= MSB_INT; i--)
result[len - 1 - i] = msb;
while (i >= 0)
{
result[len - 1 - i] = (x & (1 << i)) ? '1' : '0';
i--;
}
result[len] = '\0';
return result;
}
char *
btor_uext_const (BtorMemMgr * mm, const char *c, int len)
{
char *res, *q;
const char *p;
int rlen;
assert (mm != NULL);
assert (c != NULL);
assert (len > 0);
assert (is_valid_const (c));
rlen = (int) strlen (c) + len;
BTOR_NEWN (mm, res, rlen + 1);
for (q = res; len; len--, q++)
*q = '0';
for (p = c; *p; p++, q++)
*q = *p;
assert (res + rlen == q);
*q = 0;
return res;
}
static char *
mul_const (BtorMemMgr * mm, const char *a, const char *b)
{
char *result, *and, *add, *shift;
int i, j, len;
assert (mm != NULL);
assert (a != NULL);
assert (b != NULL);
assert (strlen (a) == strlen (b));
assert ((int) strlen (a) > 0);
assert (is_valid_const_3vl (a));
assert (is_valid_const_3vl (b));
len = (int) strlen (a);
result = btor_int_to_const (mm, 0, len);
for (i = len - 1; i >= 0; i--)
{
BTOR_NEWN (mm, and, len + 1);
for (j = 0; j < len; j++)
and[j] = BTOR_AND_CONST_3VL (a[j], b[i]);
and[len] = '\0';
shift = btor_sll_n_bits_const (mm, and, len - 1 - i);
add = add_const (mm, result, shift);
btor_delete_const (mm, result);
btor_delete_const (mm, and);
btor_delete_const (mm, shift);
result = add;
}
return result;
}
static char *
slice_const (BtorMemMgr * mm, const char *a, int upper, int lower)
{
const char *p, *eoa;
char *res, *q;
int len, delta;
assert (mm != NULL);
assert (a != NULL);
assert (upper < (int) strlen (a));
assert (upper >= lower);
assert (lower >= 0);
assert (is_valid_const_3vl (a));
len = (int) strlen (a);
delta = upper - lower + 1;
BTOR_NEWN (mm, res, delta + 1);
p = a + len - 1 - upper;
q = res;
eoa = a + len - 1 - lower;
while (p <= eoa)
*q++ = *p++;
*q = 0;
assert ((int) strlen (res) == delta);
return res;
}
static char *
add_const (BtorMemMgr * mm, const char *a, const char *b)
{
char carry, p0, p1, p2, *result;
int len, i;
assert (mm != NULL);
assert (a != NULL);
assert (b != NULL);
assert (strlen (a) == strlen (b));
assert ((int) strlen (a) > 0);
assert (is_valid_const_3vl (a));
assert (is_valid_const_3vl (b));
carry = '0';
len = (int) strlen (a);
BTOR_NEWN (mm, result, len + 1);
for (i = len - 1; i >= 0; i--)
{
result[i] = BTOR_XOR_CONST_3VL (BTOR_XOR_CONST_3VL (a[i], b[i]), carry);
p0 = BTOR_AND_CONST_3VL (a[i], b[i]);
p1 = BTOR_AND_CONST_3VL (a[i], carry);
p2 = BTOR_AND_CONST_3VL (b[i], carry);
carry = BTOR_OR_CONST_3VL (BTOR_OR_CONST_3VL (p0, p1), p2);
}
result[len] = '\0';
return result;
}
char *
btor_cond_const_3vl (BtorMemMgr * mm, const char *a, const char *b,
const char *c)
{
char *result;
int i, len;
assert (mm != NULL);
assert (a != NULL);
assert (b != NULL);
assert (c != NULL);
assert ((int) strlen (a) == 1);
assert (strlen (b) == strlen (c));
assert ((int) strlen (b) > 0);
if (a[0] == '1')
result = btor_copy_const (mm, b);
else if (a[0] == '0')
result = btor_copy_const (mm, c);
else
{
len = (int) strlen (b);
BTOR_NEWN (mm, result, len + 1);
for (i = 0; i < len; i++)
{
if (b[i] != 'x' && c[i] != 'x' && b[i] == c[i])
result[i] = b[i];
else
result[i] = 'x';
}
result[i] = '\0';
}
return result;
}
char *
btor_add_unbounded_const (BtorMemMgr * mm, const char *a, const char *b)
{
char *res, *r, c, x, y, s, *tmp;
int alen, blen, rlen;
const char *p, *q;
assert (mm != NULL);
assert (a != NULL);
assert (b != NULL);
assert (is_valid_const (a));
assert (is_valid_const (b));
a = strip_zeroes (a);
b = strip_zeroes (b);
if (!*a)
return btor_strdup (mm, b);
if (!*b)
return btor_strdup (mm, a);
alen = (int) strlen (a);
blen = (int) strlen (b);
rlen = (alen < blen) ? blen : alen;
rlen++;
BTOR_NEWN (mm, res, rlen + 1);
p = a + alen;
q = b + blen;
c = '0';
r = res + rlen;
*r = 0;
while (res < r)
{
x = (a < p) ? *--p : '0';
y = (b < q) ? *--q : '0';
s = x ^ y ^ c;
c = (x & y) | (x & c) | (y & c);
*--r = s;
}
p = strip_zeroes (res);
if ((p != res))
{
tmp = btor_copy_const (mm, p);
btor_delete_const (mm, res);
res = tmp;
}
return res;
}
char *
btor_const_to_decimal (BtorMemMgr * mem, const char *c)
{
char *res, *q, *tmp, *rem, ch;
BtorCharStack stack;
const char *p;
int len;
BTOR_INIT_STACK (stack);
assert (mem != NULL);
assert (c != NULL);
assert (is_valid_const (c));
res = btor_copy_const (mem, c);
while (*res)
{
tmp = btor_udiv_unbounded_const (mem, res, "1010", &rem); /* / 10 */
assert ((int) strlen (rem) <= 4);
ch = 0;
for (p = strip_zeroes (rem); *p; p++)
{
ch <<= 1;
if (*p == '1')
ch++;
}
assert (ch < 10);
ch += '0';
BTOR_PUSH_STACK (mem, stack, ch);
btor_delete_const (mem, rem);
btor_delete_const (mem, res);
res = tmp;
}
btor_delete_const (mem, res);
if (BTOR_EMPTY_STACK (stack))
BTOR_PUSH_STACK (mem, stack, '0');
len = BTOR_COUNT_STACK (stack);
BTOR_NEWN (mem, res, len + 1);
q = res;
p = stack.top;
while (p > stack.start)
*q++ = *--p;
assert (res + len == q);
*q = 0;
assert (len == (int) strlen (res));
BTOR_RELEASE_STACK (mem, stack);
return res;
}
char *
btor_const_to_hex (BtorMemMgr * mem, const char *c)
{
int clen, rlen, i, j, tmp;
char *res, ch;
assert (mem != NULL);
assert (c != NULL);
assert (is_valid_const (c));
clen = (int) strlen (c);
rlen = (clen + 3) / 4;
if (rlen)
{
BTOR_NEWN (mem, res, rlen + 1);
i = clen - 1;
j = rlen;
res[j--] = 0;
while (i >= 0)
{
tmp = (c[i--] == '1');
if (i >= 0)
{
tmp |= (c[i--] == '1') << 1;
if (i >= 0)
{
tmp |= (c[i--] == '1') << 2;
if (i >= 0)
tmp |= (c[i--] == '1') << 3;
}
}
if (tmp < 10)
ch = '0' + tmp;
else
ch = 'a' + (tmp - 10);
res[j--] = ch;
}
}
else
res = btor_strdup (mem, "0");
return res;
}
char *
btor_zero_const (BtorMemMgr * mm, int len)
{
char *res;
int i;
assert (len > 0);
BTOR_NEWN (mm, res, len + 1);
for (i = 0; i < len; i++)
res[i] = '0';
res[i] = '\0';
return res;
}
char *
btor_x_const_3vl (BtorMemMgr * mm, int len)
{
char *res;
int i;
assert (mm != NULL);
assert (len > 0);
BTOR_NEWN (mm, res, len + 1);
for (i = 0; i < len; i++)
res[i] = 'x';
res[i] = '\0';
return res;
}
char *
btor_one_const (BtorMemMgr * mm, int len)
{
char *res;
int i;
assert (mm != NULL);
assert (len > 0);
BTOR_NEWN (mm, res, len + 1);
for (i = 0; i < len - 1; i++)
res[i] = '0';
res[i++] = '1';
res[i] = '\0';
return res;
}
static char *
concat_const (BtorMemMgr * mm, const char *a, const char *b)
{
char *result;
assert (mm != NULL);
assert (a != NULL);
assert (b != NULL);
assert ((int) strlen (a) > 0);
assert ((int) strlen (b) > 0);
assert (is_valid_const_3vl (a));
assert (is_valid_const_3vl (b));
BTOR_NEWN (mm, result, (int) strlen (a) + (int) strlen (b) + 1);
strcpy (result, a);
strcat (result, b);
return result;
}
static char *
not_const (BtorMemMgr * mm, const char *a)
{
char *result;
int len, i;
assert (mm != NULL);
assert (a != NULL);
assert ((int) strlen (a) > 0);
assert (is_valid_const_3vl (a));
len = (int) strlen (a);
BTOR_NEWN (mm, result, len + 1);
for (i = 0; i < len; i++)
result[i] = BTOR_NOT_CONST_3VL (a[i]);
result[len] = '\0';
return result;
}
BtorParamCacheTuple *
btor_copy_param_cache_tuple (Btor * btor, BtorParamCacheTuple * t)
{
assert (btor);
assert (t);
BtorParamCacheTuple *result;
BTOR_NEW (btor->mm, result);
BTOR_CLR (result);
result->exp = btor_copy_exp (btor, t->exp);
result->hash = t->hash;
result->num_args = t->num_args;
BTOR_NEWN (btor->mm, result->args, result->num_args);
memcpy (result->args, t->args, t->num_args * sizeof (*result->args));
return result;
}
char *
btor_ult_const (BtorMemMgr * mm, const char *a, const char *b)
{
char *result;
assert (mm != NULL);
assert (a != NULL);
assert (b != NULL);
assert (strlen (a) == strlen (b));
assert ((int) strlen (a) > 0);
assert (is_valid_const (a));
assert (is_valid_const (b));
BTOR_NEWN (mm, result, 2);
if (strcmp (a, b) == -1)
result[0] = '1';
else
result[0] = '0';
result[1] = '\0';
return result;
}
static char *
and_const (BtorMemMgr * mm, const char *a, const char *b)
{
char *result;
int len, i;
assert (mm != NULL);
assert (a != NULL);
assert (b != NULL);
assert (strlen (a) == strlen (b));
assert ((int) strlen (a) > 0);
assert (is_valid_const_3vl (a));
assert (is_valid_const_3vl (b));
len = (int) strlen (a);
BTOR_NEWN (mm, result, len + 1);
for (i = len - 1; i >= 0; i--)
result[i] = BTOR_AND_CONST_3VL (a[i], b[i]);
result[len] = '\0';
return result;
}
char *
btor_ground_const_3vl (BtorMemMgr * mm, const char *c)
{
char *res, *q;
const char *p;
char ch;
assert (mm != NULL);
assert (c != NULL);
assert ((int) strlen (c) > 0);
assert (is_valid_const_3vl (c));
BTOR_NEWN (mm, res, (int) strlen (c) + 1);
q = res;
for (p = c; (ch = *p); p++)
*q++ = (ch == '1') ? '1' : '0'; /* 'x' -> '0' */
*q = 0;
return res;
}
static char *
btor_srl_n_bits_const (BtorMemMgr * mm, const char *a, int n)
{
char *result;
int len, i;
assert (mm != NULL);
assert (a != NULL);
assert (is_valid_const_3vl (a));
assert (n >= 0);
assert (n < (int) strlen (a));
len = (int) strlen (a);
if (len == 0)
return btor_strdup (mm, a);
BTOR_NEWN (mm, result, len + 1);
for (i = 0; i < n; i++)
result[i] = '0';
for (i = n; i < len; i++)
result[i] = a[i - n];
result[len] = '\0';
return result;
}
static char *
eq_const (BtorMemMgr * mm, const char *a, const char *b)
{
char *result;
int len, i, has_x;
assert (mm != NULL);
assert (a != NULL);
assert (b != NULL);
assert (strlen (a) == strlen (b));
assert ((int) strlen (a) > 0);
assert (is_valid_const_3vl (a));
assert (is_valid_const_3vl (b));
len = (int) strlen (a);
BTOR_NEWN (mm, result, 2);
result[0] = '1';
has_x = 0;
for (i = len - 1; i >= 0; i--)
{
if (a[i] == 'x' || b[i] == 'x')
has_x = 1;
else if (a[i] != b[i])
{
result[0] = '0';
break;
}
}
result[1] = '\0';
if (result[0] == '1' && has_x)
result[0] = 'x';
return result;
}
char *
btor_unsigned_to_const (BtorMemMgr * mm, unsigned x, int len)
{
char *result;
int i;
assert (mm != NULL);
assert (len > 0);
BTOR_NEWN (mm, result, len + 1);
for (i = len - 1; i > MSB_UNSIGNED; i--)
result[len - 1 - i] = '0';
while (i >= 0)
{
result[len - 1 - i] = (x & (1u << i)) ? '1' : '0';
i--;
}
result[len] = '\0';
return result;
}
char *
btor_mult_unbounded_const (BtorMemMgr * mm, const char *a, const char *b)
{
char *res, *r, c, x, y, s, m;
int alen, blen, rlen, i;
const char *p;
assert (mm != NULL);
assert (a != NULL);
assert (b != NULL);
assert (is_valid_const (a));
assert (is_valid_const (b));
a = strip_zeroes (a);
if (!*a)
return btor_strdup (mm, "");
if (a[0] == '1' && !a[1])
return btor_strdup (mm, b);
b = strip_zeroes (b);
if (!*b)
return btor_strdup (mm, "");
if (b[0] == '1' && !b[1])
return btor_strdup (mm, a);
alen = (int) strlen (a);
blen = (int) strlen (b);
rlen = alen + blen;
BTOR_NEWN (mm, res, rlen + 1);
res[rlen] = 0;
for (r = res; r < res + blen; r++)
*r = '0';
for (p = a; p < a + alen; p++)
*r++ = *p;
assert (r == res + rlen);
for (i = 0; i < alen; i++)
{
m = res[rlen - 1];
c = '0';
if (m == '1')
{
p = b + blen;
r = res + blen;
while (res < r)
{
x = *--p;
y = *--r;
s = x ^ y ^ c;
c = (x & y) | (x & c) | (y & c);
*r = s;
}
}
memmove (res + 1, res, rlen - 1);
res[0] = c;
}
return res;
}
BtorParamCacheTuple *
btor_new_param_cache_tuple (Btor * btor, BtorNode * exp)
{
assert (btor);
assert (exp);
assert (BTOR_IS_REGULAR_NODE (exp));
int i;
unsigned int hash;
BtorNode *param, *arg, *cur;
BtorParamCacheTuple *t;
BtorParameterizedIterator it;
BtorNodeIterator pit;
BTOR_NEW (btor->mm, t);
BTOR_CLR (t);
t->exp = btor_copy_exp (btor, exp);
btor_init_parameterized_iterator (&it, btor, exp);
hash = BTOR_REAL_ADDR_NODE (exp)->id;
if (btor_has_next_parameterized_iterator (&it))
{
t->num_args = it.num_params;
if (BTOR_IS_LAMBDA_NODE (exp))
t->num_args += btor_get_fun_arity (btor, exp);
BTOR_NEWN (btor->mm, t->args, t->num_args);
i = 0;
if (BTOR_IS_LAMBDA_NODE (exp))
{
btor_init_lambda_iterator (&pit, exp);
while (btor_has_next_lambda_iterator (&pit))
{
cur = btor_next_lambda_iterator (&pit);
arg = btor_param_cur_assignment (cur->e[0]);
if (!arg)
arg = cur->e[0];
assert (arg);
t->args[i++] = btor_copy_exp (btor, arg);
hash += (unsigned int) BTOR_GET_ID_NODE (arg);
}
}
do
{
param = btor_next_parameterized_iterator (&it);
assert (BTOR_IS_REGULAR_NODE (param));
assert (BTOR_IS_PARAM_NODE (param));
arg = btor_param_cur_assignment (param);
if (!arg)
arg = param;
assert (arg);
t->args[i++] = btor_copy_exp (btor, arg);
hash += (unsigned int) BTOR_GET_ID_NODE (arg);
}
while (btor_has_next_parameterized_iterator (&it));
}
else if (BTOR_IS_LAMBDA_NODE (exp))
{
btor_init_lambda_iterator (&pit, exp);
t->num_args = btor_get_fun_arity (btor, exp);
BTOR_NEWN (btor->mm, t->args, t->num_args);
i = 0;
while (btor_has_next_lambda_iterator (&pit))
{
cur = btor_next_lambda_iterator (&pit);
arg = btor_param_cur_assignment (cur->e[0]);
if (!arg)
arg = cur->e[0];
assert (arg);
t->args[i++] = btor_copy_exp (btor, arg);
hash += (unsigned int) BTOR_GET_ID_NODE (arg);
}
}
hash *= 7334147u;
t->hash = hash;
return t;
}
char *
btor_sub_unbounded_const (BtorMemMgr * mem, const char *a, const char *b)
{
char *res, *tmp, *r, c, x, y, s;
int alen, blen, rlen;
const char *p, *q;
assert (mem != NULL);
assert (a != NULL);
assert (b != NULL);
assert (is_valid_const (a));
assert (is_valid_const (b));
assert (btor_cmp_const (b, a) <= 0);
a = strip_zeroes (a);
b = strip_zeroes (b);
if (!*b)
return btor_strdup (mem, a);
alen = (int) strlen (a);
blen = (int) strlen (b);
assert (alen >= blen);
rlen = alen;
BTOR_NEWN (mem, res, rlen + 1);
p = a + alen;
q = b + blen;
c = '0';
r = res + rlen;
*r = 0;
while (res < r)
{
assert (a < p);
x = *--p;
y = (b < q) ? *--q : '0';
s = x ^ y ^ c;
c = ((1 ^ x) & c) | ((1 ^ x) & y) | (y & c);
*--r = s;
}
assert (c == '0');
#ifndef NDEBUG
{
tmp = btor_add_unbounded_const (mem, res, b);
assert (!btor_cmp_const (tmp, a));
btor_freestr (mem, tmp);
}
#endif
tmp = btor_strdup (mem, strip_zeroes (res));
btor_freestr (mem, res);
res = tmp;
return res;
}
char *
btor_udiv_unbounded_const (BtorMemMgr * mem,
const char *dividend, const char *divisor,
char **rem_ptr)
{
char *quotient, *rest, *extended_divisor, *tmp;
int delta, plen, qlen;
const char *p, *q;
assert (mem != NULL);
assert (dividend != NULL);
assert (divisor != NULL);
assert (is_valid_const (dividend));
assert (is_valid_const (divisor));
dividend = strip_zeroes (dividend);
divisor = strip_zeroes (divisor);
for (p = dividend; *p && *p == '0'; p++)
;
for (q = divisor; *q && *q == '0'; q++)
;
assert (*q); /* in any case even if 'dividend == 0' */
if (!*p || btor_cmp_const (p, q) < 0)
{
if (rem_ptr)
*rem_ptr = btor_strdup (mem, p); /* copy divident */
return btor_strdup (mem, "");
}
plen = (int) strlen (p);
qlen = (int) strlen (q);
delta = plen - qlen;
assert (delta >= 0);
BTOR_NEWN (mem, extended_divisor, plen + 1);
memset (extended_divisor, '0', delta);
strcpy (extended_divisor + delta, divisor);
udiv_urem_const (mem, dividend, extended_divisor, "ient, &rest);
btor_delete_const (mem, extended_divisor);
tmp = btor_strdup (mem, strip_zeroes (quotient));
btor_delete_const (mem, quotient);
quotient = tmp;
tmp = btor_strdup (mem, strip_zeroes (rest));
btor_delete_const (mem, rest);
rest = tmp;
assert (btor_cmp_const (rest, divisor) < 0);
#ifndef NDEBUG
{
char *tmp1 = btor_mult_unbounded_const (mem, quotient, divisor);
char *tmp2 = btor_add_unbounded_const (mem, tmp1, rest);
assert (!btor_cmp_const (dividend, tmp2));
btor_freestr (mem, tmp1);
btor_freestr (mem, tmp2);
}
#endif
if (rem_ptr)
*rem_ptr = rest;
else
btor_delete_const (mem, rest);
return quotient;
}
static int
btor_passdown_lingeling_options (BtorSATMgr * smgr,
const char * optstr,
LGL * external_lgl)
{
char * str, * p, * next, * eq, * opt, * val;
LGL * lgl = external_lgl ? external_lgl : 0;
int len, valid, res = 1;
assert (optstr);
len = strlen (optstr);
BTOR_NEWN (smgr->mm, str, len + 1);
strcpy (str, optstr);
res = 1;
for (p = str; *p; p = next)
{
if (*p == ',')
next = p + 1;
else
{
opt = p;
while (*p != ',' && *p)
p++;
if (*p)
{
assert (*p == ',');
*p = 0;
next = p + 1;
}
else next = p;
val = eq = 0;
if (!isalpha (*opt))
valid = 0;
else
{
for (p = opt + 1; isalnum (*p); p++)
;
if (*p == '=')
{
*(eq = p++) = 0;
val = p;
if (*p == '-') p++;
if (isdigit (*p))
{
while (isdigit (*p))
p++;
valid = !*p;
}
else
valid = 0;
}
else
valid = 0;
}
if (valid)
{
if (!lgl)
{
assert (!external_lgl);
lgl = lglinit ();
}
if (lglhasopt (lgl, opt))
{
if (external_lgl && val)
{
assert (lgl == external_lgl);
btor_msg_sat (smgr, 2,
"setting Lingeling option --%s=%s", opt, val);
lglsetopt (lgl, opt, atoi (val));
}
}
else
valid = 0;
}
if (!valid) res = 0;
if (valid || external_lgl) continue;
if (eq) *eq = '=';
btor_msg_sat (smgr, 0,
"*** can not pass down to Lingeling invalid option '%s'", optstr);
}
}
BTOR_DELETEN (smgr->mm, str, len + 1);
if (lgl && !external_lgl) lglrelease (lgl);
return res;
}
char *
btor_hex_to_const_n (BtorMemMgr * mem, const char *str, int hlen)
{
const char *p, *end;
char *tmp, *res, *q;
int len;
assert (mem != NULL);
assert (str != NULL);
assert (hlen >= 0);
len = 4 * hlen;
BTOR_NEWN (mem, tmp, len + 1);
q = tmp;
end = str + hlen;
for (p = str; p < end; p++)
switch (*p)
{
case '0':
*q++ = '0';
*q++ = '0';
*q++ = '0';
*q++ = '0';
break;
case '1':
*q++ = '0';
*q++ = '0';
*q++ = '0';
*q++ = '1';
break;
case '2':
*q++ = '0';
*q++ = '0';
*q++ = '1';
*q++ = '0';
break;
case '3':
*q++ = '0';
*q++ = '0';
*q++ = '1';
*q++ = '1';
break;
case '4':
*q++ = '0';
*q++ = '1';
*q++ = '0';
*q++ = '0';
break;
case '5':
*q++ = '0';
*q++ = '1';
*q++ = '0';
*q++ = '1';
break;
case '6':
*q++ = '0';
*q++ = '1';
*q++ = '1';
*q++ = '0';
break;
case '7':
*q++ = '0';
*q++ = '1';
*q++ = '1';
*q++ = '1';
break;
case '8':
*q++ = '1';
*q++ = '0';
*q++ = '0';
*q++ = '0';
break;
case '9':
*q++ = '1';
*q++ = '0';
*q++ = '0';
*q++ = '1';
break;
case 'A':
case 'a':
*q++ = '1';
*q++ = '0';
*q++ = '1';
*q++ = '0';
break;
case 'B':
case 'b':
*q++ = '1';
*q++ = '0';
*q++ = '1';
*q++ = '1';
break;
case 'C':
case 'c':
*q++ = '1';
*q++ = '1';
*q++ = '0';
*q++ = '0';
break;
case 'D':
case 'd':
*q++ = '1';
*q++ = '1';
*q++ = '0';
*q++ = '1';
break;
case 'E':
case 'e':
*q++ = '1';
*q++ = '1';
*q++ = '1';
*q++ = '0';
break;
case 'F':
case 'f':
default:
assert (*p == 'f' || *p == 'F');
*q++ = '1';
*q++ = '1';
*q++ = '1';
*q++ = '1';
break;
}
assert (tmp + len == q);
*q++ = 0;
res = btor_strdup (mem, strip_zeroes (tmp));
btor_freestr (mem, tmp);
return res;
}
char *
btor_ult_const_3vl (BtorMemMgr * mm, const char *a, const char *b)
{
char *result;
int i, len;
assert (mm != NULL);
assert (a != NULL);
assert (b != NULL);
assert (strlen (a) == strlen (b));
assert ((int) strlen (a) > 0);
assert (is_valid_const_3vl (a));
assert (is_valid_const_3vl (b));
len = (int) strlen (a);
BTOR_NEWN (mm, result, 2);
result[0] = '0';
result[1] = '\0';
for (i = 0; i < len; i++)
{
if (a[i] == '0')
{
if (b[i] == 'x')
{
ult_const_0_x_or_x_1_case (a, b, len, i, result);
break;
}
else if (b[i] == '1')
{
result[0] = '1';
break;
}
else
continue;
}
if (a[i] == '1')
{
if (b[i] == 'x')
{
ult_const_1_x_or_x_0_case (a, b, len, i, result);
break;
}
else if (b[i] == '0')
{
result[0] = '0';
break;
}
else
continue;
}
if (a[i] == 'x')
{
if (b[i] == '1')
{
ult_const_0_x_or_x_1_case (a, b, len, i, result);
break;
}
else if (b[i] == '0')
{
ult_const_1_x_or_x_0_case (a, b, len, i, result);
break;
}
else
{
result[0] = 'x';
break;
}
}
assert (a[i] == b[i] && a[i] != 'x' && b[i] != 'x');
}
return result;
}
static BtorBTORParser *
btor_new_btor_parser (Btor * btor, BtorParseOpt * opts)
{
BtorMemMgr *mem = btor->mm;
BtorBTORParser *res;
(void) opts->incremental; // TODO what about incremental?
(void) opts->need_model; // TODO use at least this
assert (opts->verbosity >= -1);
BTOR_NEW (mem, res);
BTOR_CLR (res);
res->mem = mem;
res->btor = btor;
BTOR_NEWN (mem, res->parsers, SIZE_PARSERS);
BTOR_NEWN (mem, res->ops, SIZE_PARSERS);
BTOR_CLRN (res->ops, SIZE_PARSERS);
new_parser (res, parse_add, "add");
new_parser (res, parse_and, "and");
new_parser (res, parse_array, "array");
new_parser (res, parse_concat, "concat");
new_parser (res, parse_cond, "cond");
new_parser (res, parse_acond, "acond");
new_parser (res, parse_const, "const");
new_parser (res, parse_constd, "constd");
new_parser (res, parse_consth, "consth");
new_parser (res, parse_eq, "eq");
new_parser (res, parse_iff, "iff");
new_parser (res, parse_implies, "implies");
new_parser (res, parse_mul, "mul");
new_parser (res, parse_nand, "nand");
new_parser (res, parse_neg, "neg");
new_parser (res, parse_inc, "inc");
new_parser (res, parse_dec, "dec");
new_parser (res, parse_ne, "ne");
new_parser (res, parse_next, "next"); /* only in parser */
new_parser (res, parse_anext, "anext"); /* only in parser */
new_parser (res, parse_nor, "nor");
new_parser (res, parse_not, "not");
new_parser (res, parse_one, "one");
new_parser (res, parse_ones, "ones");
new_parser (res, parse_or, "or");
new_parser (res, parse_proxy, "proxy");
new_parser (res, parse_read, "read");
new_parser (res, parse_redand, "redand");
new_parser (res, parse_redor, "redor");
new_parser (res, parse_redxor, "redxor");
new_parser (res, parse_rol, "rol");
new_parser (res, parse_root, "root"); /* only in parser */
new_parser (res, parse_ror, "ror");
new_parser (res, parse_saddo, "saddo");
new_parser (res, parse_sdivo, "sdivo");
new_parser (res, parse_sdiv, "sdiv");
new_parser (res, parse_sext, "sext");
new_parser (res, parse_sgte, "sgte");
new_parser (res, parse_sgt, "sgt");
new_parser (res, parse_slice, "slice");
new_parser (res, parse_sll, "sll");
new_parser (res, parse_slte, "slte");
new_parser (res, parse_slt, "slt");
new_parser (res, parse_smod, "smod");
new_parser (res, parse_smulo, "smulo");
new_parser (res, parse_sra, "sra");
new_parser (res, parse_srem, "srem");
new_parser (res, parse_srl, "srl");
new_parser (res, parse_ssubo, "ssubo");
new_parser (res, parse_sub, "sub");
new_parser (res, parse_uaddo, "uaddo");
new_parser (res, parse_udiv, "udiv");
new_parser (res, parse_uext, "uext");
new_parser (res, parse_ugte, "ugte");
new_parser (res, parse_ugt, "ugt");
new_parser (res, parse_ulte, "ulte");
new_parser (res, parse_ult, "ult");
new_parser (res, parse_umulo, "umulo");
new_parser (res, parse_urem, "urem");
new_parser (res, parse_usubo, "usubo");
new_parser (res, parse_var, "var");
new_parser (res, parse_write, "write");
new_parser (res, parse_xnor, "xnor");
new_parser (res, parse_xor, "xor");
new_parser (res, parse_zero, "zero");
res->verbosity = opts->verbosity;
return res;
}
char *
btor_inverse_const (BtorMemMgr * mm, const char *c)
{
char *a, *b, *y, *ly, *r, *q, *yq, *res, *ty;
int len = strlen (c);
assert (mm != NULL);
assert (c != NULL);
assert (len > 0);
assert (c[len - 1] == '1'); /* odd */
assert (is_valid_const (c));
BTOR_NEWN (mm, a, len + 2);
a[0] = '1';
memset (a + 1, '0', len);
a[len + 1] = 0;
BTOR_NEWN (mm, b, len + 2);
b[0] = '0';
memcpy (b + 1, c, len);
b[len + 1] = 0;
y = btor_unsigned_to_const (mm, 1, len + 1);
ly = btor_unsigned_to_const (mm, 0, len + 1);
while (!btor_is_zero_const (b))
{
udiv_urem_const (mm, a, b, &q, &r);
btor_delete_const (mm, a);
a = b;
b = r;
ty = y;
yq = btor_mul_const (mm, y, q);
btor_delete_const (mm, q);
y = btor_sub_const (mm, ly, yq);
btor_delete_const (mm, yq);
btor_delete_const (mm, ly);
ly = ty;
}
res = btor_slice_const (mm, ly, len - 1, 0);
#ifndef NDEBUG
assert (strlen (res) == strlen (c));
ty = btor_mul_const (mm, c, res);
assert (btor_is_one_const (ty));
btor_delete_const (mm, ty);
#endif
btor_delete_const (mm, ly);
btor_delete_const (mm, y);
btor_delete_const (mm, b);
btor_delete_const (mm, a);
return res;
}
