StackParser - WIP

import java.io.*;
import java.io.File;
import java.io.FileNotFoundException;
import java.lang.*;
import java.util.ArrayList;
import java.util.Scanner;

/**
 * This program will perform the following:
 * Uses a scanner to read expressions from Expressions.txt
 * Each expression in Expressions.txt uses a character # to signal the end of the equation.
 * As the Expressions are read in they're placed into a Character Array express
 * Several Array's are established for purposes explained below:
 * Char [] Vart - A character array of variables used within the Equations. Values Range from A - F and then again 0-9.
 * Int [] ivalue - An Int Array to hold the values of each Equation Variable. A - F are given their CHARACTERS value, as are 0-9.
 * Char [] Opert - A character Array of the symbols used within each equation including @ - Exponent, % - Modulus, * - Times, / - Divide, + - Addition, - - Subtraction. ) - Right Paren, and ( - Left Paren
 * Int [] IntValP - An Int Array that holds the priority of each operator from our Operator Equation.
 * As each character from the express array is read, it is assigned as either an Operator, or Operand, given a value or priority, or placed within their relevant stack
 * Math is performed in order of operations on each expression, as read from left to right. Parenthesis with highest priority, followed by Exponent, then Modulus having the same priority as Multiplication and Division and finally Addition and Subtraction with the lowest priority.
 * The entire process is printed to make this appear as a character by character parser.
 */

