// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   C:\Sergey\Java\Plota\Program.java

import java.util.Hashtable;
import java.util.Vector;

public class Program implements Runnable, Tokens {

    private boolean executeLine() throws SyntaxErrorException {
        boolean bPlot = false;
        int tt = 0;
        m_iProg = m_iProgPrv = 0;
label0:
        do
            do
            {
                if(!nextToken())
                    break label0;
                tt = m_Token.getType();
                if(tt != 306)
                    continue label0;
                String name = m_Token.getName();
                int ts = m_Token.getSubType();
                if(name.equals("y"))
                    bPlot = true;
                double value = assignVariable();
                m_Var.setValue(name, value);     // I'm guessing this is where xmax and xmin are set.
            } while(true);
        while(tt != 310);
        return bPlot;
    }

    public void processLine(String text) {
        if(text == null)
            printlnOut("No program to load.");
        m_sText = new StringBuffer(text);
        m_Applet.getTextFields();
        m_Xmax = m_Var.getValue("xmax");
        m_Xmin = m_Var.getValue("xmin");
        m_NumPoints = (int)Math.round(m_Var.getValue("numpoints"));
        if(text.trim().length() < 3) {
            return;
        } else {
            execute();
            return;
        }
    }

    private double levelNum2()
        throws SyntaxErrorException
    {
        int op = m_Token.getSubType();
        if(op == 342 || op == 343)
            nextToken();
        double result = levelNum3();
        if(op == 343)
            result = -result;
        while((op = m_Token.getSubType()) == 342 || op == 343) 
        {
            nextToken();
            double hold = levelNum3();
            result = calcArithm(op, result, hold);
        }
        return result;
    }

    public void start()
    {
        if(m_Runner == null)
        {
            m_Runner = new Thread(this);
            m_Runner.start();
        }
    }

    public void stop()
    {
        if(m_Runner != null)
        {
            m_Runner.stop();
            m_Runner = null;
        }
    }

    public void execute()
    {
        m_cText = m_sText.toString().toCharArray();
        m_nProg = m_cText.length;
        boolean bSendData = false;
        try
        {
            if(executeLine())
            {
		double[] m_Xarr = new double[1201];
		double[] m_Yarr = new double[1201];

                m_DelX = (m_Xmax - m_Xmin) / ((double)m_NumPoints - 1.0D);
                for(int i = 0; i < m_NumPoints; i++)
                {
                    m_Xarr[i] = m_Xmin + (double)i * m_DelX;
                    m_Var.setValue("x", m_Xarr[i]);
                    executeLine();
                    m_Yarr[i] = m_Var.getValue("y");   //!flag
                }

                bSendData = true;

		while (m_Xarrs.size() < (current_equation+1)) {
		    m_Xarrs.add(null);   // add a blank new element, then overwrite it as the
		    m_Yarrs.add(null);   // new equation's points come in.
		}

		m_Xarrs.setElementAt(m_Xarr, current_equation);
		m_Yarrs.setElementAt(m_Yarr, current_equation);

		System.out.println("m_Xarr started at [" + m_Xarr[0] + "] (is this an int?)");
		System.out.println("current_equation is [" + current_equation + "]");
		System.out.println("The size of m_Xarrs in Program.java is now [" + m_Xarrs.size() + "]");
            }
        }
        catch(SyntaxErrorException e)
        {
            printlnOut(e.toString());
            return;
        }
        m_Xmax = m_Var.getValue("xmax");
        m_Xmin = m_Var.getValue("xmin");
        m_NumPoints = (int)Math.round(m_Var.getValue("numpoints"));
        m_Applet.setTextField();
        printstrOut(new String(m_cText));
        m_cText = null;
        if(bSendData)
            m_Applet.sendData("plota");
    }

    private double levelNum5()
        throws SyntaxErrorException
    {
        int st = m_Token.getSubType();
        boolean bfunc = false;
        if(m_Token.getType() == 308)
        {
            nextToken();
            bfunc = true;
        }
        double result = levelNum6();
        if(bfunc)
            result = calcFnc(st, result);
        return result;
    }

    public Program(Calca applet)
    {
        m_bInvalid = true;
        m_sError = new StringBuffer(80);
        m_Var = new Variables();
        m_dNumPoints = 800D;
        m_NumPoints = (int)Math.round(m_dNumPoints);
        m_Xmax = 800D;
        m_DelX = (m_Xmax - m_Xmin) / ((double)m_NumPoints - 1.0D);
        m_Ymax = 1.0D;
        //m_Xarr = new double[1201];
        //m_Yarr = new double[1201];
	m_Xarrs = new Vector();
	m_Yarrs = new Vector();
        m_Applet = applet;
    }

