title: How to read line by line using char array (or byte array) in stack problem
body: <p>This is a follow up question on:
  <a href="https://stackoverflow.com/questions/60445253/how-to-print-contents-in-stack-to-a-file">How to print contents in stack to a file</a></p>
  
  <p>I just realized the assignment restricts the use of String functions. I haven't been abel to read line by line using char array. Instead of the result I could get intiatially:</p>
  
  <pre><code>            --- EVALUATION BEGINS ---
  EXAMPLE 1: 
  Postfix Expression: AB+C-
  Instructions in the Register:
  LD A
  AD B
  ST TEMP1
  LD TEMP1
  SB C
  ST TEMP2
  
  
  EXAMPLE 2: 
  Postfix Expression: ABC+-
  Instructions in the Register:
  LD B
  AD C
  ST TEMP1
  LD A
  SB TEMP1
  ST TEMP2
  
  
  EXAMPLE 3: 
  Postfix Expression: AB-C+DEF-+$
  Instructions in the Register:
  LD A
  SB B
  ST TEMP1
  LD TEMP1
  AD C
  ST TEMP2
  LD E
  SB F
  ST TEMP3
  LD D
  AD TEMP3
  ST TEMP4
  LD TEMP2
  EX TEMP4
  ST TEMP5
  
  
  EXAMPLE 4: 
  Postfix Expression: ABCDE-+$*EF*-
  Instructions in the Register:
  LD D
  SB E
  ST TEMP1
  LD C
  AD TEMP1
  ST TEMP2
  LD B
  EX TEMP2
  ST TEMP3
  LD A
  ML TEMP3
  ST TEMP4
  LD E
  ML F
  ST TEMP5
  LD TEMP4
  SB TEMP5
  ST TEMP6
  
  
  EXAMPLE 5: 
  Postfix Expression: ABC+*CBA-+*
  Instructions in the Register:
  LD B
  AD C
  ST TEMP1
  LD A
  ML TEMP1
  ST TEMP2
  LD B
  SB A
  ST TEMP3
  LD C
  AD TEMP3
  ST TEMP4
  LD TEMP2
  ML TEMP4
  ST TEMP5
  
  
  EXAMPLE 6: 
  Postfix Expression: ABC+/CBA*+
  Instructions in the Register:
  LD B
  AD C
  ST TEMP1
  LD A
  DV TEMP1
  ST TEMP2
  LD B
  ML A
  ST TEMP3
  LD C
  AD TEMP3
  ST TEMP4
  
  
  EXAMPLE 7: 
  Postfix Expression: AB-*CBA+-*
  Instructions in the Register:
  LD A
  SB B
  ST TEMP1
  The expression is invald. Exiting program now...
  StackException: EMPTY STACK ON ARG2
  
  
  EXAMPLE 8: 
  Postfix Expression: ABC-/BA-+/
  Instructions in the Register:
  LD B
  SB C
  ST TEMP1
  LD A
  DV TEMP1
  ST TEMP2
  LD B
  SB A
  ST TEMP3
  LD TEMP2
  AD TEMP3
  ST TEMP4
  The expression is invald. Exiting program now...
  StackException: EMPTY STACK ON ARG2
  
  
  EXAMPLE 9: 
  Postfix Expression: ABC+$CBA-+*
  Instructions in the Register:
  LD B
  AD C
  ST TEMP1
  LD A
  EX TEMP1
  ST TEMP2
  LD B
  SB A
  ST TEMP3
  LD C
  AD TEMP3
  ST TEMP4
  LD TEMP2
  ML TEMP4
  ST TEMP5
  
  
  EXAMPLE 10: 
  Postfix Expression: AB0+/CBA+-/
  Instructions in the Register:
  The expression is invald. Exiting program now...
  StackException: Unidentified operator or operand encoutered: 0 at position: 2
  
  
  EXAMPLE 11: 
  Postfix Expression: ABC*+DE-/
  Instructions in the Register:
  LD B
  ML C
  ST TEMP1
  LD A
  AD TEMP1
  ST TEMP2
  LD D
  SB E
  ST TEMP3
  LD TEMP2
  DV TEMP3
  ST TEMP4
  
  
  EXAMPLE 12: 
  Postfix Expression: AB#CD@EF
  Instructions in the Register:
  The expression is invald. Exiting program now...
  StackException: Unidentified operator or operand encoutered: # at position: 2
  
  
  EXAMPLE 13: 
  Postfix Expression: AB*CD-/E
  Instructions in the Register:
  LD A
  ML B
  ST TEMP1
  LD C
  SB D
  ST TEMP2
  LD TEMP1
  DV TEMP2
  ST TEMP3
  The expression is invald. Exiting program now...
  StackException: Leftover variables after evaluation.
  
  
  EXAMPLE 14: 
  Postfix Expression: 12*34-+5$
  Instructions in the Register:
  The expression is invald. Exiting program now...
  StackException: Unidentified operator or operand encoutered: 1 at position: 0
  
  
  EXAMPLE 15: 
  Postfix Expression: thisislab1
  Instructions in the Register:
  The expression is invald. Exiting program now...
  StackException: Unidentified operator or operand encoutered: t at position: 0
  
              --- EVALUATION COMLETE ---
  </code></pre>
  
  <p>Now, after rewriting the code in the PostFixEvalNew class hoping to read the input file line by line using char array, I am getting this instead:</p>
  
  <pre><code>            --- EVALUATION BEGINS ---
  EXAMPLE 1: 
  Postfix Expression: AB+C-
  ABC+-
  AB-C+DEF-+$
  ABC
  Instructions in the Register:
  LD A
  AD B
  ST TEMP1
  LD TEMP1
  SB C
  ST TEMP2
  LD B
  AD C
  ST TEMP3
  LD A
  SB TEMP3
  ST TEMP4
  LD A
  SB B
  ST TEMP5
  LD TEMP5
  AD C
  ST TEMP6
  LD E
  SB F
  ST TEMP7
  LD D
  AD TEMP7
  ST TEMP8
  LD TEMP6
  EX TEMP8
  ST TEMP9
  The expression is invald. Exiting program now...
  StackException: Leftover variables after evaluation.
  
  
  EXAMPLE 2: 
  Postfix Expression: AB+C-
  ABC+-
  AB-C+DEF-+$
  ABC
  Instructions in the Register:
  LD A
  AD B
  ST TEMP1
  LD TEMP1
  SB C
  ST TEMP2
  LD B
  AD C
  ST TEMP3
  LD A
  SB TEMP3
  ST TEMP4
  LD A
  SB B
  ST TEMP5
  LD TEMP5
  AD C
  ST TEMP6
  LD E
  SB F
  ST TEMP7
  LD D
  AD TEMP7
  ST TEMP8
  LD TEMP6
  EX TEMP8
  ST TEMP9
  The expression is invald. Exiting program now...
  StackException: Leftover variables after evaluation.
  
  
  EXAMPLE 3: 
  Postfix Expression: AB+C-
  ABC+-
  AB-C+DEF-+$
  ABC
  Instructions in the Register:
  LD A
  AD B
  ST TEMP1
  LD TEMP1
  SB C
  ST TEMP2
  LD B
  AD C
  ST TEMP3
  LD A
  SB TEMP3
  ST TEMP4
  LD A
  SB B
  ST TEMP5
  LD TEMP5
  AD C
  ST TEMP6
  LD E
  SB F
  ST TEMP7
  LD D
  AD TEMP7
  ST TEMP8
  LD TEMP6
  EX TEMP8
  ST TEMP9
  The expression is invald. Exiting program now...
  StackException: Leftover variables after evaluation.
  
  
  EXAMPLE 4: 
  Postfix Expression: AB+C-
  ABC+-
  AB-C+DEF-+$
  ABC
  Instructions in the Register:
  LD A
  AD B
  ST TEMP1
  LD TEMP1
  SB C
  ST TEMP2
  LD B
  AD C
  ST TEMP3
  LD A
  SB TEMP3
  ST TEMP4
  LD A
  SB B
  ST TEMP5
  LD TEMP5
  AD C
  ST TEMP6
  LD E
  SB F
  ST TEMP7
  LD D
  AD TEMP7
  ST TEMP8
  LD TEMP6
  EX TEMP8
  ST TEMP9
  The expression is invald. Exiting program now...
  StackException: Leftover variables after evaluation.
  
  
  EXAMPLE 5: 
  Postfix Expression: AB+C-
  ABC+-
  AB-C+DEF-+$
  ABC
  Instructions in the Register:
  LD A
  AD B
  ST TEMP1
  LD TEMP1
  SB C
  ST TEMP2
  LD B
  AD C
  ST TEMP3
  LD A
  SB TEMP3
  ST TEMP4
  LD A
  SB B
  ST TEMP5
  LD TEMP5
  AD C
  ST TEMP6
  LD E
  SB F
  ST TEMP7
  LD D
  AD TEMP7
  ST TEMP8
  LD TEMP6
  EX TEMP8
  ST TEMP9
  The expression is invald. Exiting program now...
  StackException: Leftover variables after evaluation.
  
  
  EXAMPLE 6: 
  Postfix Expression: AB+C-
  ABC+-
  AB-C+DEF-+$
  ABC
  Instructions in the Register:
  LD A
  AD B
  ST TEMP1
  LD TEMP1
  SB C
  ST TEMP2
  LD B
  AD C
  ST TEMP3
  LD A
  SB TEMP3
  ST TEMP4
  LD A
  SB B
  ST TEMP5
  LD TEMP5
  AD C
  ST TEMP6
  LD E
  SB F
  ST TEMP7
  LD D
  AD TEMP7
  ST TEMP8
  LD TEMP6
  EX TEMP8
  ST TEMP9
  The expression is invald. Exiting program now...
  StackException: Leftover variables after evaluation.
  
  
  EXAMPLE 7: 
  Postfix Expression: AB+C-
  ABC+-
  AB-C+DEF-+$
  ABC
  Instructions in the Register:
  LD A
  AD B
  ST TEMP1
  LD TEMP1
  SB C
  ST TEMP2
  LD B
  AD C
  ST TEMP3
  LD A
  SB TEMP3
  ST TEMP4
  LD A
  SB B
  ST TEMP5
  LD TEMP5
  AD C
  ST TEMP6
  LD E
  SB F
  ST TEMP7
  LD D
  AD TEMP7
  ST TEMP8
  LD TEMP6
  EX TEMP8
  ST TEMP9
  The expression is invald. Exiting program now...
  StackException: Leftover variables after evaluation.
  
              --- EVALUATION COMLETE ---
  </code></pre>
  
  <p>Not entirely sure what I did wrong here. Any help is very much appreciated!!</p>
  
  <pre><code>public class StackException extends Exception {
      public StackException(String message) {
          super(message);
      }
  }
  
  public class Stack {
      private final int stackSize = 100;
      private String[] stackArray;
      private int stackTop;    //empty stack
  
      Stack() {
          stackArray = new String[stackSize];
          stackTop = -1;
      }
      public boolean isEmpty() {
          if(stackTop == -1)
              return true;
          else
              return false;
      }
  
      public void push(String input) throws StackException {
          if(stackTop == stackSize -1) {
              throw new StackException("Stack Overflow. Exiting program now...");
          }
  
          stackArray[++stackTop] = input;
      }
  
      public int size() {
  
          return stackTop + 1;
      }
  
      public String peek() throws StackException {
  
          if (isEmpty()) {
              throw new StackException("Stack Underflow. Exiting program now...");
          }
  
          return stackArray[stackTop];
      }
  
      public String pop() throws StackException {
          if (isEmpty()) {
              throw new StackException("Stack Underflow. Exiting program now...");
          }
  
          return stackArray[stackTop--];
      }
  
  }
  import java.io.*;
  import java.util.*;
  
  public class PostFixEvalNew {
      public static void main(String[]args) throws StackException, IOException {
          File fin = new File(args[0]);
          boolean fileExist = fin.exists();
  
          File fout = new File(args[1]);
  
          PrintWriter pw = new PrintWriter(new FileWriter(fout));
          if(fileExist == true) {
              pw.println("\n" + "\t\t\t\t" + "--- EVALUATION BEGINS ---");
              parseFromFile(args[0], pw);
          } 
          else {
              translate(args[0], pw);
          }    
          pw.println("\t\t\t\t" + "--- EVALUATION COMLETE ---" + "\n");
          pw.close();
      }
  
      public static void parseFromFile(String input, PrintWriter pw) {
          String line;
          int lineCounter = 0;
          char[] content = new char[(int)input.length()];
          int c = 0;
  
          try {
              BufferedReader br = new BufferedReader(new FileReader(input));
  
              try {
                  // while ((line = br.readLine()) != null) { 
                  while((c = br.read(content)) != -1) {
                      for(int i = 0; i &lt; c; i++) {
                          // br.read(content);
                          line = new String(content);
                          lineCounter++;
                          pw.println("EXAMPLE " + lineCounter + ": ");
                          pw.println("Postfix Expression: " + line);
  
                          try {
                              translate(line, pw);
                          } catch (Exception e){
                              pw.println("The expression is invald. Exiting program now...");
                              pw.println(e);
                          }
  
                          pw.println("\n");
                      }
  
                      br.close();
                  }
              } 
              catch (java.io.IOException e) {
                  pw.println("End of File!");
              }
  
          } 
          catch (java.io.FileNotFoundException e) {
              pw.println("File: " + input + " not found!");
              return;
          }
      }
  
      private static boolean isOperator(String operator) {
          switch(operator) {
              case "+":
              case "-":
              case "*":
              case "/":
              case "$":
                  return true;
              default:
                  return false;
          }
      }
  
      private static String instruction(String oper) {
          switch(oper) {
              case "+":
                  return "AD";
              case "-":
                  return "SB";
              case "*":
                  return "ML";
              case "/":
                  return "DV";
              case "$":
                  return "EX";
              default:
                  return "N/A";
          }
      }
  
      public static void translate(String expression, PrintWriter pw)
              throws StackException {
  
          Stack variables = new Stack();
          int tempNum = 1;
          String arg1;
          String arg2;
          String command;
  
          pw.println("Instructions in the Register:");
  
          if (expression.trim().length() == 0) {
              throw new StackException("EMPTY STACK");
          }
  
  
          for (int i=0; i&lt;expression.length(); i++){
              //if operator, pop arguments and evaluate
              if (isOperator(expression.substring(i, i+1))){
                  if (variables.isEmpty()) {
                      throw new StackException("EMPTY STACK");
                  }
  
                  command = instruction(expression.substring(i, i+1));
  
                  try {
                      arg1 = variables.pop();
                  } catch (StackException e) {
                      throw new StackException("EMPTY STACK ON ARG1");
                  }
  
                  try {
                      arg2 = variables.pop();
                  } catch (StackException e) {
                      throw new StackException("EMPTY STACK ON ARG2");
                  }
  
                  variables.push("TEMP" + tempNum);
                  pw.println("LD " + arg2);
                  pw.println(command + " " + arg1);
                  pw.println("ST " + "TEMP" + tempNum);
                  tempNum++;
  
  
              } else if (Character.isLetter(expression.charAt(i))) {
                  //if variable, push onto stack
                  variables.push(expression.substring(i, i+1));
              } else if (Character.isWhitespace(expression.charAt(i))) {
                  //Ignore whitespace
                  continue;
              } else {
                  throw new StackException("Unidentified operator or operand encoutered: " +
                          expression.charAt(i) +
                          " at position: " + i);
              }
          }
  
          if (variables.isEmpty() == false) {
              while (variables.isEmpty() == false) {
                  if (variables.pop().startsWith("TEMP") == false){
                      throw new StackException("Leftover variables after evaluation.");
                  }
              }
          }
      }
  }
  </code></pre>