// (print x y z ...)
Cell* op_print(Scheme *sc) {
Cell *x;
for (x = sc->args; x != &g_nil; x = cdr(x)) {
printf("%s", cell2str(sc, car(x)));
}
return s_return_helper(sc, &g_true);
}
static char*
cell2str(lex_ctxt* lexic, tree_cell* c)
{
char * p;
tree_cell *c2;
nasl_array *a;
if (c == NULL || c == FAKE_CELL)
{
#if NASL_DEBUG > 0
nasl_perror(lexic, "Cannot convert NULL or FAKE cell to string\n");
#endif
return NULL;
}
switch(c->type)
{
case CONST_INT:
p = malloc(16);
if (p != NULL)
snprintf(p, 16, "%d", c->x.i_val);
return p;
case CONST_STR:
case CONST_DATA:
if ( c->x.str_val == NULL)
p = estrdup("");
else
p = nasl_strndup(c->x.str_val, c->size);
return p;
case REF_ARRAY:
case DYN_ARRAY:
a = c->x.ref_val;
p = (char*)array2str(a);
return estrdup(p);
default:
c2 = nasl_exec(lexic, c);
p = cell2str(lexic, c2);
deref_cell(c2);
if (p == NULL)
p = estrdup("");
return p;
}
}
// (error x y z ...)
Cell* op_err(Scheme *sc) {
Cell *x;
if (!is_string(car(sc->args))) {
sc->args = cons(sc, make_string(sc, " -- "), sc->args);
set_immutable(sc->args);
}
fprintf(stderr, "Error: ");
fprintf(stderr, car(sc->args)->_string);
sc->args = cdr(sc->args);
for (x = sc->args; x != &g_nil; x = cdr(x)) {
fprintf(stderr, cell2str(sc, car(x)));
}
fprintf(stderr, "\n");
return s_return_helper(sc, &g_true);
}
int main(int argc, char **argv) {
Scheme *sc = alloc_scheme();
Statement *st = NULL;
String scheme = NULL;
if (!scheme_init(sc)) {
fprintf(stderr, "Initialize scheme environment error!\n");
return 1;
}
if (!funny_init()) {
fprintf(stderr, "Initialize funny environment error!\n");
return 1;
}
printf("Welcome to FUNNY programming world. Type {exit} to exit.\n");
while (TRUE) {
printf("> ");
st = read_statement(stdin);
if (empty_statement(st)) {
printf("can't parse the statement.\n");
continue;
}
wait_to_exit(st);
scheme = match(st);
if (equals_string(scheme, ""))
continue;
//#ifdef DEBUG
printf("TARGET: %s\n", scheme);
//#endif
Cell* result = eval(sc, scheme);
printf("%s\n", cell2str(sc, result));
}
return 0;
}
void test_op(Scheme *sc, String input, String output) {
Cell* result = eval(sc, input);
assert(strcmp(cell2str(sc, result), output) == 0);
}
tree_cell*
nasl_exec(lex_ctxt* lexic, tree_cell* st)
{
tree_cell *ret = NULL, *ret2 = NULL, *tc1 = NULL, *tc2 = NULL, *tc3 = NULL, *idx = NULL, *args;
int flag, x, y, z;
char *s1 = NULL, *s2 = NULL, *s3 = NULL, *p = NULL;
char *p1, *p2;
int len1, len2;
nasl_func *pf = NULL;
int i, n;
unsigned long sz;
#if 0
nasl_dump_tree(st); /* See rt.value, rt.type, rt.length */
#endif
/* return */
if (lexic->ret_val != NULL)
{
ref_cell(lexic->ret_val);
return lexic->ret_val;
}
/* break or continue */
if (lexic->break_flag || lexic->cont_flag)
return FAKE_CELL;
if (st == FAKE_CELL)
return FAKE_CELL;
if (st == NULL)
{
#if NASL_DEBUG > 0
nasl_perror(lexic, "nasl_exec: st == NULL\n");
#endif
return NULL;
}
if (nasl_trace_fp != NULL)
nasl_short_dump(nasl_trace_fp, st);
switch(st->type)
{
case NODE_IF_ELSE:
ret = nasl_exec(lexic, st->link[0]);
#ifdef STOP_AT_FIRST_ERROR
if (ret == NULL)
return NULL;
#endif
if (cvt_bool(lexic, ret))
ret2 = nasl_exec(lexic, st->link[1]);
else
if (st->link[2] != NULL) /* else branch */
ret2 = nasl_exec(lexic, st->link[2]);
else /* No else */
ret2 = FAKE_CELL;
deref_cell(ret);
return ret2;
case NODE_INSTR_L: /* Block. [0] = first instr, [1] = tail */
ret = nasl_exec(lexic, st->link[0]);
#if NASL_DEBUG > 1
if (ret == NULL)
nasl_perror(lexic, "Instruction failed. Going on in block\n");
#endif
if (st->link[1] == NULL || lexic->break_flag || lexic->cont_flag)
return ret;
deref_cell(ret);
ret = nasl_exec(lexic, st->link[1]);
return ret;
case NODE_FOR:
/* [0] = start expr, [1] = cond, [2] = end_expr, [3] = block */
ret2 = nasl_exec(lexic, st->link[0]);
#ifdef STOP_AT_FIRST_ERROR
if (ret2 == NULL)
return NULL;
#endif
deref_cell(ret2);
for (;;)
{
/* Break the loop if 'return' */
if (lexic->ret_val != NULL)
{
ref_cell(lexic->ret_val);
return lexic->ret_val;
}
/* condition */
if ((ret = nasl_exec(lexic, st->link[1])) == NULL)
return NULL; /* We can return here, as NULL is false */
flag = cvt_bool(lexic, ret);
deref_cell(ret);
if (! flag)
break;
/* block */
ret = nasl_exec(lexic, st->link[3]);
#ifdef STOP_AT_FIRST_ERROR
if (ret == NULL)
return NULL;
#endif
deref_cell(ret);
/* break */
if (lexic->break_flag)
{
lexic->break_flag = 0;
return FAKE_CELL;
}
lexic->cont_flag = 0; /* No need to test if set */
/* end expression */
ret = nasl_exec(lexic, st->link[2]);
#ifdef STOP_AT_FIRST_ERROR
if (ret == NULL)
return NULL;
#endif
deref_cell(ret);
}
return FAKE_CELL;
case NODE_WHILE:
/* [0] = cond, [1] = block */
for (;;)
{
/* return? */
if (lexic->ret_val != NULL)
{
ref_cell(lexic->ret_val);
return lexic->ret_val;
}
/* Condition */
if ((ret = nasl_exec(lexic, st->link[0])) == NULL)
return NULL; /* NULL is false */
flag = cvt_bool(lexic, ret);
deref_cell(ret);
if (! flag)
break;
/* Block */
ret = nasl_exec(lexic, st->link[1]);
#ifdef STOP_AT_FIRST_ERROR
if (ret == NULL)
return NULL;
#endif
deref_cell(ret);
/* break */
if (lexic->break_flag)
{
lexic->break_flag = 0;
return FAKE_CELL;
}
lexic->cont_flag = 0;
}
return FAKE_CELL;
case NODE_REPEAT_UNTIL:
/* [0] = block, [1] = cond */
for (;;)
{
/* return? */
if (lexic->ret_val != NULL)
{
ref_cell(lexic->ret_val);
return lexic->ret_val;
}
/* Block */
ret = nasl_exec(lexic, st->link[0]);
#ifdef STOP_AT_FIRST_ERROR
if (ret == NULL)
return NULL;
#endif
deref_cell(ret);
/* break */
if (lexic->break_flag)
{
lexic->break_flag = 0;
return FAKE_CELL;
}
lexic->cont_flag = 0;
/* Condition */
ret = nasl_exec(lexic, st->link[1]);
#ifdef STOP_AT_FIRST_ERROR
if (ret == NULL)
return NULL;
#endif
flag = cvt_bool(lexic, ret);
deref_cell(ret);
if (flag)
break;
}
return FAKE_CELL;
case NODE_FOREACH:
/* str_val = index name, [0] = array, [1] = block */
{
nasl_iterator ai;
tree_cell *v, *a, *val;
v = get_variable_by_name(lexic, st->x.str_val);
if (v == NULL)
return NULL; /* We cannot go on if we have no variable to iterate */
a = nasl_exec(lexic, st->link[0]);
ai = nasl_array_iterator(a);
while ((val = nasl_iterate_array(&ai)) != NULL)
{
tc1 = nasl_affect(v, val);
ret = nasl_exec(lexic, st->link[1]);
deref_cell(val);
deref_cell(tc1);
#ifdef STOP_AT_FIRST_ERROR
if (ret == NULL)
break;
#endif
deref_cell(ret);
/* return */
if (lexic->ret_val != NULL)
break;
/* break */
if (lexic->break_flag)
{
lexic->break_flag = 0;
break;
}
lexic->cont_flag = 0;
}
deref_cell(a);
deref_cell(v);
}
return FAKE_CELL;
case NODE_FUN_DEF:
/* x.str_val = function name, [0] = argdecl, [1] = block */
ret = decl_nasl_func(lexic, st);
return ret;
case NODE_FUN_CALL:
pf = get_func_ref_by_name(lexic, st->x.str_val);
if (pf == NULL)
{
nasl_perror(lexic, "Undefined function '%s'\n", st->x.str_val);
return NULL;
}
args = st->link[0];
#if 0
printf("****************\n");
nasl_dump_tree(args);
printf("****************\n");
#endif
ret = nasl_func_call(lexic, pf, args);
return ret;
case NODE_REPEATED:
n = cell2intW(lexic, st->link[1]);
if (n <= 0)
return NULL;
#ifdef STOP_AT_FIRST_ERROR
for (tc1 = NULL, i = 1; i <= n; i ++)
{
deref_cell(tc1);
if ((tc1 = nasl_exec(lexic, st->link[0])) == NULL)
return NULL;
}
return tc1;
#else
for (i = 1; i <= n; i ++)
{
tc1 = nasl_exec(lexic, st->link[0]);
deref_cell(tc1);
}
return FAKE_CELL;
#endif
/*
* I wonder...
* Will nasl_exec be really called with NODE_EXEC or NODE_ARG?
*/
case NODE_DECL: /* Used in function declarations */
/* [0] = next arg in list */
/* TBD? */
return st; /* ? */
case NODE_ARG: /* Used function calls */
/* val = name can be NULL, [0] = val, [1] = next arg */
ret = nasl_exec(lexic, st->link[0]); /* Is this wise? */
return ret;
case NODE_RETURN:
/* [0] = ret val */
ret = nasl_return(lexic, st->link[0]);
return ret;
case NODE_BREAK:
lexic->break_flag = 1;
return FAKE_CELL;
case NODE_CONTINUE:
lexic->cont_flag = 1;
return FAKE_CELL;
case NODE_ARRAY_EL: /* val = array name, [0] = index */
idx = cell2atom(lexic, st->link[0]);
ret = get_array_elem(lexic, st->x.str_val, idx);
deref_cell(idx);
return ret;
case NODE_AFF:
/* [0] = lvalue, [1] = rvalue */
tc1 = nasl_exec(lexic, st->link[0]);
tc2 = nasl_exec(lexic, st->link[1]);
ret = nasl_affect(tc1, tc2);
deref_cell(tc1); /* Must free VAR_REF */
deref_cell(ret);
return tc2; /* So that "a = b = e;" works */
case NODE_PLUS_EQ:
tc1 = nasl_exec(lexic, st->link[0]);
tc2 = nasl_exec(lexic, st->link[1]);
tc3 = alloc_expr_cell(0, EXPR_PLUS, tc1, tc2);
ret2 = nasl_exec(lexic, tc3);
ret = nasl_affect(tc1, ret2);
deref_cell(tc3); /* Frees tc1 and tc2 */
deref_cell(ret);
return ret2; /* So that "a = b += e;" works */
case NODE_MINUS_EQ:
tc1 = nasl_exec(lexic, st->link[0]);
tc2 = nasl_exec(lexic, st->link[1]);
tc3 = alloc_expr_cell(0, EXPR_MINUS, tc1, tc2);
ret2 = nasl_exec(lexic, tc3);
ret = nasl_affect(tc1, ret2);
deref_cell(tc3); /* Frees tc1 and tc2 */
deref_cell(ret);
return ret2; /* So that "a = b -= e;" works */
case NODE_MULT_EQ:
tc1 = nasl_exec(lexic, st->link[0]);
tc2 = nasl_exec(lexic, st->link[1]);
tc3 = alloc_expr_cell(0, EXPR_MULT, tc1, tc2);
ret2 = nasl_exec(lexic, tc3);
ret = nasl_affect(tc1, ret2);
deref_cell(tc3); /* Frees tc1 and tc2 */
deref_cell(ret);
return ret2;
case NODE_DIV_EQ:
tc1 = nasl_exec(lexic, st->link[0]);
tc2 = nasl_exec(lexic, st->link[1]);
tc3 = alloc_expr_cell(0, EXPR_DIV, tc1, tc2);
ret2 = nasl_exec(lexic, tc3);
ret = nasl_affect(tc1, ret2);
deref_cell(tc3); /* Frees tc1 and tc2 */
deref_cell(ret);
return ret2;
case NODE_MODULO_EQ:
tc1 = nasl_exec(lexic, st->link[0]);
tc2 = nasl_exec(lexic, st->link[1]);
tc3 = alloc_expr_cell(0, EXPR_MODULO, tc1, tc2);
ret2 = nasl_exec(lexic, tc3);
ret = nasl_affect(tc1, ret2);
deref_cell(tc3); /* Frees tc1 and tc2 */
deref_cell(ret);
return ret2;
case NODE_L_SHIFT_EQ:
tc1 = nasl_exec(lexic, st->link[0]);
tc2 = nasl_exec(lexic, st->link[1]);
tc3 = alloc_expr_cell(0, EXPR_L_SHIFT, tc1, tc2);
ret2 = nasl_exec(lexic, tc3);
ret = nasl_affect(tc1, ret2);
deref_cell(tc3); /* Frees tc1 and tc2 */
deref_cell(ret);
return ret2;
case NODE_R_SHIFT_EQ:
tc1 = nasl_exec(lexic, st->link[0]);
tc2 = nasl_exec(lexic, st->link[1]);
tc3 = alloc_expr_cell(0, EXPR_R_SHIFT, tc1, tc2);
ret2 = nasl_exec(lexic, tc3);
ret = nasl_affect(tc1, ret2);
deref_cell(tc3); /* Frees tc1 and tc2 */
deref_cell(ret);
return ret2;
case NODE_R_USHIFT_EQ:
tc1 = nasl_exec(lexic, st->link[0]);
tc2 = nasl_exec(lexic, st->link[1]);
tc3 = alloc_expr_cell(0, EXPR_R_USHIFT, tc1, tc2);
ret2 = nasl_exec(lexic, tc3);
ret = nasl_affect(tc1, ret2);
deref_cell(tc3); /* Frees tc1 and tc2 */
deref_cell(ret);
return ret2;
case NODE_VAR:
/* val = variable name */
ret = get_variable_by_name(lexic, st->x.str_val);
return ret;
case NODE_LOCAL: /* [0] = argdecl */
ret = decl_local_variables(lexic, st->link[0]);
return ret;
case NODE_GLOBAL: /* [0] = argdecl */
ret = decl_global_variables(lexic, st->link[0]);
return ret;
case EXPR_AND:
x = cell2bool(lexic, st->link[0]);
if(! x)
return bool2cell(0);
y = cell2bool(lexic, st->link[1]);
return bool2cell(y);
case EXPR_OR:
x = cell2bool(lexic, st->link[0]);
if(x)
return bool2cell(x);
y = cell2bool(lexic, st->link[1]);
return bool2cell(y);
case EXPR_NOT:
x = cell2bool(lexic, st->link[0]);
return bool2cell(! x);
case EXPR_INCR:
case EXPR_DECR:
x = (st->type == EXPR_INCR) ? 1 : -1;
if (st->link[0] == NULL)
{
y = 1; /* pre */
tc1 = st->link[1];
}
else
{
y = 0; /* post */
tc1 = st->link[0];
}
tc2 = nasl_exec(lexic, tc1);
if (tc2 == NULL)
return NULL;
ret = nasl_incr_variable(lexic, tc2, y, x);
deref_cell(tc2);
return ret;
if (st->link[0] == NULL)
ret = nasl_incr_variable(lexic, st->link[1], 1, 1);
else
ret = nasl_incr_variable(lexic, st->link[1], 0, 1);
break;
case EXPR_PLUS:
s1 = s2 = NULL;
tc1 = cell2atom(lexic, st->link[0]);
#ifdef STOP_AT_FIRST_ERROR
if (tc1 == NULL || tc1 == FAKE_CELL)
return NULL;
#endif
tc2 = cell2atom(lexic, st->link[1]);
if (tc2 == NULL || tc2 == FAKE_CELL)
{
#ifdef STOP_AT_FIRST_ERROR
deref_cell(tc1);
return NULL;
#else
return tc1;
#endif
}
if (tc1 == NULL || tc1 == FAKE_CELL)
return tc2;
/*
* Anything added to a string is converted to a string
* Otherwise anything added to an intger is converted into an integer
*/
if (tc1->type == CONST_DATA || tc2->type == CONST_DATA)
flag = CONST_DATA;
else if (tc1->type == CONST_STR || tc2->type == CONST_STR)
flag = CONST_STR;
else if (tc1->type == CONST_INT || tc2->type == CONST_INT)
flag = CONST_INT;
else
flag = NODE_EMPTY;
#if NASL_DEBUG > 0
if ((flag == CONST_DATA || flag == CONST_STR) &&
(tc1->type == CONST_INT || tc2->type == CONST_INT))
nasl_perror(lexic, "Horrible type conversion (int -> str) for operator + %s\n", get_line_nb(st));
#endif
switch (flag)
{
case CONST_INT:
x = tc1->x.i_val;
y = cell2int(lexic, tc2);
ret = int2cell(x + y);
break;
case CONST_STR:
case CONST_DATA:
s1 = s2 = NULL;
if (tc1->type == CONST_STR || tc1->type == CONST_DATA)
len1 = tc1->size;
else
{
s1 = cell2str(lexic, tc1);
len1 = (s1 == NULL ? 0 : strlen(s1));
}
if (tc2->type == CONST_STR || tc2->type == CONST_DATA)
len2 = tc2->size;
else
{
s2 = cell2str(lexic, tc2);
len2 = (s2 == NULL ? 0 : strlen(s2));
}
sz = len1 + len2;
s3 = emalloc(sz);
if (len1 > 0)
memcpy(s3, s1 != NULL ? s1 : tc1->x.str_val, len1);
if (len2 > 0)
memcpy(s3 + len1, s2 != NULL ? s2 : tc2->x.str_val, len2);
efree(&s1); efree(&s2);
ret = alloc_tree_cell(0, s3);
ret->type = flag;
ret->size = sz;
break;
default:
ret = NULL;
break;
}
deref_cell(tc1);
deref_cell(tc2);
return ret;
case EXPR_MINUS: /* Infamous duplicated code */
s1 = s2 = NULL;
tc1 = cell2atom(lexic, st->link[0]);
#ifdef STOP_AT_FIRST_ERROR
if (tc1 == NULL || tc1 == FAKE_CELL)
return NULL;
#endif
tc2 = cell2atom(lexic, st->link[1]);
if (tc2 == NULL || tc2 == FAKE_CELL)
{
#ifdef STOP_AT_FIRST_ERROR
deref_cell(tc1);
return NULL;
#else
return tc1;
#endif
}
if (tc1 == NULL || tc1 == FAKE_CELL)
{
if (tc2->type == CONST_INT)
{
y = cell2int(lexic, tc2);
ret = int2cell(- y);
}
else
ret = NULL;
deref_cell(tc2);
return ret;
}
/*
* Anything substracted from a string is converted to a string
* Otherwise anything substracted from integer is converted into an
* integer
*/
if (tc1->type == CONST_DATA || tc2->type == CONST_DATA)
flag = CONST_DATA;
else if (tc1->type == CONST_STR || tc2->type == CONST_STR)
flag = CONST_STR;
else if (tc1->type == CONST_INT || tc2->type == CONST_INT)
flag = CONST_INT;
else
flag = NODE_EMPTY;
#if NASL_DEBUG > 0
if ((flag == CONST_DATA || flag == CONST_STR) &&
(tc1->type == CONST_INT || tc2->type == CONST_INT))
nasl_perror(lexic, "Horrible type conversion (int -> str) for operator - %s\n", get_line_nb(st));
#endif
switch (flag)
{
case CONST_INT:
x = cell2int(lexic, tc1);
y = cell2int(lexic, tc2);
ret = int2cell(x - y);
break;
case CONST_STR:
case CONST_DATA:
if (tc1->type == CONST_STR || tc1->type == CONST_DATA)
{
p1 = tc1->x.str_val;
len1 = tc1->size;
}
else
{
p1 = s1 = cell2str(lexic, tc1);
len1 = (s1 == NULL ? 0 : strlen(s1));
}
if (tc2->type == CONST_STR || tc2->type == CONST_DATA)
{
p2 = tc2->x.str_val;
len2 = tc2->size;
}
else
{
p2 = s2 = cell2str(lexic, tc2);
len2 = (s2 == NULL ? 0 : strlen(s2));
}
if (len2 == 0 || len1 < len2 ||
(p = (char*)nasl_memmem(p1, len1, p2, len2)) == NULL)
{
s3 = emalloc(len1);
memcpy(s3, p1, len1);
ret = alloc_tree_cell(0, s3);
ret->type = flag;
ret->size = len1;
}
else
{
sz = len1 - len2;
if (sz <= 0)
{
sz = 0;
s3 = estrdup("");
}
else
{
s3 = emalloc(sz);
if (p - p1 > 0)
memcpy(s3, p1, p - p1);
if (sz > p - p1)
memcpy(s3 + (p - p1), p + len2, sz - (p - p1));
}
ret = alloc_tree_cell(0, s3);
ret->size = sz;
ret->type = flag;
}
efree(&s1); efree(&s2);
break;
default:
ret = NULL;
break;
}
deref_cell(tc1);
deref_cell(tc2);
return ret;
case EXPR_MULT:
x = cell2intW(lexic, st->link[0]);
y = cell2intW(lexic, st->link[1]);
return int2cell(x * y);
case EXPR_DIV:
x = cell2intW(lexic, st->link[0]);
y = cell2intW(lexic, st->link[1]);
if( y != 0 )
return int2cell(x / y);
else
return int2cell(0);
case EXPR_EXPO:
x = cell2intW(lexic, st->link[0]);
y = cell2intW(lexic, st->link[1]);
return int2cell(expo(x, y));
case EXPR_MODULO:
x = cell2intW(lexic, st->link[0]);
y = cell2intW(lexic, st->link[1]);
if( y != 0)
return int2cell(x % y);
else
return int2cell(0);
case EXPR_BIT_AND:
x = cell2intW(lexic, st->link[0]);
y = cell2intW(lexic, st->link[1]);
return int2cell(x & y);
case EXPR_BIT_OR:
x = cell2intW(lexic, st->link[0]);
y = cell2intW(lexic, st->link[1]);
return int2cell(x | y);
case EXPR_BIT_XOR:
x = cell2intW(lexic, st->link[0]);
y = cell2intW(lexic, st->link[1]);
return int2cell(x ^ y);
case EXPR_BIT_NOT:
x = cell2intW(lexic, st->link[0]);
return int2cell(~ x);
case EXPR_U_MINUS:
x = cell2intW(lexic, st->link[0]);
return int2cell(- x);
/* TBD: Handle shift for strings and arrays */
case EXPR_L_SHIFT:
x = cell2intW(lexic, st->link[0]);
y = cell2intW(lexic, st->link[1]);
return int2cell(x << y);
case EXPR_R_SHIFT: /* arithmetic right shift */
x = cell2intW(lexic, st->link[0]);
y = cell2intW(lexic, st->link[1]);
#if NASL_DEBUG > 0
if (y < 0)
nasl_perror(lexic, "Warning: Negative count in right shift!\n");
#endif
z = x >> y;
#ifndef __GNUC__
if (x < 0 && z >= 0) /* Fix it */
{
#if NASL_DEBUG > 1
nasl_perror(lexic, "Warning: arithmetic right shift is buggy! Fixing...\n");
#endif
z |= (~0) << (sizeof(x) * 8 - y);
}
#endif
return int2cell(z);
case EXPR_R_USHIFT:
x = cell2intW(lexic, st->link[0]);
y = cell2intW(lexic, st->link[1]);
#if NASL_DEBUG > 0
if (y < 0)
nasl_perror(lexic, "Warning: Negative count in right shift!\n");
#endif
z = (unsigned)x >> (unsigned)y;
#ifndef __GNUC__
if (x < 0 && z <= 0) /* Fix it! */
{
#if NASL_DEBUG > 1
nasl_perror(lexic, "Warning: Logical right shift is buggy! Fixing...\n");
#endif
z &= ~((~0) << (sizeof(x) * 8 - y));
}
#endif
return int2cell(z);
case COMP_MATCH:
case COMP_NOMATCH:
tc1 = cell2atom(lexic, st->link[0]);
tc2 = cell2atom(lexic, st->link[1]);
s1 = s2 = NULL;
if (tc1 == NULL || tc1 == FAKE_CELL)
{
p1 = "";
len1 = 0;
}
else if (tc1->type == CONST_STR || tc1->type == CONST_DATA)
{
p1 = tc1->x.str_val;
len1 = tc1->size;
}
else
{
#if NASL_DEBUG > 0
nasl_perror(lexic, "Horrible type conversion (%s -> str) for operator >< or >!< %s\n", nasl_type_name(tc1->type), get_line_nb(st));
#endif
p1 = s1 = cell2str(lexic, tc1);
len1 = strlen(s1);
}
if (tc2 == NULL || tc2 == FAKE_CELL)
{
p2 = "";
len2 = 0;
}
else if (tc2->type == CONST_STR || tc2->type == CONST_DATA)
{
p2 = tc2->x.str_val;
len2 = tc2->size;
}
else
{
#if NASL_DEBUG > 0
nasl_perror(lexic, "Horrible type conversion (%s -> str) for operator >< or >!< %s\n", nasl_type_name(tc2->type), get_line_nb(st));
#endif
p2 = s2 = cell2str(lexic, tc2);
len2 = strlen(s2);
}
if(len1 <= len2)
flag = ((void*)nasl_memmem(p2, len2, p1, len1) != NULL);
else
flag = 0;
efree(&s1); efree(&s2);
deref_cell(tc1);
deref_cell(tc2);
if (st->type == COMP_MATCH)
return bool2cell(flag);
else
return bool2cell(! flag);
case COMP_RE_MATCH:
case COMP_RE_NOMATCH:
if (st->x.ref_val == NULL)
{
nasl_perror(lexic, "nasl_exec: bad regex at or near line %d\n",
st->line_nb);
return NULL;
}
s1 = cell2str(lexic, st->link[0]);
if (s1 == NULL)
return 0;
flag = nasl_regexec(st->x.ref_val, s1, 0, NULL, 0);
free(s1);
if (st->type == COMP_RE_MATCH)
return bool2cell(flag != REG_NOMATCH);
else
return bool2cell(flag == REG_NOMATCH);
case COMP_LT:
return bool2cell(cell_cmp(lexic, st->link[0], st->link[1]) < 0);
case COMP_LE:
return bool2cell(cell_cmp(lexic, st->link[0], st->link[1]) <= 0);
case COMP_EQ:
return bool2cell(cell_cmp(lexic, st->link[0], st->link[1]) == 0);
case COMP_NE:
return bool2cell(cell_cmp(lexic, st->link[0], st->link[1]) != 0);
case COMP_GT:
return bool2cell(cell_cmp(lexic, st->link[0], st->link[1]) > 0);
case COMP_GE:
return bool2cell(cell_cmp(lexic, st->link[0], st->link[1]) >= 0);
case REF_ARRAY:
case DYN_ARRAY:
case CONST_INT:
case CONST_STR:
case CONST_DATA:
ref_cell(st); /* nasl_exec returns a cell that should be deref-ed */
return st;
case REF_VAR:
ret = nasl_read_var_ref(lexic, st);
return ret;
default:
nasl_perror(lexic, "nasl_exec: unhandled node type %d\n", st->type);
abort();
return NULL;
}
deref_cell(ret);
deref_cell(ret2);
return NULL;
}
int
cell_cmp(lex_ctxt* lexic, tree_cell* c1, tree_cell* c2)
{
int flag, x1, x2, typ, typ1, typ2;
char *s1, *s2;
int len_s1, len_s2, len_min;
#if NASL_DEBUG >= 0
if (c1 == NULL || c1 == FAKE_CELL)
nasl_perror(lexic, "cell_cmp: c1 == NULL !\n");
if (c2 == NULL || c2 == FAKE_CELL)
nasl_perror(lexic, "cell_cmp: c2 == NULL !\n");
#endif
/* We first convert the cell to atomic types */
c1 = cell2atom(lexic, c1);
c2 = cell2atom(lexic, c2);
/*
* Comparing anything to something else which is entirely different
* may lead to unpredictable results.
* Here are the rules:
* 1. No problem with same types, although we do not compare arrays yet
* 2. No problem with CONST_DATA / CONST_STR
* 3. When an integer is compared to a string, the integer is converted
* 4. When NULL is compared to an integer, it is converted to 0
* 5. When NULL is compared to a string, it is converted to ""
* 6. NULL is "smaller" than anything else (i.e. an array)
* Anything else is an error
*/
typ1 = cell_type(c1);
typ2 = cell_type(c2);
if (typ1 == 0 && typ2 == 0) /* Two NULL */
{
deref_cell(c1); deref_cell(c2);
return 0;
}
if (typ1 == typ2) /* Same type, no problem */
typ = typ1;
else if ((typ1 == CONST_DATA || typ1 == CONST_STR) &&
(typ2 == CONST_DATA || typ2 == CONST_STR))
typ = CONST_DATA; /* Same type in fact (string) */
/* We convert an integer into a string before compare */
else if ((typ1 == CONST_INT && (typ2 == CONST_DATA || typ2 == CONST_STR)) ||
(typ2 == CONST_INT && (typ1 == CONST_DATA || typ1 == CONST_STR)) )
{
#if NASL_DEBUG > 0
nasl_perror(lexic, "cell_cmp: converting integer to string\n");
#endif
typ = CONST_DATA;
}
else if (typ1 == 0) /* 1st argument is null */
if (typ2 == CONST_INT || typ2 == CONST_DATA || typ2 == CONST_STR)
typ = typ2; /* We convert it to 0 or "" */
else
{
deref_cell(c1); deref_cell(c2);
return -1; /* NULL is smaller than anything else */
}
else if (typ2 == 0) /* 2nd argument is null */
if (typ1 == CONST_INT || typ1 == CONST_DATA || typ1 == CONST_STR)
typ = typ1; /* We convert it to 0 or "" */
else
{
deref_cell(c1); deref_cell(c2);
return 1; /* Anything else is greater than NULL */
}
else
{
nasl_perror(lexic, "cell_cmp: comparing %s and %s does not make sense\n", nasl_type_name(typ1), nasl_type_name(typ2));
deref_cell(c1); deref_cell(c2);
return 0;
}
switch (typ)
{
case CONST_INT:
x1 = cell2int(lexic, c1);
x2 = cell2int(lexic, c2);
deref_cell(c1); deref_cell(c2);
return x1 - x2;
case CONST_STR:
case CONST_DATA:
s1 = cell2str(lexic, c1);
if (typ1 == CONST_STR || typ1 == CONST_DATA)
len_s1 = c1->size;
else if (s1 == NULL)
len_s1 = 0;
else
len_s1 = strlen(s1);
s2 = cell2str(lexic, c2);
if (typ2 == CONST_STR || typ2 == CONST_DATA)
len_s2 = c2->size;
else if (s2 == NULL)
len_s2 = 0;
else
len_s2 = strlen(s2);
len_min = len_s1 < len_s2 ? len_s1 : len_s2;
flag = 0;
if (len_min > 0)
flag = memcmp(s1, s2, len_min);
if (flag == 0)
flag = len_s1 - len_s2;
efree(&s1); efree(&s2);
deref_cell(c1); deref_cell(c2);
return flag;
case REF_ARRAY:
case DYN_ARRAY:
fprintf(stderr, "cell_cmp: cannot compare arrays yet\n");
deref_cell(c1); deref_cell(c2);
return 0;
default:
fprintf(stderr, "cell_cmp: don't known how to compare %s and %s\n",
nasl_type_name(typ1), nasl_type_name(typ2));
deref_cell(c1); deref_cell(c2);
return 0;
}
}