    public void clearOut()
    {
        m_Applet.clearOut();
    }

    private void printlnOut(String str)
    {
        m_Applet.printlnOut(str);
    }

    public synchronized void pushBack()
    {
        m_iProg = m_iProgPrv;
    }

    private double calcArithm(int op, double a, double b)
        throws SyntaxErrorException
    {
        switch(op)
        {
        case 342: 
            return a + b;

        case 343: 
            return a - b;

        case 344: 
            return a * b;

        case 345: 
            return a / b;

        case 346: 
            return a % b;

        case 347: 
            return Math.pow(a, b);
        }
        throw new SyntaxErrorException("unknown operator.");
    }

    private double levelNum3()
        throws SyntaxErrorException
    {
        double result;
        int op;
        double hold;
        for(result = levelNum4(); (op = m_Token.getSubType()) == 344 || op == 345 || op == 346; result = calcArithm(op, result, hold))
        {
            nextToken();
            hold = levelNum4();
        }

        return result;
    }

    private void printstrOut(String str)
    {
        m_Applet.printstrOut(str);
    }

    public synchronized boolean nextToken()
        throws SyntaxErrorException
    {
        m_Token = new Token(310);
        if(m_iProg >= m_nProg)
            return false;
        m_iProgPrv = m_iProg;
        if(m_cText == null || m_cText[m_iProg] == '\n' || m_cText[m_iProg] == ';')
        {
            m_iProg++;
            m_Token = new Token(310);
            return false;
        }
        for(; m_cText[m_iProg] == ' ' || m_cText[m_iProg] == '\t'; m_iProg++);
        switch(m_cText[m_iProg])
        {
        case 61: // '='
            m_iProg++;
            m_Token = new Token(304, 341);
            return true;

        case 43: // '+'
            m_iProg++;
            m_Token = new Token(304, 342);
            return true;

        case 45: // '-'
            m_iProg++;
            m_Token = new Token(304, 343);
            return true;

        case 42: // '*'
            m_iProg++;
            m_Token = new Token(304, 344);
            return true;

        case 47: // '/'
            m_iProg++;
            m_Token = new Token(304, 345);
            return true;

        case 37: // '%'
            m_iProg++;
            m_Token = new Token(304, 346);
            return true;

        case 94: // '^'
            m_iProg++;
            m_Token = new Token(304, 347);
            return true;

        case 40: // '('
            m_iProg++;
            m_Token = new Token(304, 351);
            return true;

        case 41: // ')'
            m_iProg++;
            m_Token = new Token(304, 352);
            return true;

        case 44: // ','
            m_iProg++;
            m_Token = new Token(301, 356);
            return true;
        }
        String sdelim = " ;,+-></*%^=!(){}\\[]\t\r\n";
        if(m_cText[m_iProg] >= '0' && m_cText[m_iProg] <= '9' || m_cText[m_iProg] == '.')
        {
            StringBuffer sbuff = new StringBuffer();
            sbuff.append(m_cText[m_iProg]);
            for(m_iProg++; sdelim.indexOf(m_cText[m_iProg]) < 0 || (m_cText[m_iProg] == '+' || m_cText[m_iProg] == '-') && (m_cText[m_iProg - 1] == 'e' || m_cText[m_iProg - 1] == 'E'); m_iProg++)
                sbuff.append(m_cText[m_iProg]);

            String sval = sbuff.toString();
            m_Token = new Token(305, sval, Double.valueOf(sval).doubleValue());
            return true;
        }
        if(m_cText[m_iProg] >= 'A' && m_cText[m_iProg] <= 'Z' || m_cText[m_iProg] >= 'a' && m_cText[m_iProg] <= 'z' || m_cText[m_iProg] == '_')
        {
            StringBuffer sbuff = new StringBuffer();
            sbuff.append(m_cText[m_iProg]);
            for(m_iProg++; sdelim.indexOf(m_cText[m_iProg]) < 0; m_iProg++)
                sbuff.append(m_cText[m_iProg]);

            String sname = sbuff.toString();
            if(m_Fnc.containsKey(sname))
            {
                m_Token = new Token(308, ((Integer)m_Fnc.get(sname)).intValue());
                return true;
            } else
            {
                m_Token = new Token(306, sname, m_Var.getValue(sname));
                return true;
            }
        } else
        {
            throw new SyntaxErrorException("Unknown symbol.");
        }
    }

