return new NotExpr(getLocation(), expr.createAssign(this, parseConditionalExpr()));
token = parseToken();   if (token == '&') return new NotExpr(getLocation(), expr.createAssignRef(this, parseBitOrExpr()));  else { _peekToken = token; return new NotExpr(getLocation(), expr.createAssign(this, parseConditionalExpr())); }
  private Expr parseTermBase()    throws IOException  {    int token = parseToken();    switch (token) {    case STRING:      return new StringLiteralExpr(getLocation(), _lexeme);          case SYSTEM_STRING:      {	ArrayList<Expr> args = new ArrayList<Expr>();	args.add(new StringLiteralExpr(getLocation(), _lexeme));	return new FunctionExpr(getLocation(), "shell_exec", args);      }          case SIMPLE_SYSTEM_STRING:      {	ArrayList<Expr> args = new ArrayList<Expr>();	args.add(parseEscapedString(_lexeme, SIMPLE_STRING_ESCAPE, true));	return new FunctionExpr(getLocation(), "shell_exec", args);      }    case COMPLEX_SYSTEM_STRING:      {	ArrayList<Expr> args = new ArrayList<Expr>();	args.add(parseEscapedString(_lexeme, COMPLEX_STRING_ESCAPE, true));	return new FunctionExpr(getLocation(), "shell_exec", args);      }          case SIMPLE_STRING_ESCAPE:    case COMPLEX_STRING_ESCAPE:      return parseEscapedString(_lexeme, token, false);          case LONG:      return new LiteralExpr(getLocation(), LongValue.create(Long.parseLong(_lexeme)));          case DOUBLE:      return new LiteralExpr(getLocation(), new DoubleValue(Double.parseDouble(_lexeme)));    case NULL:      return NullLiteralExpr.NULL;    case TRUE:      return new LiteralExpr(getLocation(), BooleanValue.TRUE);    case FALSE:      return new LiteralExpr(getLocation(), BooleanValue.FALSE);    case '$':      return parseVariable();      /* quercus/0211    case '&':      {	Expr expr = parseTerm();		return expr.createRef();      }      */    case '-':      {        Expr expr = parseTerm();        return new MinusExpr(getLocation(), expr);      }    case '+':      {        Expr expr = parseTerm();        return new PlusExpr(getLocation(), expr);      }    case '!':      {	// XXX: quercus/03i3 vs quercus/03i4	        Expr expr = parseTerm();	token = parseToken();	if (token == '=') {	  return new NotExpr(getLocation(), expr.createAssign(this,                                                              parseConditionalExpr()));	}	else {	  _peekToken = token;	  	  return new NotExpr(getLocation(), expr);	}      }    case '~':      {        Expr expr = parseTerm();        return new BitNotExpr(getLocation(), expr);      }    case '@':      {        Expr expr = parseTerm();	return new SuppressErrorExpr(getLocation(), expr);      }    case CLONE:      {        Expr expr = parseTerm();	return new CloneExpr(getLocation(), expr);      }    case INCR:      {        Expr expr = parseTerm();        return new PreIncrementExpr(getLocation(), expr, 1);      }    case DECR:      {        Expr expr = parseTerm();        return new PreIncrementExpr(getLocation(), expr, -1);      }    case NEW:      return parseNew();    case INCLUDE:      return new IncludeExpr(getLocation(), _sourceFile, parseExpr());    case REQUIRE:      return new IncludeExpr(getLocation(), _sourceFile, parseExpr(), true);    case INCLUDE_ONCE:      return new IncludeOnceExpr(getLocation(), _sourceFile, parseExpr());    case REQUIRE_ONCE:      return new IncludeOnceExpr(getLocation(), _sourceFile, parseExpr(), true);    case LIST:      return parseList();    case PRINT:      return parsePrintExpr();          case EXIT:      return parseExit();          case DIE:      return parseDie();    case IDENTIFIER:      {	if (_lexeme.equals("new"))	  return parseNew();	String className = null;	String name = _lexeme;	            token = parseToken();        _peekToken = token;	if (token == SCOPE) {	  _peekToken = -1;	  	  className = name;	  token = parseToken();	  if (token == '$')	    return parseStaticClassField(className);	  else	    _peekToken = token;	  	  name = parseIdentifier();	  token = parseToken();	  _peekToken = token;	}	          if (token == '(')          return parseFunction(className, name);        else          return parseConstant(className, name);      }    case '(':      {	Expr expr = parseExpr();	expect(')');	if (expr instanceof ConstExpr) {	  String type = ((ConstExpr) expr).getVar();	  	  if ("bool".equals(type) || "boolean".equals(type))	    return new ToBooleanExpr(getLocation(), parseTerm());	  else if ("int".equals(type) || "integer".equals(type))	    return new ToLongExpr(getLocation(), parseTerm());	  else if ("float".equals(type)		   || "double".equals(type)		   || "real".equals(type))	    return new ToDoubleExpr(getLocation(), parseTerm());	  else if ("string".equals(type))	    return new ToStringExpr(getLocation(), parseTerm());	  else if ("object".equals(type))	    return new ToObjectExpr(getLocation(), parseTerm());	  else if ("array".equalsIgnoreCase(type))	    return new ToArrayExpr(getLocation(), parseTerm());	}	return expr;      }    default:      throw error(L.l("{0} is an unexpected token, expected an expression.",		      tokenName(token)));    }  }