InfixParser_E

package csc143.data_structures;

import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
import java.lang.*;

/**
 * @author Vita Wiebe
 * @version PA9: Stack/Queue Use, Parser
 * This program takes a mathematical expression, user-input in
 * the standard, infix notation, and produces an equivalent
 * expression written in postfix notation.
 */
public class InfixParser implements ParserInterface  {

   // Fields

   // String s, the input string from user.
   // Pre-condition: non-empty.
   private String s;
   // A String to hold a temporary value.
   private String temp;

   // Our data structures, for handling the input, reordering,
   // and eventual output of the postfix form of input.
   private UnboundedArrayQueue outputQ;

   // For comparison when parsing the input string.
   public final String operators = "+-/*%";
   public final String numbers = "0123456789";

   /**
    * Our class constructor.
    */
   public InfixParser() {
   }

   /**
    * This method parses the input string into individual tokens.
    * <p>
    * For the minimal version of the assignment, this means breaking
    * the input string into single-character tokens, discarding all
    * white space.
    * For the standard version of the assignment, this entails
    * breaking the input string into contiguous "runs" of alphanumeric
    * characters (identifiers and integers) and punctuation (operators).
    * <p>
    * Negative numbers are not handled by this tokenizer.
    *
    * @param input The input string.
    * @return A queue object containing the individual tokens.
    */
   public UnboundedArrayQueue tokenizeInput(String input) throws
      IllegalArgumentException, NullPointerException {

      // Take input string, split into separate tokens, put into UnboundedQueue
      this.s = input;
      String[] sChar = s.split("");
      UnboundedArrayQueue inputQ = new UnboundedArrayQueue();

      // Iterate thru sChar, combine each token into one token if
      // consecutive elements are numerals (done to allow for numbers
      // outside of 0-9 range).
      for(int i = 0; i < sChar.length; i++) {
         String tempString = "";
         if(numbers.contains(sChar[i])) {
            while(i < sChar.length && numbers.contains(sChar[i])){
               tempString += sChar[i];
               ++i;
            }
            --i;
            inputQ.add(tempString);
         }else if(operators.contains(sChar[i])) {
            inputQ.add(sChar[i]);
         }
      }
      return inputQ;
   }

   /**
    * This method converts a stream of tokens representing a
    * well-formed arithmetic expression from infix notation to
    * postfix notation.
    * <p>
    * For the minimal and standard versions of the assignment,
    * this algorithm does not have handle the left-to-right
    * associativity of the additive and multiplicative operators.
    * This is avoided by taking advantange of the associative
    * property of addition and multiplication.
    * The challenge version of the assignment includes the left-
    * to-right associativity, and therefore can also support the
    * subtraction and division operators.
    * <p>
    * This method does not have to detect malformed input streams.
    *
    * @param input The input stream of tokens, the expression in
    * infix notation.
    * @return The output stream of tokens, the expression in postfix
    * notation.
    */
   public UnboundedQueue<String> convertInfixToPostfix(UnboundedQueue<String> input) {

      UnboundedArrayStack<String> processStack = new UnboundedArrayStack(input.size());
      UnboundedArrayQueue<String> outputQ = new UnboundedArrayQueue(input.size());

      // If the input is empty, output should be empty.
      if(!input.hasContents()){
         return new UnboundedArrayQueue();
      } else {
         // Overall, this section parses the input queue, then puts
         // the reodered elements into the stack.
         String ops = "";
         try {
            // Iterate over inputQ. Add numbers to processStack.
            while(input.hasContents()) {
               String token = input.remove();
               if (!operators.contains(token)) {
                  outputQ.add(token);
               } else if (token.equals('(')) {
                  processStack.push(token);
               // Suss out operators, compare their order of operations
               } else if (operators.contains(token)) {
                  token.compareTo((String)processStack.peek());
                  if(token.compareTo((String)processStack.peek()) == -1) {
                     while(token.compareTo((String)processStack.peek()) == -1) {
                        outputQ.add(processStack.pop());
                     }
                  // If operator is > or == to precedence:
                  // put on the stack.
                  } else {
                     processStack.push(token);
                  }
               } else if (token.equals(')')) {
                     do {
                        // Temp variable to store value
                        // so pop() needn't be called more than once.
                        temp = (String)processStack.pop();
                     }   while(!temp.equals('('));
                           outputQ.add(temp);
                     if(processStack.peek().equals('(')) {
                        outputQ.add(processStack.pop());
                     }
               }
            }
         } catch(NullPointerException n) {
            System.err.println(n.getMessage());
         }
      }

      // Add operators from the processStack into the outputQ.
      while(processStack.hasContents()){
         outputQ.add(processStack.pop());
      }
      return outputQ;
   }

   /**
    * This method formats the output stream of tokens into a
    * single string for output. The individual tokens in the
    * output stream are separated by exactly one space between
    * adjacent tokens. There is no opening or closing space in
    * the output String.
    *
    * @param output The output stream of tokens.
    * @return The formatted output string.
    */
   public String formatOutput(UnboundedQueue<String> output){
      String tokenStream = "";
      if(output == null) {
         throw new NullPointerException("This left me feeling a little empty...");
      } else {
         tokenStream = output.remove();
         while(output.hasContents()) {
            tokenStream += " " + output.remove();
         }
      }
      return tokenStream;
   }

   // Main application method from which the program is run.
   public static void main(String[] args) {
      InfixParser zoop = new InfixParser();
      UnboundedArrayQueue test = zoop.tokenizeInput("3 2 + 4 * 2");
      System.out.println(test);
      // The following two calls produce "null" to console output.
      // I am still attempting to figure out why output is null.
      System.out.println(zoop.convertInfixToPostfix(test));
      //System.out.println(zoop.formatOutput(zoop.convertInfixToPostfix(test)));

   }
}