    public void run()
    {
        do
        {
            if(m_bInvalid)
                m_bInvalid = false;
            try
            {
                Thread.sleep(1000L);
            }
            catch(InterruptedException interruptedexception) { }
        } while(true);
    }

    public synchronized double assignVariable()
        throws SyntaxErrorException
    {
        nextToken();
        nextToken();
        double dval = calcNumExpr();
        return dval;
    }

    private double levelNum4()
        throws SyntaxErrorException
    {
        double result = levelNum5();
        int op = m_Token.getSubType();
        if(op == 347)
        {
            nextToken();
            double hold = levelNum5();
            result = calcArithm(op, result, hold);
        }
        return result;
    }

    public double sinh(double x) {return (Math.exp(x)-Math.exp(-x))/2;}

    public double cosh(double x) {return (Math.exp(x)+Math.exp(-x))/2;}

    public double sech(double x) {return (1/cosh(x));}

    public double tanh(double x) {return (sinh(x)/cosh(x));}



    private double calcFnc(int stype, double x)
        throws SyntaxErrorException
    {
        switch(stype)
        {
        case 701: 
            return Math.abs(x);

        case 702: 
            return Math.rint(x);

        case 703: 
            return Math.sin(x);

        case 704: 
            return Math.cos(x);

        case 705: 
            return Math.asin(x);

        case 706: 
            return Math.acos(x);

        case 707: 
            return Math.tan(x);

        case 708: 
            return Math.atan(x);

        case 710: 
            return Math.sqrt(x);

        case 711: 
            return Math.exp(x);

        case 712: 
            return Math.log(x);

        case 713: 
            return sech(x);

        case 714: 
            return sinh(x);

        case 715: 
            return cosh(x);

        case 716: 
            return tanh(x);

        case 709: 
        default:
            throw new SyntaxErrorException("Unknown function.");
        }
    }

    private double levelNum6()
        throws SyntaxErrorException
    {
        double result = 0.0D;
        if(m_Token.getSubType() == 351)
        {
            nextToken();
            result = levelNum2();
            if(m_Token.getSubType() != 352)
                throw new SyntaxErrorException("')' is absent.");
        } else
        {
            switch(m_Token.getType())
            {
            case 306: 
                result = m_Var.getValue(m_Token.getName());
                break;

            case 305: 
                result = m_Token.getValue();
                break;

            default:
                result = (0.0D / 0.0D);
                break;
            }
        }
        if(result == (0.0D / 0.0D))
        {
            throw new SyntaxErrorException("Unknown variable.");
        } else
        {
            nextToken();
            return result;
        }
    }

    public double calcNumExpr()
        throws SyntaxErrorException
    {
        double dResult = levelNum2();
        pushBack();
        return dResult;
    }

    private Calca m_Applet;
    private Thread m_Runner;
    private boolean m_bInvalid;
    private StringBuffer m_sText;
    private int m_Index;
    private Token m_Token;
    private char m_cText[];
    private int m_iProg;
    private int m_iProgPrv;
    private int m_nProg;
    private static Hashtable m_Fnc;
    private StringBuffer m_sError;
    public Variables m_Var;
    private final double DEGTORAD = 0.017453292519943295D;
    private double m_dNumPoints;
    public int m_NumPoints;
    private double m_Y;
    private double m_X;
    public double m_Xmin;
    public double m_Xmax;
    private double m_DelX;
    public double m_Ymin;
    public double m_Ymax;
    //public double m_Xarr[];
    //public double m_Yarr[];
    public Vector m_Xarrs;
    public Vector m_Yarrs;
    public int current_equation;

    static 
    {
        m_Fnc = new Hashtable();
        m_Fnc.put("abs", new Integer(701));
        m_Fnc.put("rint", new Integer(702));
        m_Fnc.put("sin", new Integer(703));
        m_Fnc.put("cos", new Integer(704));
        m_Fnc.put("asin", new Integer(705));
        m_Fnc.put("acos", new Integer(706));
        m_Fnc.put("tan", new Integer(707));
        m_Fnc.put("atan", new Integer(708));
        m_Fnc.put("sqrt", new Integer(710));
        m_Fnc.put("exp", new Integer(711));
        m_Fnc.put("log", new Integer(712));
        m_Fnc.put("sech", new Integer(713));
        m_Fnc.put("sinh", new Integer(714));
        m_Fnc.put("cosh", new Integer(714));
        m_Fnc.put("tanh", new Integer(714));
    }
}