Compiler class to read file and parse in Java

[Slynn Garrett]

Someone please help! I am trying to read a text file from a Translator class in java then I have another class to read it as instructions to do. I have some code but when I test my compiler it brings me back an empty ArrayDeque. I have also forgotten how to call the methods from the other class for instructions after it has found instructions. I am not wanting someone to code this all for me but I need someone to explain where I am going wrong. Here are my codes so far.

import java.io.*;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.*;
import java.util.Scanner;
import javax.swing.*;


public class Translator
{
  
  private String filename;
  public ArrayDeque<Instruction> getInstructionList (String filename)
  { 
    ArrayDeque<Instruction> instructions = new ArrayDeque<Instruction>(); 
    
    Scanner fileIn = null;
    String line;
    int count = 1;
    try
    {
      fileIn = new Scanner(new FileInputStream(filename));
    }
    catch (IOException e)
    {
      JOptionPane.showMessageDialog(null, "Data error: " + e.getMessage());
      return null;
    } 
    
    while(fileIn.hasNextLine())
    {
      count++;
      
      String s = fileIn.nextLine();
      
      
      System.out.println(s);
    }
    fileIn.close();
    
    return instructions;
  }
  
  public static void main (String[]args)
  {
    Translator translator=new Translator();
    ArrayDeque<Instruction> instruction = translator.getInstructionList("1.txt");
    
  }
}

I have not been able to figure out the parsing of this file.

import java.io.*;
import java.util.*;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;


public class Instruction
{

  public static final int PUSH = 0;
  public static final int INPUT = 13;
  public static final int NOP = 99;
  public static final int DUP2=0;
  public static final int ADD=0;
  public static final int STORE_PERIMETER=0;
  public static final int PUSH2=0;
  public static final int RECALL_WIDTH=0;
  public static final int RECALL_PERIMETER=0;
  public static final int END=0;
  public static final int RECALL=0;
  public static final int INPUT_LENGTH=0;
  public static final int INPUT_WIDTH=0;
  public static final int POP=0;
  public static final int MULT=0;
  private int opCode;
  private String name;
  private double value;

  public Instruction(int opCode)
  {
    this.opCode=opCode;
    name="";
    value=0.0;

  }
  public Instruction (int opCode, String name)
  {
    this.opCode=opCode;
    this.name=name;
    value=0.0;
  }
  public Instruction (int opCode, double value)
  {
    this.opCode=opCode;
    name="";
    this.value=value;
  }
  public int getopCode()
  {

    return opCode;
  }
  public static int tanslateName (String name)
  {
    if (name.equalsIgnoreCase("push"))
      return PUSH;
    if(name.equalsIgnoreCase("input length"))
      return INPUT_LENGTH;
    if(name.equalsIgnoreCase("input width"))
      return INPUT;
    if(name.equalsIgnoreCase("recall length"))
      return RECALL;
    if(name.equalsIgnoreCase("recall width"))
      return RECALL_WIDTH;
    if(name.equalsIgnoreCase("dup2"))
      return DUP2;
    if(name.equalsIgnoreCase("add"))
      return ADD;
    if(name.equalsIgnoreCase("push 2"))
      return PUSH2;
    if(name.equalsIgnoreCase("mult"))
      return MULT;
    if(name.equalsIgnoreCase("store perimeter"))
      return STORE_PERIMETER;
    if(name.equalsIgnoreCase("pop"))
      return POP;
    if(name.equalsIgnoreCase("recall perimeter"))
      return RECALL_PERIMETER;
    if(name.equalsIgnoreCase("end"))
      return END;
    else
      return NOP;
  }
//   public static String tanslatename (int name)
//  {
//    switch (name)
//    {
//      case 1: name="push";
//        return PUSH;
//      
//      default:
//        return NOP;
//    }
//  }

}

My text file is in this format:
input length
input width
recall length
recall width
dup2
add
push 2
mult
store perimeter
mult
pop
recall perimeter
end

[Stephan van Hulst]

Hi Sherry, welcome to CodeRanch!

You never actually add anything to your deque? Shouldn't you call translateName() somewhere in your getInstructionList() method?

A few more remarks:

Use packages. Putting your classes in the default package will almost always lead to problems

Make classes final unless you have plans to extend them. You should almost never have to make your classes extensible.

Don't make classes and methods public unless you intend to expose your API. Classes only have to be public if you use them outside of their package.

If a method doesn't require access to instance fields, you can make it static.

If a class consists only of static methods, you can make it a utility class by providing only a private constructor with an empty implementation.

Don't use String where you can use strong types instead. Use Path to indicate file paths.

It looks like you have an unused field filename in your Translator class, that is being hidden by a parameter in getInstructionList(). Get rid of it.

Declaring your method return types and variable types as ArrayDeque is too strong. If you need a queue, use the Queue interface. If you need a stack, use the Deque interface.

Don't pass generic type arguments twice. You can use the diamond operator instead.

Avoid translating exceptions to return values. Just propagate them. If getInstructionList() doesn't have an appropriate way to deal with an IOException (after all, it shouldn't know whether the application has a GUI), just declare that it throws an IOException.

Use try-with-resources to read from files.

Swing code (like showing a message dialog) should be run on the EDT. You can do this using SwingUtilities.invokeLater().

Don't use integers for typed constants. Use enums instead. You can make OpCode an enum and associate Instructions with OpCodes.

Here's some cleaned up code:

package com.example.instruct;

import java.io.*;
import java.nio.file.*;
import java.util.*;
import java.util.stream.*;

import javax.swing.*;

final class Translator {

  // This is a utility class.
  private Translator() {}
  
  private static Instruction translateLineToInstruction(String line) {
    // TODO
  }

  static Queue<Instruction> readInstructions(Path instructionFilePath) throws IOException {
    try (
      BufferedReader input = Files.newBufferedReader(instructionFilePath)
    ) {
      return input.lines()
        .map(Translator::translateLineToInstruction)
        .collect(Collectors.toCollection(ArrayDeque::new));
    }
  }

  public static void main(String... args) {
    try {
      Path path = Paths.get("1.txt");
      Queue<Instruction> instructions = Translator.readInstructions(path);
    }
    
    catch (IOException ex) {
      SwingUtilities.invokeLater(() -> {
        JOptionPane.showMessageDialog(null, "An I/O exception occurred: " + ex.getMessage());
      });
    }
  }
}

[Slynn Garrett]

I am not exactly sure why but my teacher insisted on using ArrayDeque. As for where to call my translateName I can not find anywhere it will work. I thought it would be in the while loop but doesn't help.

[Stephan van Hulst]

Why? What happened? Show us the code including where you think the call to translateName() should be, and then tell us what isn't working.

[Slynn Garrett]

Thanks everyone I got it working wonderfully now.

[Campbell Ritchie]

Sherry Kaiser wrote:I am not exactly sure why but my teacher insisted on using ArrayDeque. . . .

That does not mean you declare it as such
Queue<Foo> queue = new ArrayDeque<>();
If you are using array deque as a stack, then you would have to declare it as such. There is a serious problem about stacks in Java® because of the java.util.Stack class which is a triumph of bad design, and there is no stack interface. Have you read about Array Deque?

[Stephan van Hulst]

I'm assuming ArrayDeque is used because the Queue interface is required. After all, you add instructions to the end of a pipeline, and you remove them from the front.

[Campbell Ritchie]

That sounds right; I did see the word Queue in earlier posts. ArrayDeque is the fastest‑performing queue implementation I know about. It can also be used as a stack.