(paramString, new Primitive(paramBoolean));
  }
  
  public void unset(String paramString)
    throws EvalError
  {
    CallStack localCallStack = new CallStack();
    try
    {
      LHS localLHS = globalNameSpace.getNameResolver(paramString).toLHS(localCallStack, this);
      if (type != 0) {
        throw new EvalError("Can't unset, not a variable: " + paramString, SimpleNode.JAVACODE, new CallStack());
      }
      nameSpace.unsetVariable(paramString);
    }
    catch (UtilEvalError localUtilEvalError)
    {
      throw new EvalError(localUtilEvalError.getMessage(), SimpleNode.JAVACODE, new CallStack());
    }
  }
  
  public Object getInterface(Class paramClass)
    throws EvalError
  {
    try
    {
      return globalNameSpace.getThis(this).getInterface(paramClass);
    }
    catch (UtilEvalError localUtilEvalError)
    {
      throw localUtilEvalError.toEvalError(SimpleNode.JAVACODE, new CallStack());
    }
  }
  
  private JJTParserState get_jjtree()
  {
    return parser.jjtree;
  }
  
  private JavaCharStream get_jj_input_stream()
  {
    return parser.jj_input_stream;
  }
  
  private boolean Line()
    throws ParseException
  {
    return parser.Line();
  }
  
  void loadRCFiles()
  {
    try
    {
      String str = System.getProperty("user.home") + File.separator + ".bshrc";
      source(str, globalNameSpace);
    }
    catch (Exception localException)
    {
      if (DEBUG) {
        debug("Could not find rc file: " + localException);
      }
    }
  }
  
  public File pathToFile(String paramString)
    throws IOException
  {
    File localFile = new File(paramString);
    if (!localFile.isAbsolute())
    {
      String str = (String)getu("bsh.cwd");
      localFile = new File(str + File.separator + paramString);
    }
    return new File(localFile.getCanonicalPath());
  }
  
  public static void redirectOutputToFile(String paramString)
  {
    try
    {
      PrintStream localPrintStream = new PrintStream(new FileOutputStream(paramString));
      System.setOut(localPrintStream);
      System.setErr(localPrintStream);
    }
    catch (IOException localIOException)
    {
      System.err.println("Can't redirect output to file: " + paramString);
    }
  }
  
  public void setClassLoader(ClassLoader paramClassLoader)
  {
    getClassManager().setClassLoader(paramClassLoader);
  }
  
  public BshClassManager getClassManager()
  {
    return getNameSpace().getClassManager();
  }
  
  public void setStrictJava(boolean paramBoolean)
  {
    strictJava = paramBoolean;
  }
  
  public boolean getStrictJava()
  {
    return strictJava;
  }
  
  static void staticInit()
  {
    try
    {
      systemLineSeparator = System.getProperty("line.separator");
      debug = System.err;
      DEBUG = Boolean.getBoolean("debug");
      TRACE = Boolean.getBoolean("trace");
      LOCALSCOPING = Boolean.getBoolean("localscoping");
      String str = System.getProperty("outfile");
      if (str != null) {
        redirectOutputToFile(str);
      }
    }
    catch (SecurityException localSecurityException)
    {
      System.err.println("Could not init static:" + localSecurityException);
    }
    catch (Exception localException)
    {
      System.err.println("Could not init static(2):" + localException);
    }
    catch (Throwable localThrowable)
    {
      System.err.println("Could not init static(3):" + localThrowable);
    }
  }
  
  public String getSourceFileInfo()
  {
    if (sourceFileInfo != null) {
      return sourceFileInfo;
    }
    return "<unknown source>";
  }
  
  public Interpreter getParent()
  {
    return parent;
  }
  
  public void setOut(PrintStream paramPrintStream)
  {
    out = paramPrintStream;
  }
  
  public void setErr(PrintStream paramPrintStream)
  {
    err = paramPrintStream;
  }
  
  private void readObject(ObjectInputStream paramObjectInputStream)
    throws IOException, ClassNotFoundException
  {
    paramObjectInputStream.defaultReadObject();
    if (console != null)
    {
      setOut(console.getOut());
      setErr(console.getErr());
    }
    else
    {
      setOut(System.out);
      setErr(System.err);
    }
  }
  
  private String getBshPrompt()
  {
    try
    {
      return (String)eval("getBshPrompt()");
    }
    catch (Exception localException) {}
    return "bsh % ";
  }
  
  public void setExitOnEOF(boolean paramBoolean)
  {
    exitOnEOF = paramBoolean;
  }
  
  static
  {
    staticInit();
  }
}

