code: private Object eval( boolean toLHS,
          CallStack callstack, Interpreter interpreter)
          throws EvalError
      {
          // We can cache array expressions evaluated during type inference
          if ( isArrayExpression && null != cached )
              return cached;
  
          Object obj = jjtGetChild(0);
          int numChildren = jjtGetNumChildren();
  
          for(int i=1; i<numChildren; i++)
              obj = ((BSHPrimarySuffix)jjtGetChild(i)).doSuffix(
                  obj, toLHS, callstack, interpreter);
  
          /*
              If the result is a Node eval() it to an object or LHS
              (as determined by toLHS)
          */
          if ( obj instanceof SimpleNode )
              if ( obj instanceof BSHAmbiguousName )
                  if ( toLHS )
                      obj = ((BSHAmbiguousName)obj).toLHS(
                          callstack, interpreter);
                  else
                      obj = ((BSHAmbiguousName)obj).toObject(
                          callstack, interpreter);
              else
                  // Some arbitrary kind of node
                  if ( toLHS )
                      // is this right?
                      throw new EvalError("Can't assign to prefix.",
                          this, callstack );
                  else
                      obj = ((SimpleNode)obj).eval(callstack, interpreter);
  
          if ( isMapExpression ) {
              if ( obj == Primitive.VOID )
                  throw new EvalError(
                      "illegal use of undefined variable or 'void' literal",
                      this, callstack );
              // we have a valid map expression return an assignable Map.Entry
              obj = new LHS(obj);
          }
  
          if ( isArrayExpression )
              cached = obj;
          return obj;
      }
docs: /*
  Our children are a prefix expression and any number of suffixes.
  <p>
  
  We don't eval() any nodes until the suffixes have had an
  opportunity to work through them.  This lets the suffixes decide
  how to interpret an ambiguous name (e.g. for the .class operation).