if (tok == tNATIVE || tok == tPUBLIC && stock)
if (tok == tNATIVE || (tok == tPUBLIC && stock))
newfunc(char *firstname, int firsttag, int fpublic, int fstatic, int stock){   symbol             *sym;   int                 argcnt, tok, tag, funcline;   int                 opertok, opererror;   char                symbolname[sNAMEMAX + 1];   char               *str;   cell                val, cidx, glbdecl;   int                 filenum;   litidx = 0;			/* clear the literal pool ??? */   opertok = 0;   lastst = 0;			/* no statement yet */   cidx = 0;			/* just to avoid compiler warnings */   glbdecl = 0;   filenum = fcurrent;		/* save file number at start of declaration */   if (firstname != NULL)     {	assert(strlen(firstname) <= sNAMEMAX);	strcpy(symbolname, firstname);	/* save symbol name */	tag = firsttag;     }   else     {	tag = (firsttag >= 0) ? firsttag : sc_addtag(NULL);	tok = lex(&val, &str);	assert(!fpublic);	if (tok == tNATIVE || tok == tPUBLIC && stock)	   error(42);		/* invalid combination of class specifiers */	if (tok == tOPERATOR)	  {	     opertok = operatorname(symbolname);	     if (opertok == 0)		return TRUE;	/* error message already given */	     check_operatortag(opertok, tag, symbolname);	  }	else	  {	     if (tok != tSYMBOL && freading)	       {		  error(20, str);	/* invalid symbol name */		  return FALSE;	       }		/* if */	     assert(strlen(str) <= sNAMEMAX);	     strcpy(symbolname, str);	  }			/* if */     }				/* if */   /* check whether this is a function or a variable declaration */   if (!matchtoken('('))      return FALSE;   /* so it is a function, proceed */   funcline = fline;		/* save line at which the function is defined */   if (symbolname[0] == PUBLIC_CHAR)     {	fpublic = TRUE;		/* implicitly public function */	if (stock)	   error(42);		/* invalid combination of class specifiers */     }				/* if */   sym = fetchfunc(symbolname, tag);	/* get a pointer to the					 * function entry */   if (sym == NULL)      return TRUE;   if (fpublic)      sym->usage |= uPUBLIC;   if (fstatic)      sym->fnumber = filenum;   /* declare all arguments */   argcnt = declargs(sym);   opererror = !operatoradjust(opertok, sym, symbolname, tag);   if (strcmp(symbolname, uMAINFUNC) == 0)     {	if (argcnt > 0)	   error(5);		/* "main()" function may not have any arguments */	sym->usage |= uREAD;	/* "main()" is the program's entry point:				 * always used */     }				/* if */   /* "declargs()" found the ")"; if a ";" appears after this, it was a    * prototype */   if (matchtoken(';'))     {	if (!sc_needsemicolon)	   error(218);		/* old style prototypes used with optional				 * semicolumns */	delete_symbols(&loctab, 0, TRUE, TRUE);	/* prototype is done;						 * forget everything */	return TRUE;     }				/* if */   /* so it is not a prototype, proceed */   /* if this is a function that is not referred to (this can only be    * detected in the second stage), shut code generation off */   if (sc_status == statWRITE && (sym->usage & uREAD) == 0)     {	sc_status = statSKIP;	cidx = code_idx;	glbdecl = glb_declared;     }				/* if */   begcseg();   sym->usage |= uDEFINE;	/* set the definition flag */   if (fpublic)      sym->usage |= uREAD;	/* public functions are always "used" */   if (stock)      sym->usage |= uSTOCK;   if (opertok != 0 && opererror)      sym->usage &= ~uDEFINE;   defsymbol(sym->name, iFUNCTN, sGLOBAL,	     code_idx + opcodes(1) + opargs(3) + nameincells(sym->name), tag);   /* ^^^ The address for the symbol is the code address. But the    * "symbol" instruction itself generates code. Therefore the    * offset is pre-adjusted to the value it will have after the    * symbol instruction.    */   startfunc(sym->name);	/* creates stack frame */   if ((sc_debug & sSYMBOLIC) != 0)      setline(funcline, fcurrent);   if (sc_alignnext)     {	alignframe(sc_dataalign);	sc_alignnext = FALSE;     }				/* if */   declared = 0;		/* number of local cells */   rettype = (sym->usage & uRETVALUE);	/* set "return type" variable */   curfunc = sym;   define_args();		/* add the symbolic info for the function arguments */   statement(NULL, FALSE);   if ((rettype & uRETVALUE) != 0)      sym->usage |= uRETVALUE;   if (declared != 0)     {	/* This happens only in a very special (and useless) case, where a	 * function has only a single statement in its body (no compound	 * block) and that statement declares a new variable	 */	modstk((int)declared * sizeof(cell));	/* remove all local						 * variables */	declared = 0;     }				/* if */   if ((lastst != tRETURN) && (lastst != tGOTO))     {	const1(0);	ffret();	if ((sym->usage & uRETVALUE) != 0)	  {	     char                symname[2 * sNAMEMAX + 16];	/* allow space for user								 * defined operators */	     funcdisplayname(symname, sym->name);	     error(209, symname);	/* function should return a value */	  }			/* if */     }				/* if */   endfunc();   if (litidx)     {				/* if there are literals defined */	glb_declared += litidx;	begdseg();		/* flip to DATA segment */	dumplits();		/* dump literal strings */	litidx = 0;     }				/* if */   testsymbols(&loctab, 0, TRUE, TRUE);	/* test for unused arguments					 * and labels */   delete_symbols(&loctab, 0, TRUE, TRUE);	/* clear local variables						 * queue */   assert(loctab.next == NULL);   curfunc = NULL;   if (sc_status == statSKIP)     {	sc_status = statWRITE;	code_idx = cidx;	glb_declared = glbdecl;     }				/* if */   return TRUE;}