* must not be misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source
* distribution.
- * Version: $Id: embryo_cc_sc1.c 51023 2010-08-11 20:35:26Z lucas $
+ * Version: $Id$
*/
void
sc_closesrc(void *handle)
{
- assert(handle != NULL);
+ assert(!!handle);
fclose((FILE *) handle);
}
void
sc_resetsrc(void *handle, void *position)
{
- assert(handle != NULL);
+ assert(!!handle);
fsetpos((FILE *) handle, (fpos_t *) position);
}
/* write the binary file (the file is already open) */
if (errnum == 0 && jmpcode == 0)
{
- assert(binf != NULL);
+ assert(!!binf);
sc_resetasm(outf); /* flush and loop back, for reading */
assemble(binf, outf); /* assembler file is now input */
} /* if */
free(litq);
phopt_cleanup();
stgbuffer_cleanup();
- assert(jmpcode != 0 || loctab.next == NULL); /* on normal flow,
+ assert(jmpcode != 0 || !loctab.next); /* on normal flow,
* local symbols
* should already have been deleted */
delete_symbols(&loctab, 0, TRUE, TRUE); /* delete local variables
char *str;
cell val;
- assert(name != NULL);
+ assert(!!name);
/* check the operator */
opertok = lex(&val, &str);
static int
check_operatortag(int opertok, int resulttag, char *opername)
{
- assert(opername != NULL && opername[0] != '\0');
+ assert(!!opername && opername[0] != '\0');
switch (opertok)
{
case '!':
unary = parse_funcname(funcname, &tags[0], &tags[1], opname);
tagsym[1] = find_constval_byval(&tagname_tab, tags[1]);
- assert(tagsym[1] != NULL);
+ assert(!!tagsym[1]);
if (unary)
{
sprintf(dest, "operator%s(%s:)", opname, tagsym[1]->name);
* and labels */
delete_symbols(&loctab, 0, TRUE, TRUE); /* clear local variables
* queue */
- assert(loctab.next == NULL);
+ assert(!loctab.next);
curfunc = NULL;
if (sc_status == statSKIP)
{
needtoken(')');
} /* if */
/* resolve any "sizeof" arguments (now that all arguments are known) */
- assert(sym->dim.arglist != NULL);
+ assert(!!sym->dim.arglist);
arglist = sym->dim.arglist;
for (idx = 0; idx < argcnt && arglist[idx].ident != 0; idx++)
{
{
if (ref->parent)
continue; /* hierarchical data type */
- assert(ref->refer != NULL);
+ assert(!!ref->refer);
for (i = 0; i < ref->numrefers && ref->refer[i] != sym;
i++)
/* nothing */ ;
{
cell length;
- assert(sym != NULL);
+ assert(!!sym);
assert(sym->ident == iARRAY || sym->ident == iREFARRAY);
length = sym->dim.array.length;
if (sym->dim.array.level > 0)
* "continue" must ignore these fields.
*/
ptr = readwhile();
- assert(ptr != NULL);
+ assert(!!ptr);
ptr[wqBRK] = (int)declared;
ptr[wqCONT] = (int)declared;
jumplabel(skiplab); /* skip expression 3 1st time */
needtoken(tTERM);
rettype |= uRETVALUE; /* function returns a value */
/* check tagname with function tagname */
- assert(curfunc != NULL);
+ assert(!!curfunc);
if (!matchtag(curfunc->tag, tag, TRUE))
error(213); /* tagname mismatch */
}
{
char symname[2 * sNAMEMAX + 16]; /* allow space for user
* defined operators */
- assert(curfunc != NULL);
+ assert(!!curfunc);
funcdisplayname(symname, curfunc->name);
error(209, symname); /* function should return a value */
} /* if */
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*
- * Version: $Id: embryo_cc_sc2.c 51023 2010-08-11 20:35:26Z lucas $
+ * Version: $Id$
*/
*/
assert(strlen(pline) < sLINEMAX);
term = strchr(pline, '\0');
- assert(term != NULL);
+ assert(!!term);
chrcat(pline, PREPROC_TERM); /* the "DEL" code (see SC.H) */
result = constexpr(val, tag); /* get value (or 0 on error) */
*term = '\0'; /* erase the token (if still present) */
static char *
getstring(char *dest, int max, char *line)
{
- assert(dest != NULL && line != NULL);
+ assert(!!dest && !!line);
*dest = '\0';
while (*line <= ' ' && *line != '\0')
line++; /* skip whitespace */
if (skiplevel == 0)
{
check_empty(lptr);
- assert(inpf != NULL);
+ assert(!!inpf);
if (inpf != inpf_org)
sc_closesrc(inpf);
inpf = NULL;
if (clreol)
{
lptr = strchr(pline, '\0');
- assert(lptr != NULL);
+ assert(!!lptr);
} /* if */
}
/* free all sub-symbol allocated memory blocks, depending on the
* kind of the symbol
*/
- assert(sym != NULL);
+ assert(!!sym);
if (sym->ident == iFUNCTN)
{
/* run through the argument list; "default array" arguments
* must be freed explicitly; the tag list must also be freed */
- assert(sym->dim.arglist != NULL);
+ assert(!!sym->dim.arglist);
for (arg = sym->dim.arglist; arg->ident != 0; arg++)
{
if (arg->ident == iREFARRAY && arg->hasdefault)
&& ((arg->hasdefault & uSIZEOF) != 0
|| (arg->hasdefault & uTAGOF) != 0))
free(arg->defvalue.size.symname);
- assert(arg->tags != NULL);
+ assert(!!arg->tags);
free(arg->tags);
} /* for */
free(sym->dim.arglist);
} /* if */
- assert(sym->refer != NULL);
+ assert(!!sym->refer);
free(sym->refer);
free(sym);
}
while (root->next != sym)
{
root = root->next;
- assert(root != NULL);
+ assert(!!root);
} /* while */
/* unlink it, then free it */
{
int count;
- assert(bywhom != NULL); /* it makes no sense to add a "void" referrer */
- assert(entry != NULL);
- assert(entry->refer != NULL);
+ assert(!!bywhom); /* it makes no sense to add a "void" referrer */
+ assert(!!entry);
+ assert(!!entry->refer);
/* see if it is already there */
for (count = 0; count < entry->numrefers && entry->refer[count] != bywhom;
} /* if */
/* add the referrer */
- assert(entry->refer[count] == NULL);
+ assert(!entry->refer[count]);
entry->refer[count] = bywhom;
return TRUE;
}
sym = find_symbol(&glbtab, name, fcurrent);
if (!sym || sym->ident != iCONSTEXPR)
return NULL;
- assert(sym->parent == NULL); /* constants have no hierarchy */
+ assert(!sym->parent); /* constants have no hierarchy */
return sym;
}
/* global variables/constants/functions may only be defined once */
assert(!(ident == iFUNCTN || ident == iCONSTEXPR) || vclass != sGLOBAL
- || findglb(name) == NULL);
+ || !findglb(name));
/* labels may only be defined once */
- assert(ident != iLABEL || findloc(name) == NULL);
+ assert(ident != iLABEL || !findloc(name));
/* create an empty referrer list */
if (!(refer = (symbol **)malloc(sizeof(symbol *))))
int level;
/* global variables may only be defined once */
- assert(vclass != sGLOBAL || (sym = findglb(name)) == NULL
+ assert(vclass != sGLOBAL || !(sym = findglb(name))
|| (sym->usage & uDEFINE) == 0);
if (ident == iARRAY || ident == iREFARRAY)
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*
- * Version: $Id: embryo_cc_sc3.c 51023 2010-08-11 20:35:26Z lucas $
+ * Version: $Id$
*/
}
else
{
- assert(oper != NULL);
+ assert(!!oper);
assert(numparam == 1);
/* try a select group of unary operators */
assert((sizeof unoperstr / sizeof unoperstr[0]) ==
if (oper == user_inc || oper == user_dec)
{
assert(!savepri);
- assert(lval != NULL);
+ assert(!!lval);
if (lval->ident == iARRAYCELL || lval->ident == iARRAYCHAR)
push1(); /* save current address in PRI */
rvalue(lval); /* get the symbol's value in PRI */
* result must be stored; this address must be preserved accross the
* call
*/
- assert(lval != NULL); /* this was checked earlier */
+ assert(!!lval); /* 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 != NULL);
+ assert(!!resulttag);
*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 != NULL);
+ assert(!!lval);
if (lval->ident == iARRAYCELL || lval->ident == iARRAYCHAR)
pop2(); /* restore address (in ALT) */
store(lval); /* store PRI in the symbol */
{
cell length;
- assert(sym != NULL);
+ assert(!!sym);
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 != NULL);
+ assert(!!sym);
assert(sym->ident == iARRAY || sym->ident == iREFARRAY);
assert(level <= sym->dim.array.level);
while (level-- > 0)
{
sym = finddepend(sym);
- assert(sym != NULL);
+ assert(!!sym);
} /* if */
return sym->dim.array.length;
}
/* array assignment is permitted too (with restrictions) */
if (oper)
return error(23); /* array assignment must be simple assigment */
- assert(lval1->sym != NULL);
+ assert(!!lval1->sym);
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 != NULL);
+ assert(!!lval1->sym);
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 != NULL);
+ assert(!!lval3.sym);
error(226, lval3.sym->name); /* self-assignment */
} /* if */
} /* if */
symbol *sym2 = lval2.sym;
int i;
- assert(sym1 != NULL && sym2 != NULL);
+ assert(!!sym1 && !!sym2);
/* ^^^ 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 != NULL && sym2 != NULL);
+ assert(!!sym1 && !!sym2);
/* ^^^ 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 != NULL);
+ assert(!!lval->sym);
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 != NULL);
+ assert(!!lval->sym);
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 != NULL);
+ 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 != NULL);
+ assert(!!lval->sym);
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 != NULL);
+ assert(!!lval->sym);
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 != NULL); /* should still be set */
+ assert(lval1->sym == sym && !!sym); /* 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 != NULL);
+ assert(!!lval1->sym);
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 != NULL);
+ assert(!!sym);
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 != NULL);
+ assert(!!string);
assert(size > 0);
/* check whether to dump the default array */
- assert(dataaddr != NULL);
+ assert(!!dataaddr);
if (sc_status == statWRITE && *dataaddr < 0)
{
int i;
cell lexval;
char *lexstr;
- assert(sym != NULL);
+ assert(!!sym);
arg = sym->dim.arglist;
- assert(arg != NULL);
+ assert(!!arg);
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 != NULL);
+ assert(!!lval.sym);
if ((lval.sym->usage & uCONST) != 0
&& (arg[argidx].usage & uCONST) == 0)
{
{
if (lvalue)
{
- assert(lval.sym != NULL);
+ assert(!!lval.sym);
address(lval.sym);
}
else
symbol *sym = lval.sym;
short level = 0;
- assert(sym != NULL);
+ assert(!!sym);
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 != NULL);
+ assert(!!sym);
level++;
} /* if */
/* the last dimension is checked too, again, unless it is zero */
assert(level < sDIMEN_MAX);
- assert(sym != NULL);
+ assert(!!sym);
if (arg[argidx].dim[level] != 0
&& sym->dim.array.length !=
arg[argidx].dim[level])
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*
- * Version: $Id: embryo_cc_sc4.c 50816 2010-08-04 16:57:32Z lucas $
+ * Version: $Id$
*/
else if (lval->ident == iREFERENCE)
{
/* indirect fetch, but address not yet in PRI */
- assert(sym != NULL);
+ assert(!!sym);
assert(sym->vclass == sLOCAL); /* global references don't exist in Small */
if (sym->vclass == sLOCAL)
stgwrite("\tlref.s.pri ");
else
{
/* direct or stack relative fetch */
- assert(sym != NULL);
+ assert(!!sym);
if (sym->vclass == sLOCAL)
stgwrite("\tload.s.pri ");
else
void
address(symbol * sym)
{
- assert(sym != NULL);
+ assert(!!sym);
/* the symbol can be a local array, a global array, or an array
* that is passed by reference.
*/
}
else if (lval->ident == iREFERENCE)
{
- assert(sym != NULL);
+ assert(!!sym);
if (sym->vclass == sLOCAL)
stgwrite("\tsref.s.pri ");
else
}
else
{
- assert(sym != NULL);
+ assert(!!sym);
markusage(sym, uWRITTEN);
if (sym->vclass == sLOCAL)
stgwrite("\tstor.s.pri ");
void
copyarray(symbol * sym, cell size)
{
- assert(sym != NULL);
+ assert(!!sym);
/* the symbol can be a local array, a global array, or an array
* that is passed by reference.
*/
{
const1(val); /* load val in PRI */
- assert(sym != NULL);
+ assert(!!sym);
/* the symbol can be a local array, a global array, or an array
* that is passed by reference.
*/
void
ffcall(symbol * sym, int numargs)
{
- assert(sym != NULL);
+ assert(!!sym);
assert(sym->ident == iFUNCTN);
if ((sym->usage & uNATIVE) != 0)
{
}
else if (lval->ident == iREFERENCE)
{
- assert(sym != NULL);
+ assert(!!sym);
stgwrite("\tpush.pri\n");
/* load dereferenced value */
assert(sym->vclass == sLOCAL); /* global references don't exist in Small */
else
{
/* local or global variable */
- assert(sym != NULL);
+ assert(!!sym);
if (sym->vclass == sLOCAL)
stgwrite("\tinc.s ");
else
}
else if (lval->ident == iREFERENCE)
{
- assert(sym != NULL);
+ assert(!!sym);
stgwrite("\tpush.pri\n");
/* load dereferenced value */
assert(sym->vclass == sLOCAL); /* global references don't exist in Small */
else
{
/* local or global variable */
- assert(sym != NULL);
+ assert(!!sym);
if (sym->vclass == sLOCAL)
stgwrite("\tdec.s ");
else
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*
- * Version: $Id: embryo_cc_sc6.c 51023 2010-08-11 20:35:26Z lucas $
+ * Version: $Id$
*/
write_encoded(FILE * fbin, ucell * c, int num)
{
assert(sizeof(cell) <= 4); /* code must be adjusted for larger cells */
- assert(fbin != NULL);
+ assert(!!fbin);
while (num-- > 0)
{
if (sc_compress)
* already have been set (in order for static globals to be found).
*/
sym = findglb(name);
- assert(sym != NULL);
+ assert(!!sym);
assert(sym->ident == iFUNCTN || sym->ident == iREFFUNC);
assert(sym->vclass == sGLOBAL);
if (fbin)
{
- assert(lbltab != NULL);
+ assert(!!lbltab);
p = lbltab[i];
write_encoded(fbin, (ucell *) & opcode, 1);
write_encoded(fbin, &p, 1);
if (fbin)
{
- assert(lbltab != NULL);
+ assert(!!lbltab);
p = lbltab[i];
write_encoded(fbin, (ucell *) & opcode, 1);
write_encoded(fbin, &p, 1);
if (fbin)
{
- assert(lbltab != NULL);
+ assert(!!lbltab);
p = lbltab[i];
write_encoded(fbin, &v, 1);
write_encoded(fbin, &p, 1);
while (low < high)
{
mid = (low + high) / 2;
- assert(opcodelist[mid].name != NULL);
+ assert(!!opcodelist[mid].name);
cmp = strcasecmp(str, opcodelist[mid].name);
if (cmp > 0)
low = mid + 1;
/* verify that the opcode list is sorted (skip entry 1; it is reserved
* for a non-existant opcode)
*/
- assert(opcodelist[1].name != NULL);
+ assert(!!opcodelist[1].name);
for (i = 2; i < (sizeof opcodelist / sizeof opcodelist[0]); i++)
{
- assert(opcodelist[i].name != NULL);
+ assert(!!opcodelist[i].name);
assert(strcasecmp(opcodelist[i].name, opcodelist[i - 1].name) > 0);
} /* for */
#endif
char alias[sNAMEMAX + 1];
sym = nativelist[i];
- assert(sym != NULL);
+ assert(!!sym);
if (!lookup_alias(alias, sym->name))
{
assert(strlen(sym->name) <= sNAMEMAX);
/* nothing */ ;
assert(params > instr);
i = findopcode(instr, (int)(params - instr));
- assert(opcodelist[i].name != NULL);
+ assert(!!opcodelist[i].name);
if (opcodelist[i].segment == pass)
opcodelist[i].func(fout, skipwhitespace(params),
opcodelist[i].opcode);
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*
- * Version: $Id: embryo_cc_sc7.c 51023 2010-08-11 20:35:26Z lucas $
+ * Version: $Id$
*/
* that the same symbol may occur multiple times in the pattern) plus
* line endings and startings ('\t' to start a line and '\n\0' to end one)
*/
- assert(repl_length != NULL);
+ assert(!!repl_length);
*repl_length = 0;
lptr = pattern;
while (*lptr)
char symbols[_maxoptvars][_aliasmax + 1];
int seq, match_length, repl_length;
- assert(sequences != NULL);
+ assert(!!sequences);
while (start < end)
{
if ((sc_debug & sNOOPTIMIZE) != 0 || sc_status != statWRITE)
seq++;
} /* if */
} /* while */
- assert(sequences[seq].find == NULL);
+ assert(!sequences[seq].find);
filewrite(start);
} /* if */
assert(start < end);
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*
- * Version: $Id: embryo_cc_sclist.c 51023 2010-08-11 20:35:26Z lucas $
+ * Version: $Id$
*/
{
stringpair *cur, *pred;
- assert(root != NULL);
- assert(first != NULL);
- assert(second != NULL);
+ assert(!!root);
+ assert(!!first);
+ assert(!!second);
/* create a new node, and check whether all is okay */
if (!(cur = (stringpair *)malloc(sizeof(stringpair))))
return NULL;
{
stringpair *cur, *next;
- assert(root != NULL);
+ assert(!!root);
cur = root->next;
while (cur)
{
next = cur->next;
- assert(cur->first != NULL);
- assert(cur->second != NULL);
+ assert(!!cur->first);
+ assert(!!cur->second);
free(cur->first);
free(cur->second);
free(cur);
int result = 0;
assert(matchlength > 0); /* the function cannot handle zero-length comparison */
- assert(first != NULL);
+ assert(!!first);
while (cur && result <= 0)
{
result = (int)*cur->first - (int)*first;
{
stringpair *cur;
- assert(root != NULL);
+ assert(!!root);
cur = root;
while (cur->next)
{
if (cur->next == item)
{
cur->next = item->next; /* unlink from list */
- assert(item->first != NULL);
- assert(item->second != NULL);
+ assert(!!item->first);
+ assert(!!item->second);
free(item->first);
free(item->second);
free(item);
{
stringpair *cur;
- assert(name != NULL);
+ assert(!!name);
assert(strlen(name) <= sNAMEMAX);
- assert(alias != NULL);
+ assert(!!alias);
assert(strlen(alias) <= sEXPMAX);
if (!(cur = insert_stringpair(&alias_tab, name, alias, strlen(name))))
error(103); /* insufficient memory (fatal error) */
assert(strlen(cur->second) <= sEXPMAX);
strcpy(target, cur->second);
} /* if */
- return cur != NULL;
+ return !!cur;
}
void
{
stringlist *cur;
- assert(path != NULL);
+ assert(!!path);
if (!(cur = (stringlist *)malloc(sizeof(stringlist))))
error(103); /* insufficient memory (fatal error) */
if (!(cur->line = strdup(path)))
cur = cur->next;
if (cur)
{
- assert(cur->line != NULL);
+ assert(!!cur->line);
return cur->line;
} /* if */
return NULL;
while (cur)
{
next = cur->next;
- assert(cur->line != NULL);
+ assert(!!cur->line);
free(cur->line);
free(cur);
cur = next;
{
stringpair *cur;
- assert(pattern != NULL);
- assert(substitution != NULL);
+ assert(!!pattern);
+ assert(!!substitution);
if (!(cur = insert_stringpair(&substpair, pattern, substitution, prefixlen)))
error(103); /* insufficient memory (fatal error) */
adjustindex(*pattern);
{
stringpair *item;
- assert(name != NULL);
+ assert(!!name);
assert(length > 0);
assert((*name >= 'A' && *name <= 'Z') || (*name >= 'a' && *name <= 'z')
|| *name == '_');
{
stringpair *item;
- assert(name != NULL);
+ assert(!!name);
assert(length > 0);
assert((*name >= 'A' && *name <= 'Z') || (*name >= 'a' && *name <= 'z')
|| *name == '_');