if ((sym = findloc(name)) != NULL && sym->compound != nestlevel
if (((sym = findloc(name)) != NULL && sym->compound != nestlevel)
declloc(int fstatic){   int                 ident, tag;   int                 idxtag[sDIMEN_MAX];   char                name[sNAMEMAX + 1];   symbol             *sym;   cell                val, size;   char               *str;   value               lval = { 0 };   int                 cur_lit = 0;   int                 dim[sDIMEN_MAX];   int                 numdim, level;   int                 fconst;   fconst = matchtoken(tCONST);   do     {	ident = iVARIABLE;	size = 1;	numdim = 0;		/* no dimensions */	tag = sc_addtag(NULL);	if (lex(&val, &str) != tSYMBOL)	/* read in (new) token */	   error(20, str);	/* invalid symbol name */	assert(strlen(str) <= sNAMEMAX);	strcpy(name, str);	/* save symbol name */	if (name[0] == PUBLIC_CHAR)	   error(56, name);	/* local variables cannot be public */	/* Note: block locals may be named identical to locals at higher	 * compound blocks (as with standard C); so we must check (and add)	 * the "nesting level" of local variables to verify the	 * multi-definition of symbols.	 */	if ((sym = findloc(name)) != NULL && sym->compound == nestlevel)	   error(21, name);	/* symbol already defined */	/* Although valid, a local variable whose name is equal to that	 * of a global variable or to that of a local variable at a lower	 * level might indicate a bug.	 */	if ((sym = findloc(name)) != NULL && sym->compound != nestlevel	    || findglb(name) != NULL)	   error(219, name);	/* variable shadows another symbol */	while (matchtoken('['))	  {	     ident = iARRAY;	     if (numdim == sDIMEN_MAX)	       {		  error(53);	/* exceeding maximum number of dimensions */		  return ident;	       }		/* if */	     if (numdim > 0 && dim[numdim - 1] == 0)		error(52);	/* only last dimension may be variable length */	     size = needsub(&idxtag[numdim]);	/* get size; size==0 for "var[]" */#if INT_MAX < LONG_MAX	     if (size > INT_MAX)		error(105);	/* overflow, exceeding capacity */#endif	     dim[numdim++] = (int)size;	  }			/* while */	if (ident == iARRAY || fstatic)	  {	     if (sc_alignnext)	       {		  aligndata(sc_dataalign);		  sc_alignnext = FALSE;	       }		/* if */	     cur_lit = litidx;	/* save current index in the literal table */	     initials(ident, tag, &size, dim, numdim);	     if (size == 0)		return ident;	/* error message already given */	     if (numdim == 1)		dim[0] = (int)size;	  }			/* if */	/* reserve memory (on the stack) for the variable */	if (fstatic)	  {	     /* write zeros for uninitialized fields */	     while (litidx < cur_lit + size)		stowlit(0);	     sym =		addvariable(name, (cur_lit + glb_declared) * sizeof(cell),			    ident, sSTATIC, tag, dim, numdim, idxtag);	     defsymbol(name, ident, sSTATIC,		       (cur_lit + glb_declared) * sizeof(cell), tag);	  }	else	  {	     declared += (int)size;	/* variables are put on stack,					 * adjust "declared" */	     sym =		addvariable(name, -declared * sizeof(cell), ident, sLOCAL, tag,			    dim, numdim, idxtag);	     defsymbol(name, ident, sLOCAL, -declared * sizeof(cell), tag);	     modstk(-(int)size * sizeof(cell));	  }			/* if */	/* now that we have reserved memory for the variable, we can	 * proceed to initialize it */	sym->compound = nestlevel;	/* for multiple declaration/shadowing */	if (fconst)	   sym->usage |= uCONST;	if (ident == iARRAY)	   for (level = 0; level < numdim; level++)	      symbolrange(level, dim[level]);	if (!fstatic)	  {			/* static variables already initialized */	     if (ident == iVARIABLE)	       {		  /* simple variable, also supports initialization */		  int                 ctag = tag;	/* set to "tag" by default */		  int                 explicit_init = FALSE;	/* is the variable explicitly								 * initialized? */		  if (matchtoken('='))		    {		       doexpr(FALSE, FALSE, FALSE, FALSE, &ctag, TRUE);		       explicit_init = TRUE;		    }		  else		    {		       const1(0);	/* uninitialized variable, set to zero */		    }		/* if */		  /* now try to save the value (still in PRI) in the variable */		  lval.sym = sym;		  lval.ident = iVARIABLE;		  lval.constval = 0;		  lval.tag = tag;		  check_userop(NULL, ctag, lval.tag, 2, NULL, &ctag);		  store(&lval);		  endexpr(TRUE);	/* full expression ends after the store */		  if (!matchtag(tag, ctag, TRUE))		     error(213);	/* tag mismatch */		  /* if the variable was not explicitly initialized, reset the		   * "uWRITTEN" flag that store() set */		  if (!explicit_init)		     sym->usage &= ~uWRITTEN;	       }	     else	       {		  /* an array */		  if (litidx - cur_lit < size)		     fillarray(sym, size * sizeof(cell), 0);		  if (cur_lit < litidx)		    {		       /* check whether the complete array is set to a single value;		        * if it is, more compact code can be generated */		       cell                first = litq[cur_lit];		       int                 i;		       for (i = cur_lit; i < litidx && litq[i] == first; i++)			  /* nothing */ ;		       if (i == litidx)			 {			    /* all values are the same */			    fillarray(sym, (litidx - cur_lit) * sizeof(cell),				      first);			    litidx = cur_lit;	/* reset literal table */			 }		       else			 {			    /* copy the literals to the array */			    const1((cur_lit + glb_declared) * sizeof(cell));			    copyarray(sym, (litidx - cur_lit) * sizeof(cell));			 }	/* if */		    }		/* if */	       }		/* if */	  }			/* if */     }   while (matchtoken(','));	/* enddo *//* more? */   needtoken(tTERM);		/* if not comma, must be semicolumn */   return ident;}