/* Location:
 * Qualified Name:     bsh.Interpreter
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package bsh;

public class InterpreterError
  extends RuntimeException
{
  public InterpreterError(String paramString)
  {
    super(paramString);
  }
}

/* Location:
 * Qualified Name:     bsh.InterpreterError
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package bsh;

import java.util.Stack;

class JJTParserState
{
  private Stack nodes = new Stack();
  private Stack marks = new Stack();
  private int sp = 0;
  private int mk = 0;
  private boolean node_created;
  
  boolean nodeCreated()
  {
    return node_created;
  }
  
  void reset()
  {
    nodes.removeAllElements();
    marks.removeAllElements();
    sp = 0;
    mk = 0;
  }
  
  Node rootNode()
  {
    return (Node)nodes.elementAt(0);
  }
  
  void pushNode(Node paramNode)
  {
    nodes.push(paramNode);
    sp += 1;
  }
  
  Node popNode()
  {
    if (--sp < mk) {
      mk = ((Integer)marks.pop()).intValue();
    }
    return (Node)nodes.pop();
  }
  
  Node peekNode()
  {
    return (Node)nodes.peek();
  }
  
  int nodeArity()
  {
    return sp - mk;
  }
  
  void clearNodeScope(Node paramNode)
  {
    while (sp > mk) {
      popNode();
    }
    mk = ((Integer)marks.pop()).intValue();
  }
  
  void openNodeScope(Node paramNode)
  {
    marks.push(new Integer(mk));
    mk = sp;
    paramNode.jjtOpen();
  }
  
  void closeNodeScope(Node paramNode, int paramInt)
  {
    mk = ((Integer)marks.pop()).intValue();
    while (paramInt-- > 0)
    {
      Node localNode = popNode();
      localNode.jjtSetParent(paramNode);
      paramNode.jjtAddChild(localNode, paramInt);
    }
    paramNode.jjtClose();
    pushNode(paramNode);
    node_created = true;
  }
  
  void closeNodeScope(Node paramNode, boolean paramBoolean)
  {
    if (paramBoolean)
    {
      int i = nodeArity();
      mk = ((Integer)marks.pop()).intValue();
      while (i-- > 0)
      {
        Node localNode = popNode();
        localNode.jjtSetParent(paramNode);
        paramNode.jjtAddChild(localNode, i);
      }
      paramNode.jjtClose();
      pushNode(paramNode);
      node_created = true;
    }
    else
    {
      mk = ((Integer)marks.pop()).intValue();
      node_created = false;
    }
  }
}

/* Location:
 * Qualified Name:     bsh.JJTParserState
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package bsh;

import java.awt.Image;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.AdjustmentEvent;
import java.awt.event.AdjustmentListener;
import java.awt.event.ComponentEvent;
import java.awt.event.ComponentListener;
import java.awt.event.ContainerEvent;
import java.awt.event.ContainerListener;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.event.TextEvent;
import java.awt.event.TextListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import javax.swing.event.AncestorEvent;
import javax.swing.event.AncestorListener;
import javax.swing.event.CaretEvent;
import javax.swing.event.CaretListener;
import javax.swing.event.CellEditorListener;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import javax.swing.event.HyperlinkEvent;
import javax.swing.event.HyperlinkListener;
import javax.swing.event.InternalFrameEvent;
import javax.swing.event.InternalFrameListener;
import javax.swing.event.ListDataEvent;
import javax.swing.event.ListDataListener;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.event.MenuDragMouseEvent;
import javax.swing.event.MenuDragMouseListener;
import javax.swing.event.MenuEvent;
import javax.swing.event.MenuKeyEvent;
import javax.swing.event.MenuKeyListener;
import javax.swing.event.MenuListener;
import javax.swing.event.MouseInputListener;
import javax.swing.event.PopupMenuEvent;
import javax.swing.event.PopupMenuListener;
import javax.swing.event.TableColumnModelEvent;
import javax.swing.event.TableColumnModelListener;
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.event.TreeExpansionEvent;
import javax.swing.event.TreeExpansionListener;
import javax.swing.event.TreeModelEvent;
import javax.swing.event.TreeModelListener;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.event.TreeWillExpandListener;
import javax.swing.event.UndoableEditEvent;
import javax.swing.event.UndoableEditListener;

class JThis
  extends This
  implements ActionListener, AdjustmentListener, ComponentListener, ContainerListener, FocusListener, ItemListener, KeyListener, MouseListener, MouseMotionListener, TextListener, WindowListener, PropertyChangeListener, AncestorListener, CaretListener, CellEditorListener, ChangeListener, DocumentListener, HyperlinkListener, InternalFrameListener, ListDataListener, ListSelectionListener, MenuDragMouseListener, MenuKeyListener, MenuListener, MouseInputListener, PopupMenuListener, TableColumnModelListener, TableModelListener, TreeExpansionListener, TreeModelListener, TreeSelectionListener, TreeWillExpandListener, UndoableEditListener
{
  JThis(NameSpace paramNameSpace, Interpreter paramInterpreter)
  {
    super(paramNameSpace, paramInterpreter);
  }
  
  public String toString()
  {
    return "'this' reference (JThis) to Bsh object: " + namespace.nsName;
  }
  
  void event(String paramString, Object paramObject)
  {
    CallStack localCallStack = new CallStack(namespace);
    BshMethod localBshMethod = null;
    try
    {
      localBshMethod = namespace.getMethod("handleEvent", new Class[] { null });
    }
    catch (UtilEvalError localUtilEvalError1) {}
    if (localBshMethod != null) {
      try
      {
        localBshMethod.invoke(new Object[] { paramObject }, declaringInterpreter, localCallStack, null);
      }
      catch (EvalError localEvalError1)
      {
        declaringInterpreter.error("local event hander method invocation error:" + localEvalError1);
      }
    }
    try
    {
      localBshMethod = namespace.getMethod(paramString, new Class[] { null });
    }
    catch (UtilEvalError localUtilEvalError2) {}
    if (localBshMethod != null) {
      try
      {
        localBshMethod.invoke(new Object[] { paramObject }, declaringInterpreter, localCallStack, null);
      }
      catch (EvalError localEvalError2)
      {
        declaringInterpreter.error("local event hander method invocation error:" + localEvalError2);
      }
    }
  }
  
  public void ancestorAdded(AncestorEvent paramAncestorEvent)
  {
    event("ancestorAdded", paramAncestorEvent);
  }
  
  public void ancestorRemoved(AncestorEvent paramAncestorEvent)
  {
    event("ancestorRemoved", paramAncestorEvent);
  }
  
  public void ancestorMoved(AncestorEvent paramAncestorEvent)
  {
    event("ancestorMoved", paramAncestorEvent);
  }
  
  public void caretUpdate(CaretEvent paramCaretEvent)
  {
    event("caretUpdate", paramCaretEvent);
  }
  
  public void editingStopped(ChangeEvent paramChangeEvent)
  {
    event("editingStopped", paramChangeEvent);
  }
  
  public void editingCanceled(ChangeEvent paramChangeEvent)
  {
    event("editingCanceled", paramChangeEvent);
  }
  
  public void stateChanged(ChangeEvent paramChangeEvent)
  {
    event("stateChanged", paramChangeEvent);
  }
  
  public void insertUpdate(DocumentEvent paramDocumentEvent)
  {
    event("insertUpdate", paramDocumentEvent);
  }
  
  public void removeUpdate(DocumentEvent paramDocumentEvent)
  {
    event("removeUpdate", paramDocumentEvent);
  }
  
  public void changedUpdate(DocumentEvent paramDocumentEvent)
  {
    event("changedUpdate", paramDocumentEvent);
  }
  
  public void hyperlinkUpdate(HyperlinkEvent paramHyperlinkEvent)
  {
    event("internalFrameOpened", paramHyperlinkEvent);
  }
  
  public void internalFrameOpened(InternalFrameEvent paramInternalFrameEvent)
  {
    event("internalFrameOpened", paramInternalFrameEvent);
  }
  
  public void internalFrameClosing(InternalFrameEvent paramInternalFrameEvent)
  {
    event("internalFrameClosing", paramInternalFrameEvent);
  }
  
  public void internalFrameClosed(InternalFrameEvent paramInternalFrameEvent)
  {
    event("internalFrameClosed", paramInternalFrameEvent);
  }
  
  public void internalFrameIconified(InternalFrameEvent paramInternalFrameEvent)
  {
    event("internalFrameIconified", paramInternalFrameEvent);
  }
  
  public void internalFrameDeiconified(InternalFrameEvent paramInternalFrameEvent)
  {
    event("internalFrameDeiconified", paramInternalFrameEvent);
  }
  
  public void internalFrameActivated(InternalFrameEvent paramInternalFrameEvent)
  {
    event("internalFrameActivated", paramInternalFrameEvent);
  }
  
  public void internalFrameDeactivated(InternalFrameEvent paramInternalFrameEvent)
  {
    event("internalFrameDeactivated", paramInternalFrameEvent);
  }
  
  public void intervalAdded(ListDataEvent paramListDataEvent)
  {
    event("intervalAdded", paramListDataEvent);
  }
  
  public void intervalRemoved(ListDataEvent paramListDataEvent)
  {
    event("intervalRemoved", paramListDataEvent);
  }
  
  public void contentsChanged(ListDataEvent paramListDataEvent)
  {
    event("contentsChanged", paramListDataEvent);
  }
  
  public void valueChanged(ListSelectionEvent paramListSelectionEvent)
  {
    event("valueChanged", paramListSelectionEvent);
  }
  
  public void menuDragMouseEntered(MenuDragMouseEvent paramMenuDragMouseEvent)
  {
    event("menuDragMouseEntered", paramMenuDragMouseEvent);
  }
  
  public void menuDragMouseExited(MenuDragMouseEvent paramMenuDragMouseEvent)
  {
    event("menuDragMouseExited", paramMenuDragMouseEvent);
  }
  
  public void menuDragMouseDragged(MenuDragMouseEvent paramMenuDragMouseEvent)
  {
    event("menuDragMouseDragged", paramMenuDragMouseEvent);
  }
  
  public void menuDragMouseReleased(MenuDragMouseEvent paramMenuDragMouseEvent)
  {
    event("menuDragMouseReleased", paramMenuDragMouseEvent);
  }
  
  public void menuKeyTyped(MenuKeyEvent paramMenuKeyEvent)
  {
    event("menuKeyTyped", paramMenuKeyEvent);
  }
  
  public void menuKeyPressed(MenuKeyEvent paramMenuKeyEvent)
  {
    event("menuKeyPressed", paramMenuKeyEvent);
  }
  
  public void menuKeyReleased(MenuKeyEvent paramMenuKeyEvent)
  {
    event("menuKeyReleased", paramMenuKeyEvent);
  }
  
  public void menuSelected(MenuEvent paramMenuEvent)
  {
    event("menuSelected", paramMenuEvent);
  }
  
  public void menuDeselected(MenuEvent paramMenuEvent)
  {
    event("menuDeselected", paramMenuEvent);
  }
  
  public void menuCanceled(MenuEvent paramMenuEvent)
  {
    event("menuCanceled", paramMenuEvent);
  }
  
  public void popupMenuWillBecomeVisible(PopupMenuEvent paramPopupMenuEvent)
  {
    event("popupMenuWillBecomeVisible", paramPopupMenuEvent);
  }
  
  public void popupMenuWillBecomeInvisible(PopupMenuEvent paramPopupMenuEvent)
  {
    event("popupMenuWillBecomeInvisible", paramPopupMenuEvent);
  }
  
  public void popupMenuCanceled(PopupMenuEvent paramPopupMenuEvent)
  {
    event("popupMenuCanceled", paramPopupMenuEvent);
  }
  
  public void columnAdded(TableColumnModelEvent paramTableColumnModelEvent)
  {
    event("columnAdded", paramTableColumnModelEvent);
  }
  
  public void columnRemoved(TableColumnModelEvent paramTableColumnModelEvent)
  {
    event("columnRemoved", paramTableColumnModelEvent);
  }
  
  public void columnMoved(TableColumnModelEvent paramTableColumnModelEvent)
  {
    event("columnMoved", paramTableColumnModelEvent);
  }
  
  public void columnMarginChanged(ChangeEvent paramChangeEvent)
  {
    event("columnMarginChanged", paramChangeEvent);
  }
  
  public void columnSelectionChanged(ListSelectionEvent paramListSelectionEvent)
  {
    event("columnSelectionChanged", paramListSelectionEvent);
  }
  
  public void tableChanged(TableModelEvent paramTableModelEvent)
  {
    event("tableChanged", paramTableModelEvent);
  }
  
  public void treeExpanded(TreeExpansionEvent paramTreeExpansionEvent)
  {
    event("treeExpanded", paramTreeExpansionEvent);
  }
  
  public void treeCollapsed(TreeExpansionEvent paramTreeExpansionEvent)
  {
    event("treeCollapsed", paramTreeExpansionEvent);
  }
  
  public void treeNodesChanged(TreeModelEvent paramTreeModelEvent)
  {
    event("treeNodesChanged", paramTreeModelEvent);
  }
  
  public void treeNodesInserted(TreeModelEvent paramTreeModelEvent)
  {
    event("treeNodesInserted", paramTreeModelEvent);
  }
  
  public void treeNodesRemoved(TreeModelEvent paramTreeModelEvent)
  {
    event("treeNodesRemoved", paramTreeModelEvent);
  }
  
  public void treeStructureChanged(TreeModelEvent paramTreeModelEvent)
  {
    event("treeStructureChanged", paramTreeModelEvent);
  }
  
  public void valueChanged(TreeSelectionEvent paramTreeSelectionEvent)
  {
    event("valueChanged", paramTreeSelectionEvent);
  }
  
  public void treeWillExpand(TreeExpansionEvent paramTreeExpansionEvent)
  {
    event("treeWillExpand", paramTreeExpansionEvent);
  }
  
  public void treeWillCollapse(TreeExpansionEvent paramTreeExpansionEvent)
  {
    event("treeWillCollapse", paramTreeExpansionEvent);
  }
  
  public void undoableEditHappened(UndoableEditEvent paramUndoableEditEvent)
  {
    event("undoableEditHappened", paramUndoableEditEvent);
  }
  
  public void actionPerformed(ActionEvent paramActionEvent)
  {
    event("actionPerformed", paramActionEvent);
  }
  
  public void adjustmentValueChanged(AdjustmentEvent paramAdjustmentEvent)
  {
    event("adjustmentValueChanged", paramAdjustmentEvent);
  }
  
  public void componentResized(ComponentEvent paramComponentEvent)
  {
    event("componentResized", paramComponentEvent);
  }
  
  public void componentMoved(ComponentEvent paramComponentEvent)
  {
    event("componentMoved", paramComponentEvent);
  }
  
  public void componentShown(ComponentEvent paramComponentEvent)
  {
    event("componentShown", paramComponentEvent);
  }
  
  public void componentHidden(ComponentEvent paramComponentEvent)
  {
    event("componentHidden", paramComponentEvent);
  }
  
  public void componentAdded(ContainerEvent paramContainerEvent)
  {
    event("componentAdded", paramContainerEvent);
  }
  
  public void componentRemoved(ContainerEvent paramContainerEvent)
  {
    event("componentRemoved", paramContainerEvent);
  }
  
  public void focusGained(FocusEvent paramFocusEvent)
  {
    event("focusGained", paramFocusEvent);
  }
  
  public void focusLost(FocusEvent paramFocusEvent)
  {
    event("focusLost", paramFocusEvent);
  }
  
  public void itemStateChanged(ItemEvent paramItemEvent)
  {
    event("itemStateChanged", paramItemEvent);
  }
  
  public void keyTyped(KeyEvent paramKeyEvent)
  {
    event("keyTyped", paramKeyEvent);
  }
  
  public void keyPressed(KeyEvent paramKeyEvent)
  {
    event("keyPressed", paramKeyEvent);
  }
  
  public void keyReleased(KeyEvent paramKeyEvent)
  {
    event("keyReleased", paramKeyEvent);
  }
  
  public void mouseClicked(MouseEvent paramMouseEvent)
  {
    event("mouseClicked", paramMouseEvent);
  }
  
  public void mousePressed(MouseEvent paramMouseEvent)
  {
    event("mousePressed", paramMouseEvent);
  }
  
  public void mouseReleased(MouseEvent paramMouseEvent)
  {
    event("mouseReleased", paramMouseEvent);
  }
  
  public void mouseEntered(MouseEvent paramMouseEvent)
  {
    event("mouseEntered", paramMouseEvent);
  }
  
  public void mouseExited(MouseEvent paramMouseEvent)
  {
    event("mouseExited", paramMouseEvent);
  }
  
  public void mouseDragged(MouseEvent paramMouseEvent)
  {
    event("mouseDragged", paramMouseEvent);
  }
  
  public void mouseMoved(MouseEvent paramMouseEvent)
  {
    event("mouseMoved", paramMouseEvent);
  }
  
  public void textValueChanged(TextEvent paramTextEvent)
  {
    event("textValueChanged", paramTextEvent);
  }
  
  public void windowOpened(WindowEvent paramWindowEvent)
  {
    event("windowOpened", paramWindowEvent);
  }
  
  public void windowClosing(WindowEvent paramWindowEvent)
  {
    event("windowClosing", paramWindowEvent);
  }
  
  public void windowClosed(WindowEvent paramWindowEvent)
  {
    event("windowClosed", paramWindowEvent);
  }
  
  public void windowIconified(WindowEvent paramWindowEvent)
  {
    event("windowIconified", paramWindowEvent);
  }
  
  public void windowDeiconified(WindowEvent paramWindowEvent)
  {
    event("windowDeiconified", paramWindowEvent);
  }
  
  public void windowActivated(WindowEvent paramWindowEvent)
  {
    event("windowActivated", paramWindowEvent);
  }
  
  public void windowDeactivated(WindowEvent paramWindowEvent)
  {
    event("windowDeactivated", paramWindowEvent);
  }
  
  public void propertyChange(PropertyChangeEvent paramPropertyChangeEvent)
  {
    event("propertyChange", paramPropertyChangeEvent);
  }
  
  public void vetoableChange(PropertyChangeEvent paramPropertyChangeEvent)
  {
    event("vetoableChange", paramPropertyChangeEvent);
  }
  
  public boolean imageUpdate(Image paramImage, int paramInt1, int paramInt2, int paramInt3, int paramInt4, int paramInt5)
  {
    BshMethod localBshMethod = null;
    try
    {
      localBshMethod = namespace.getMethod("imageUpdate", new Class[] { null, null, null, null, null, null });
    }
    catch (UtilEvalError localUtilEvalError) {}
    if (localBshMethod != null) {
      try
      {
        CallStack localCallStack = new CallStack(namespace);
        localBshMethod.invoke(new Object[] { paramImage, new Primitive(paramInt1), new Primitive(paramInt2), new Primitive(paramInt3), new Primitive(paramInt4), new Primitive(paramInt5) }, declaringInterpreter, localCallStack, null);
      }
      catch (EvalError localEvalError)
      {
        declaringInterpreter.error("local event handler imageUpdate: method invocation error:" + localEvalError);
      }
    }
    return true;
  }
}

/* Location:
 * Qualified Name:     bsh.JThis
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package bsh;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;

public class JavaCharStream
{
  public static final boolean staticFlag = false;
  public int bufpos = -1;
  int bufsize;
  int available;
  int tokenBegin;
  protected int[] bufline;
  protected int[] bufcolumn;
  protected int column = 0;
  protected int line = 1;
  protected boolean prevCharIsCR = false;
  protected boolean prevCharIsLF = false;
  protected Reader inputStream;
  protected char[] nextCharBuf;
  protected char[] buffer;
  protected int maxNextCharInd = 0;
  protected int nextCharInd = -1;
  protected int inBuf = 0;
  
  static final int hexval(char paramChar)
    throws IOException
  {
    switch (paramChar)
    {
    case '0': 
      return 0;
    case '1': 
      return 1;
    case '2': 
      return 2;
    case '3': 
      return 3;
    case '4': 
      return 4;
    case '5': 
      return 5;
    case '6': 
      return 6;
    case '7': 
      return 7;
    case '8': 
      return 8;
    case '9': 
      return 9;
    case 'A': 
    case 'a': 
      return 10;
    case 'B': 
    case 'b': 
      return 11;
    case 'C': 
    case 'c': 
      return 12;
    case 'D': 
    case 'd': 
      return 13;
    case 'E': 
    case 'e': 
      return 14;
    case 'F': 
    case 'f': 
      return 15;
    }
    throw new IOException();
  }
  
  protected void ExpandBuff(boolean paramBoolean)
  {
    char[] arrayOfChar = new char[bufsize + 2048];
    int[] arrayOfInt1 = new int[bufsize + 2048];
    int[] arrayOfInt2 = new int[bufsize + 2048];
    try
    {
      if (paramBoolean)
      {
        System.arraycopy(buffer, tokenBegin, arrayOfChar, 0, bufsize - tokenBegin);
        System.arraycopy(buffer, 0, arrayOfChar, bufsize - tokenBegin, bufpos);
        buffer = arrayOfChar;
        System.arraycopy(bufline, tokenBegin, arrayOfInt1, 0, bufsize - tokenBegin);
        System.arraycopy(bufline, 0, arrayOfInt1, bufsize - tokenBegin, bufpos);
        bufline = arrayOfInt1;
        System.arraycopy(bufcolumn, tokenBegin, arrayOfInt2, 0, bufsize - tokenBegin);
        System.arraycopy(bufcolumn, 0, arrayOfInt2, bufsize - tokenBegin, bufpos);
        bufcolumn = arrayOfInt2;
        bufpos += bufsize - tokenBegin;
      }
      else
      {
        System.arraycopy(buffer, tokenBegin, arrayOfChar, 0, bufsize - tokenBegin);
        buffer = arrayOfChar;
        System.arraycopy(bufline, tokenBegin, arrayOfInt1, 0, bufsize - tokenBegin);
        bufline = arrayOfInt1;
        System.arraycopy(bufcolumn, tokenBegin, arrayOfInt2, 0, bufsize - tokenBegin);
        bufcolumn = arrayOfInt2;
        bufpos -= tokenBegin;
      }
    }
    catch (Throwable localThrowable)
    {
      throw new Error(localThrowable.getMessage());
    }
    available = (bufsize += 2048);
    tokenBegin = 0;
  }
  
  protected void FillBuff()
    throws IOException
  {
    if (maxNextCharInd == 4096) {
      maxNextCharInd = (nextCharInd = 0);
    }
    try
    {
      int i;
      if ((i = inputStream.read(nextCharBuf, maxNextCharInd, 4096 - maxNextCharInd)) == -1)
      {
        inputStream.close();
        throw new IOException();
      }
      maxNextCharInd += i;
      return;
    }
    catch (IOException localIOException)
    {
      if (bufpos != 0)
      {
        bufpos -= 1;
        backup(0);
      }
      else
      {
        bufline[bufpos] = line;
        bufcolumn[bufpos] = column;
      }
      throw localIOException;
    }
  }
  
  protected char ReadByte()
    throws IOException
  {
    if (++nextCharInd >= maxNextCharInd) {
      FillBuff();
    }
    return nextCharBuf[nextCharInd];
  }
  
  public char BeginToken()
    throws IOException
  {
    if (inBuf > 0)
    {
      inBuf -= 1;
      if (++bufpos == bufsize) {
        bufpos = 0;
      }
      tokenBegin = bufpos;
      return buffer[bufpos];
    }
    tokenBegin = 0;
    bufpos = -1;
    return readChar();
  }
  
  protected void AdjustBuffSize()
  {
    if (available == bufsize)
    {
      if (tokenBegin > 2048)
      {
        bufpos = 0;
        available = tokenBegin;
      }
      else
      {
        ExpandBuff(false);
      }
    }
    else if (available > tokenBegin) {
      available = bufsize;
    } else if (tokenBegin - available < 2048) {
      ExpandBuff(true);
    } else {
      available = tokenBegin;
    }
  }
  
  protected void UpdateLineColumn(char paramChar)
  {
    column += 1;
    if (prevCharIsLF)
    {
      prevCharIsLF = false;
      line += (column = 1);
    }
    else if (prevCharIsCR)
    {
      prevCharIsCR = false;
      if (paramChar == '\n') {
        prevCharIsLF = true;
      } else {
        line += (column = 1);
      }
    }
    switch (paramChar)
    {
    case '\r': 
      prevCharIsCR = true;
      break;
    case '\n': 
      prevCharIsLF = true;
      break;
    case '\t': 
      column -= 1;
      column += 8 - (column & 0x7);
      break;
    }
    bufline[bufpos] = line;
    bufcolumn[bufpos] = column;
  }
  
  public char readChar()
    throws IOException
  {
    if (inBuf > 0)
    {
      inBuf -= 1;
      if (++bufpos == bufsize) {
        bufpos = 0;
      }
      return buffer[bufpos];
    }
    if (++bufpos == available) {
      AdjustBuffSize();
    }
    char c;
    if ((buffer[bufpos] = c = ReadByte()) == '\\')
    {
      UpdateLineColumn(c);
      int i = 1;
      for (;;)
      {
        if (++bufpos == available) {
          AdjustBuffSize();
        }
        try
        {
          if ((buffer[bufpos] = c = ReadByte()) != '\\')
          {
            UpdateLineColumn(c);
            if ((c == 'u') && ((i & 0x1) == 1))
            {
              if (--bufpos < 0) {
                bufpos = (bufsize - 1);
              }
              break;
            }
            backup(i);
            return '\\';
          }
        }
        catch (IOException localIOException1)
        {
          if (i > 1) {
            backup(i);
          }
          return '\\';
        }
        UpdateLineColumn(c);
        i++;
      }
      try
      {
        while ((c = ReadByte()) == 'u') {
          column += 1;
        }
        buffer[bufpos] = (c = (char)(hexval(c) << 12 | hexval(ReadByte()) << 8 | hexval(ReadByte()) << 4 | hexval(ReadByte())));
        column += 4;
      }
      catch (IOException localIOException2)
      {
        throw new Error("Invalid escape character at line " + line + " column " + column + ".");
      }
      if (i == 1) {
        return c;
      }
      backup(i - 1);
      return '\\';
    }
    UpdateLineColumn(c);
    return c;
  }
  
  /**
   * @deprecated
   */
  public int getColumn()
  {
    return bufcolumn[bufpos];
  }
  
  /**
   * @deprecated
   */
  public int getLine()
  {
    return bufline[bufpos];
  }
  
  public int getEndColumn()
  {
    return bufcolumn[bufpos];
  }
  
  public int getEndLine()
  {
    return bufline[bufpos];
  }
  
  public int getBeginColumn()
  {
    return bufcolumn[tokenBegin];
  }
  
  public int getBeginLine()
  {
    return bufline[tokenBegin];
  }
  
  public void backup(int paramInt)
  {
    inBuf += paramInt;
    if (bufpos -= paramInt < 0) {
      bufpos += bufsize;
    }
  }
  
  public JavaCharStream(Reader paramReader, int paramInt1, int paramInt2, int paramInt3)
  {
    inputStream = paramReader;
    line = paramInt1;
    column = (paramInt2 - 1);
    available = (bufsize = paramInt3);
    buffer = new char[paramInt3];
    bufline = new int[paramInt3];
    bufcolumn = new int[paramInt3];
    nextCharBuf = new char['?'];
  }
  
  public JavaCharStream(Reader paramReader, int paramInt1, int paramInt2)
  {
    this(paramReader, paramInt1, paramInt2, 4096);
  }
  
  public JavaCharStream(Reader paramReader)
  {
    this(paramReader, 1, 1, 4096);
  }
  
  public void ReInit(Reader paramReader, int paramInt1, int paramInt2, int paramInt3)
  {
    inputStream = paramReader;
    line = paramInt1;
    column = (paramInt2 - 1);
    if ((buffer == null) || (paramInt3 != buffer.length))
    {
      available = (bufsize = paramInt3);
      buffer = new char[paramInt3];
      bufline = new int[paramInt3];
      bufcolumn = new int[paramInt3];
      nextCharBuf = new char['?'];
    }
    prevCharIsLF = (prevCharIsCR = 0);
    tokenBegin = (inBuf = maxNextCharInd = 0);
    nextCharInd = (bufpos = -1);
  }
  
  public void ReInit(Reader paramReader, int paramInt1, int paramInt2)
  {
    ReInit(paramReader, paramInt1, paramInt2, 4096);
  }
  
  public void ReInit(Reader paramReader)
  {
    ReInit(paramReader, 1, 1, 4096);
  }
  
  public JavaCharStream(InputStream paramInputStream, int paramInt1, int paramInt2, int paramInt3)
  {
    this(new InputStreamReader(paramInputStream), paramInt1, paramInt2, 4096);
  }
  
  public JavaCharStream(InputStream paramInputStream, int paramInt1, int paramInt2)
  {
    this(paramInputStream, paramInt1, paramInt2, 4096);
  }
  
  public JavaCharStream(InputStream paramInputStream)
  {
    this(paramInputStream, 1, 1, 4096);
  }
  
  public void ReInit(InputStream paramInputStream, int paramInt1, int paramInt2, int paramInt3)
  {
    ReInit(new InputStreamReader(paramInputStream), paramInt1, paramInt2, 4096);
  }
  
  public void ReInit(InputStream paramInputStream, int paramInt1, int paramInt2)
  {
    ReInit(paramInputStream, paramInt1, paramInt2, 4096);
  }
  
  public void ReInit(InputStream paramInputStream)
  {
    ReInit(paramInputStream, 1, 1, 4096);
  }
  
  public String GetImage()
  {
    if (bufpos >= tokenBegin) {
      return new String(buffer, tokenBegin, bufpos - tokenBegin + 1);
    }
    return new String(buffer, tokenBegin, bufsize - tokenBegin) + new String(buffer, 0, bufpos + 1);
  }
  
  public char[] GetSuffix(int paramInt)
  {
    char[] arrayOfChar = new char[paramInt];
    if (bufpos + 1 >= paramInt)
    {
      System.arraycopy(buffer, bufpos - paramInt + 1, arrayOfChar, 0, paramInt);
    }
    else
    {
      System.arraycopy(buffer, bufsize - (paramInt - bufpos - 1), arrayOfChar, 0, paramInt - bufpos - 1);
      System.arraycopy(buffer, 0, arrayOfChar, paramInt - bufpos - 1, bufpos + 1);
    }
    return arrayOfChar;
  }
  
  public void Done()
  {
    nextCharBuf = null;
    buffer = null;
    bufline = null;
    bufcolumn = null;
  }
  
  public void adjustBeginLineColumn(int paramInt1, int paramInt2)
  {
    int i = tokenBegin;
    int j;
    if (bufpos >= tokenBegin) {
      j = bufpos - tokenBegin + inBuf + 1;
    } else {
      j = bufsize - tokenBegin + bufpos + 1 + inBuf;
    }
    int k = 0;
    int m = 0;
    int n = 0;
    int i1 = 0;
    int i2 = 0;
    while ((k < j) && (bufline[(m = i % bufsize)] == bufline[(n = ++i % bufsize)]))
    {
      bufline[m] = paramInt1;
      i1 = i2 + bufcolumn[n] - bufcolumn[m];
      bufcolumn[m] = (paramInt2 + i2);
      i2 = i1;
      k++;
    }
    if (k < j)
    {
      bufline[m] = (paramInt1++);
      bufcolumn[m] = (paramInt2 + i2);
      while (k++ < j) {
        if (bufline[(m = i % bufsize)] != bufline[(++i % bufsize)]) {
          bufline[m] = (paramInt1++);
        } else {
          bufline[m] = paramInt1;
        }
      }
    }
    line = bufline[m];
    column = bufcolumn[m];
  }
}