public class SinglePassParser {
    public static void main(String[] args) throws Exception {

        //Create a scanner to read the file Expressions.text
        try{
            String Test;
            Scanner input = new Scanner(new File("src/main/Expressions.txt"));

                int i, num, ivalu;
                //A Character Array for the variables we'll be using A-F, and 0-9
                char[] vart = {'A', 'B', 'C', 'D', 'E', 'F', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};

                //A int array used to provide values for the Character Array vart, A=8, B=12, C=2, D=3, E=15, F=4, and 0-9 are exactly that.
                int[] ivalue = {8, 12, 2, 3, 15, 4, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

                //A Character array used to provide the Symbols used for Operators in our equations.
                char[] opert = {'@', '%', '*', '/', '+', '-', ')', '(', '#'};

                //A int array used to provide priority for the Operator's used in our formulas.
                int[] intvalp = {3, 2, 2, 2, 1, 1, 99, -99, -100};
            while(input.hasNextLine()){
                Test= input.next();

                //A new instance of GenericManagerStacks meant to hold Integers, our Operands.
                GenericManagerStacks<Integer> opnd = new GenericManagerStacks<Integer>();

                //A new instance of GenericManagerStacks meant to hold Operator Objects, our operators.
                GenericManagerStacks<Opertobj> oper = new GenericManagerStacks<Opertobj>();

                System.out.println("pushing Operator #with priority -100");

                //Our end character being added, the symbol we use to mark the end of an equation.
                Opertobj pnode1 = new Opertobj('#', -100);
                oper.pushnode(pnode1);
                int oprior, exvalue;

                //Character array's for the formulas we are parsing.

                char[] express = Test.toCharArray();

                //Loops through each read of the equation, evaluating each caracter, peeking at the top of its particular stack, and placing it in the correct place it will continue this action until a # is found.
                i = 0;
                while (express[i] != '#') {
                    System.out.println("Parsing " + express[i]);

                    if (((express[i] >= '0') && (express[i] <= '9')) || ((express[i] >= 'A') && (express[i] <= 'Z'))) {
                        System.out.println("This is an operand " + express[i]);

                        ivalu = findval(express[i], vart, ivalue, 15);
                        if (ivalu == -99) System.out.println("No value in table for" + express[i]);

                        System.out.println("We're pushing it on the operand stack " + ivalu);
                        opnd.pushnode(ivalu);
                    } else {
                        System.out.println("This is an operator " + express[i]);

                        if (express[i] == '(') {
                            System.out.println("Pushing on operator stack " + express[i]);
                            Opertobj pnodeo = new Opertobj(express[i], -99);
                            oper.pushnode(pnodeo);
                        } else if (express[i] == ')') {
                            while ((oper.peeknode()).operator != '(') {
                                popevalandpush(oper, opnd);
                            }
                            oper.popnode();
                        } else {
                            oprior = findval(express[i], opert, intvalp, 7);
                            System.out.println("Peeking at top of stack " + (oper.peeknode()).priority);

                            while (oprior <= (oper.peeknode()).priority) popevalandpush(oper, opnd);
                            System.out.println("pushing Operator " + express[i] + "with priority " + oprior);
                            Opertobj pnodeo = new Opertobj(express[i], oprior);
                            oper.pushnode(pnodeo);
                        }
                    }
                    i++;
                }
                while ((oper.peeknode()).operator != '#') {
                    popevalandpush(oper, opnd);
                }
                exvalue = opnd.popnode();
                System.out.println("the value for this expression is " + exvalue);

            }

        }
        catch (FileNotFoundException e) {
            System.err.println("File  was not found");
        }


    }

    //A method to check each operand and assign it a function.
    public static int IntEval(int oper1, char oper, int oper2) {
        int result = 0;

        switch (oper) {
            case '+':
                result = oper1 + oper2;

                return result;

            case '-':
                result = oper1 - oper2;
                System.out.println("***eval " + oper1 + oper + oper2 + "*result* " + result);
                return result;

            case '*':
                result = oper1 * oper2;
                System.out.println("***eval " + oper1 + oper + oper2 + "*result* " + result);
                return result;

            case '/':
                if (oper2 != 0) {
                    result = oper1 / oper2;

                    System.out.println("***eval " + oper1 + oper + oper2 + "*result* " + result);
                    return result;
                } else {
                    System.out.println("attempted divide but zero not allowed");
                    return -99;
                }
            case '@':
                if (oper2 >= 1) {
                    result = (int)Math.pow(oper1, oper2);
                    System.out.println("***eval " + oper1 + oper + oper2 + "*result* " + result);
                    return result;
                } else {
                    System.out.println("Attempted to raise to negative or zero power");
                    return 1;
                }
            case '%':
                result = oper1 % oper2;
                System.out.println("***eval " + oper1 + oper + oper2 + "*result* " + result);
                return result;

            default:
                System.out.println("bad operator " + oper);
                return -99;
        }
    }

    //Finds the value of each character and returns its value
    public static int findval(char x, char[] vtab, int[] valtb, int last) {
        int i, vreturn = -99;

        for (i = 0; i <= last; i++)
            if (vtab[i] == x) vreturn = valtb[i];
        System.out.println("Found this char: " + x + " value is: " + vreturn);
        return vreturn;
    }
    //Pops, evaluates, and Pushes the stacks as needed.
    public static void popevalandpush(GenericManagerStacks<Opertobj> x, GenericManagerStacks<Integer> y) {
        int a, b, c;
        char operandx;
        operandx = (x.popnode()).GetOpert();
        a = y.popnode();
        b = y.popnode();
        System.out.println("in popeval " + b + operandx + a);
        c = IntEval(b, operandx, a);
        y.pushnode(c);
        return;
    }
}

//The Generic Manager Stacks class
class GenericManagerStacks<T> {
    protected ArrayList<T> mystack;
    protected int number;

    //Constructor
    public GenericManagerStacks() {
        number = 0;

        mystack = new ArrayList<T>(100);
    }

    //Getter for Number
    public int getnumber() {
        return number;
    }

    //Pushes the node
    public int pushnode(T x) {
        System.out.println("in pushnode " + number + " x is " + x);

        mystack.add(number, x);
        number++;
        System.out.println("Leaving pushnode");
        return number;
    }

    // Pops the next node
    public T popnode() {
        T nodeval;

        nodeval = mystack.get(number - 1);
        mystack.remove(number - 1);
        number--;
        return nodeval;
    }

    //Peeks at the top of the stack
    public T peeknode() {
        T nodeval;

        nodeval = mystack.get(number - 1);
        return nodeval;
    }

    //Checks if the stack is empty
    boolean stackempty() {
        if (number == 0) return true;
        else return false;
    }

}

//The class that holds the operator objects and their priority
class Opertobj {
    protected char operator;
    protected int priority;

    //Constructor
    public Opertobj(char opert, int pri) {
        operator = opert;
        priority = pri;
    }

    //Getter for priority
    public int GetPrior() {
        return priority;
    }

    //Getter for Operator
    public char GetOpert() {
        return operator;
    }


}