{
assert((sizeof binoperstr / sizeof binoperstr[0]) ==
(sizeof op1 / sizeof op1[0]));
- for (i = 0; i < sizeof op1 / sizeof op1[0]; i++)
+ for (i = 0; i < (int)(sizeof op1 / sizeof op1[0]); i++)
{
if (oper == op1[i])
{
- strcpy(opername, binoperstr[i]);
+ strncpy(opername, binoperstr[i], sizeof(opername) - 1);
+ opername[sizeof(opername) - 1] = 0;
savepri = binoper_savepri[i];
break;
} /* if */
}
else
{
- assert(!!oper);
+ assert(oper != NULL);
assert(numparam == 1);
/* try a select group of unary operators */
assert((sizeof unoperstr / sizeof unoperstr[0]) ==
(sizeof unopers / sizeof unopers[0]));
if (opername[0] == '\0')
{
- for (i = 0; i < sizeof unopers / sizeof unopers[0]; i++)
+ for (i = 0; i < (int)(sizeof unopers / sizeof unopers[0]); i++)
{
if (oper == unopers[i])
{
- strcpy(opername, unoperstr[i]);
+ strncpy(opername, unoperstr[i], sizeof(opername) - 1);
+ opername[sizeof(opername) - 1] = 0;
break;
} /* if */
} /* for */
return FALSE;
} /* if */
- /* check existance and the proper declaration of this function */
+ /* check existence and the proper declaration of this function */
if ((sym->usage & uMISSING) != 0 || (sym->usage & uPROTOTYPED) == 0)
{
char symname[2 * sNAMEMAX + 16]; /* allow space for user defined operators */
if (oper == user_inc || oper == user_dec)
{
assert(!savepri);
- assert(!!lval);
+ assert(lval != NULL);
if (lval->ident == iARRAYCELL || lval->ident == iARRAYCHAR)
push1(); /* save current address in PRI */
rvalue(lval); /* get the symbol's value in PRI */
else if (savealt)
{
/* for the assignment operator, ALT may contain an address at which the
- * result must be stored; this address must be preserved accross the
+ * result must be stored; this address must be preserved across the
* call
*/
- assert(!!lval); /* this was checked earlier */
+ assert(lval != NULL); /* this was checked earlier */
assert(lval->ident == iARRAYCELL || lval->ident == iARRAYCHAR); /* checked earlier */
push2();
} /* if */
if (sym->x.lib)
sym->x.lib->value += 1; /* increment "usage count" of the library */
sideeffect = TRUE; /* assume functions carry out a side-effect */
- assert(!!resulttag);
+ assert(resulttag != NULL);
*resulttag = sym->tag; /* save tag of the called function */
if (savepri || savealt)
pop2(); /* restore the saved PRI/ALT that into ALT */
if (oper == user_inc || oper == user_dec)
{
- assert(!!lval);
+ assert(lval != NULL);
if (lval->ident == iARRAYCELL || lval->ident == iARRAYCHAR)
pop2(); /* restore address (in ALT) */
store(lval); /* store PRI in the symbol */
{
cell length;
- assert(!!sym);
+ assert(sym != NULL);
assert(sym->ident == iARRAY || sym->ident == iREFARRAY);
length = sym->dim.array.length;
if (sym->dim.array.level > 0)
static cell
array_levelsize(symbol * sym, int level)
{
- assert(!!sym);
+ assert(sym != NULL);
assert(sym->ident == iARRAY || sym->ident == iREFARRAY);
assert(level <= sym->dim.array.level);
while (level-- > 0)
{
sym = finddepend(sym);
- assert(!!sym);
+ assert(sym != NULL);
} /* if */
return sym->dim.array.length;
}
*
* Lowest hierarchy level (except for the , operator).
*
- * Global references: intest (reffered to only)
+ * Global references: intest (referred to only)
*/
int
hier14(value * lval1)
/* array assignment is permitted too (with restrictions) */
if (oper)
return error(23); /* array assignment must be simple assigment */
- assert(!!lval1->sym);
+ assert(lval1->sym != NULL);
if (array_totalsize(lval1->sym) == 0)
return error(46, lval1->sym->name); /* unknown array size */
lvalue = TRUE;
if (!lvalue)
return error(22); /* must be lvalue */
/* may not change "constant" parameters */
- assert(!!lval1->sym);
+ assert(lval1->sym != NULL);
if ((lval1->sym->usage & uCONST) != 0)
return error(22); /* assignment to const argument */
lval3 = *lval1; /* save symbol to enable storage of expresion result */
if (lval2.ident == iVARIABLE && lval3.ident == lval2.ident
&& lval3.sym == lval2.sym)
{
- assert(!!lval3.sym);
+ assert(lval3.sym != NULL);
error(226, lval3.sym->name); /* self-assignment */
} /* if */
} /* if */
symbol *sym2 = lval2.sym;
int i;
- assert(!!sym1 && !!sym2);
+ assert(sym1 != NULL && sym2 != NULL);
/* ^^^ sym2 must be valid, because only variables can be
* multi-dimensional (there are no multi-dimensional arrays),
* sym1 must be valid because it must be an lvalue
{
sym1 = finddepend(sym1);
sym2 = finddepend(sym2);
- assert(!!sym1 && !!sym2);
+ assert(sym1 != NULL && sym2 != NULL);
/* ^^^ both arrays have the same dimensions (this was checked
* earlier) so the dependend should always be found
*/
case tINC: /* ++lval */
if (!hier2(lval))
return error(22); /* must be lvalue */
- assert(!!lval->sym);
+ assert(lval->sym != NULL);
if ((lval->sym->usage & uCONST) != 0)
return error(22); /* assignment to const argument */
if (!check_userop(user_inc, lval->tag, 0, 1, lval, &lval->tag))
case tDEC: /* --lval */
if (!hier2(lval))
return error(22); /* must be lvalue */
- assert(!!lval->sym);
+ assert(lval->sym != NULL);
if ((lval->sym->usage & uCONST) != 0)
return error(22); /* assignment to const argument */
if (!check_userop(user_dec, lval->tag, 0, 1, lval, &lval->tag))
if (sym && sym->ident != iFUNCTN && sym->ident != iREFFUNC
&& (sym->usage & uDEFINE) == 0)
sym = NULL; /* symbol is not a function, it is in the table, but not "defined" */
- val = (sym);
+ val = !!sym;
if (!val && find_subst(st, strlen(st)))
val = 1;
clear_value(lval);
case tINC: /* lval++ */
if (!lvalue)
return error(22); /* must be lvalue */
- assert(!!lval->sym);
+ assert(lval->sym != NULL);
if ((lval->sym->usage & uCONST) != 0)
return error(22); /* assignment to const argument */
/* on incrementing array cells, the address in PRI must be saved for
case tDEC: /* lval-- */
if (!lvalue)
return error(22); /* must be lvalue */
- assert(!!lval->sym);
+ assert(lval->sym != NULL);
if ((lval->sym->usage & uCONST) != 0)
return error(22); /* assignment to const argument */
saveresult = (lval->ident == iARRAYCELL
charalign(); /* align character index into array */
} /* if */
/* the indexed item may be another array (multi-dimensional arrays) */
- assert(lval1->sym == sym && !!sym); /* should still be set */
+ assert(lval1->sym == sym && sym != NULL); /* should still be set */
if (sym->dim.array.level > 0)
{
assert(close == ']'); /* checked earlier */
/* adjust the "value" structure and find the referenced array */
lval1->ident = iREFARRAY;
lval1->sym = finddepend(sym);
- assert(!!lval1->sym);
+ assert(lval1->sym != NULL);
assert(lval1->sym->dim.array.level ==
sym->dim.array.level - 1);
/* try to parse subsequent array indices */
{
return error(17, st); /* undefined symbol */
} /* endif */
- assert(!!sym);
+ assert(sym != NULL);
assert(sym->ident == iFUNCTN || sym->ident != iREFFUNC);
lval->sym = sym;
lval->ident = sym->ident;
* the default array data is "dumped" into the data segment only once (on the
* first use).
*/
- assert(!!string);
+ assert(string != NULL);
assert(size > 0);
/* check whether to dump the default array */
- assert(!!dataaddr);
+ assert(dataaddr != NULL);
if (sc_status == statWRITE && *dataaddr < 0)
{
int i;
cell lexval;
char *lexstr;
- assert(!!sym);
+ assert(sym != NULL);
arg = sym->dim.arglist;
- assert(!!arg);
+ assert(arg != NULL);
stgmark(sSTARTREORDER);
for (argpos = 0; argpos < sMAXARGS; argpos++)
arglist[argpos] = ARG_UNHANDLED;
/* always pass by reference */
if (lval.ident == iVARIABLE || lval.ident == iREFERENCE)
{
- assert(!!lval.sym);
+ assert(lval.sym != NULL);
if ((lval.sym->usage & uCONST) != 0
&& (arg[argidx].usage & uCONST) == 0)
{
{
if (lvalue)
{
- assert(!!lval.sym);
+ assert(lval.sym != NULL);
address(lval.sym);
}
else
symbol *sym = lval.sym;
short level = 0;
- assert(!!sym);
+ assert(sym != NULL);
if (sym->dim.array.level + 1 != arg[argidx].numdim)
error(48); /* array dimensions must match */
/* the lengths for all dimensions must match, unless the dimension
append_constval(&arrayszlst, arg[argidx].name,
sym->dim.array.length, level);
sym = finddepend(sym);
- assert(!!sym);
+ assert(sym != NULL);
level++;
} /* if */
/* the last dimension is checked too, again, unless it is zero */
assert(level < sDIMEN_MAX);
- assert(!!sym);
+ assert(sym != NULL);
if (arg[argidx].dim[level] != 0
&& sym->dim.array.length !=
arg[argidx].dim[level])
projects / framework / uifw / embryo.git / blobdiff