/* Location:
 * Qualified Name:     bsh.JavaCharStream
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package bsh;

import java.io.Serializable;
import java.lang.reflect.Field;

class LHS
  implements ParserConstants, Serializable
{
  NameSpace nameSpace;
  boolean localVar;
  static final int VARIABLE = 0;
  static final int FIELD = 1;
  static final int PROPERTY = 2;
  static final int INDEX = 3;
  static final int METHOD_EVAL = 4;
  int type;
  String varName;
  String propName;
  Field field;
  Object object;
  int index;
  
  LHS(NameSpace paramNameSpace, String paramString)
  {
    throw new Error("namespace lhs");
  }
  
  LHS(NameSpace paramNameSpace, String paramString, boolean paramBoolean)
  {
    type = 0;
    localVar = paramBoolean;
    varName = paramString;
    nameSpace = paramNameSpace;
  }
  
  LHS(Field paramField)
  {
    type = 1;
    object = null;
    field = paramField;
  }
  
  LHS(Object paramObject, Field paramField)
  {
    if (paramObject == null) {
      throw new NullPointerException("constructed empty LHS");
    }
    type = 1;
    object = paramObject;
    field = paramField;
  }
  
  LHS(Object paramObject, String paramString)
  {
    if (paramObject == null) {
      throw new NullPointerException("constructed empty LHS");
    }
    type = 2;
    object = paramObject;
    propName = paramString;
  }
  
  LHS(Object paramObject, int paramInt)
  {
    if (paramObject == null) {
      throw new NullPointerException("constructed empty LHS");
    }
    type = 3;
    object = paramObject;
    index = paramInt;
  }
  
  public Object getValue()
    throws UtilEvalError
  {
    if (type == 0) {
      return nameSpace.getVariable(varName);
    }
    if (type == 1) {
      try
      {
        return field.get(object);
      }
      catch (IllegalAccessException localIllegalAccessException)
      {
        throw new UtilEvalError("Can't read field: " + field);
      }
    }
    if (type == 2) {
      try
      {
        return Reflect.getObjectProperty(object, propName);
      }
      catch (ReflectError localReflectError)
      {
        Interpreter.debug(localReflectError.getMessage());
        throw new UtilEvalError("No such property: " + propName);
      }
    }
    if (type == 3) {
      try
      {
        return Reflect.getIndex(object, index);
      }
      catch (Exception localException)
      {
        throw new UtilEvalError("Array access: " + localException);
      }
    }
    throw new InterpreterError("LHS type");
  }
  
  public Object assign(Object paramObject, boolean paramBoolean)
    throws UtilEvalError
  {
    if (type == 0)
    {
      if (localVar) {
        nameSpace.setLocalVariable(varName, paramObject, paramBoolean);
      } else {
        nameSpace.setVariable(varName, paramObject, paramBoolean);
      }
    }
    else
    {
      if (type == 1) {
        try
        {
          if ((paramObject instanceof Primitive)) {
            paramObject = ((Primitive)paramObject).getValue();
          }
          field.set(object, paramObject);
          return paramObject;
        }
        catch (NullPointerException localNullPointerException)
        {
          throw new UtilEvalError("LHS (" + field.getName() + ") not a static field.");
        }
        catch (IllegalAccessException localIllegalAccessException)
        {
          throw new UtilEvalError("LHS (" + field.getName() + ") can't access field.");
        }
        catch (IllegalArgumentException localIllegalArgumentException)
        {
          throw new UtilEvalError("Argument type mismatch. " + (paramObject == null ? "null" : paramObject.getClass().getName()) + " not assignable to field " + field.getName());
        }
      }
      if (type == 2)
      {
        CollectionManager localCollectionManager = CollectionManager.getCollectionManager();
        if (localCollectionManager.isMap(object)) {
          localCollectionManager.putInMap(object, propName, paramObject);
        } else {
          try
          {
            Reflect.setObjectProperty(object, propName, paramObject);
          }
          catch (ReflectError localReflectError)
          {
            Interpreter.debug("Assignment: " + localReflectError.getMessage());
            throw new UtilEvalError("No such property: " + propName);
          }
        }
      }
      else if (type == 3)
      {
        try
        {
          Reflect.setIndex(object, index, paramObject);
        }
        catch (UtilTargetError localUtilTargetError)
        {
          throw localUtilTargetError;
        }
        catch (Exception localException)
        {
          throw new UtilEvalError("Assignment: " + localException.getMessage());
        }
      }
      else
      {
        throw new InterpreterError("unknown lhs");
      }
    }
    return paramObject;
  }
  
  public String toString()
  {
    return "LHS";
  }
}

/* Location:
 * Qualified Name:     bsh.LHS
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package bsh;

import java.io.Serializable;
import java.util.Hashtable;

class Modifiers
  implements Serializable
{
  public static final int CLASS = 0;
  public static final int METHOD = 1;
  public static final int FIELD = 2;
  Hashtable modifiers;
  
  public void addModifier(int paramInt, String paramString)
  {
    if (modifiers == null) {
      modifiers = new Hashtable();
    }
    Object localObject = modifiers.put(paramString, this);
    if (localObject != null) {
      throw new IllegalStateException("Duplicate modifier: " + paramString);
    }
    int i = 0;
    if (hasModifier("private")) {
      i++;
    }
    if (hasModifier("protected")) {
      i++;
    }
    if (hasModifier("public")) {
      i++;
    }
    if (i > 1) {
      throw new IllegalStateException("public/private/protected cannot be used in combination.");
    }
    switch (paramInt)