Interpretador

   import jnpout32.*;
   import java.util.ArrayList;
   import java.util.regex.Pattern;
   import java.io.*;
   import java.lang.*;

   public class Interpretador
   {
      private ArrayList<Byte> varNum    = new ArrayList<>();
      private ArrayList<String> varNome = new ArrayList<>();
      private RandomAccessFile arquivo;

      Interpretador()
      {

      }

   /**
   * processa todos os simbolos lidos no arquivo
   */
      private boolean processSimbol()
      {
         boolean stop = false;
         String symb = "";
         char tmp;
         try
         {
            do
            {
               tmp = (char)arquivo.readByte();
               if(tmp != '\n' && tmp != '.')
               {
                  symb += tmp;
               }
            }while(tmp != '(' && tmp != '=' && tmp != '\n' && tmp != '.');

         //se simbolo lido == vazio, chegou fim arquivo
            if(!symb.equals(""))
            {
            // ** checa palavras reservadas **
               switch(symb)
               {
                  case "NAND(":
                     NAND();
                     break;
                  case "NOT(":
                     NOT();
                     break;
                  case "OR(":
                     OR();
                     break;
                  case "SUM(":
                     SUM();
                     break;
               }

            //** verifica se é variavel **
               if(symb.charAt(symb.length()-1) == '=')
               {
               //remove o sinal '='
                  symb = symb.substring(0,symb.length()-1);
                  String symbTemp = "";
                  byte numeroVar = 0;

               //obtem o numero da variavel
                  do
                  {
                     tmp = (char)arquivo.readByte();
                     if(tmp != '\n' && tmp != '.' && tmp != ';')
                     {
                        symbTemp += tmp;
                     }
                  }while(tmp != '\n' && tmp != '.');

                  try
                  {
                     numeroVar = (byte)Integer.parseInt(symbTemp);

                     if(!chgVar(symb,numeroVar))
                     {
                        createVar(symb, numeroVar);
                     }
                  }
                     catch(NumberFormatException nfe)
                     {
                        System.out.println("ErRor: So entendo numeros, tente novamente mais tarde");
                     }
               }
            }
            else
            {
               stop = true;
            }
         }
            catch(IOException ioe)
            {
               System.out.println("ErRor: Arquivo de entrada invalido, corrija-o");
            }
         return stop;
      }

   //=============================================================
   //=============== Manipulacao das variaveis ===================
   //=============================================================

      private byte getVar(String nome)
      {
         byte ret = 0;

         for(int i=0; i<varNome.size(); i++)
         {
            if( nome.equals(varNome.get(i)) )
            {
               ret = varNum.get(i);
               i=varNum.size();
            }
         }
         return ret;
      }

      private boolean varExists(String nome)
      {
         boolean exist = false;

         for(int i=0; i<varNome.size(); i++)
         {
            if( nome.equals(varNome.get(i)) )
            {
               exist = true;
               i=varNome.size();
            }
         }
         return exist;
      }

      private boolean chgVar(String nome, byte n)
      {
         boolean success = false;
         for(int i=0; i<varNome.size(); i++)
         {
            if( nome.equals(varNome.get(i)) )
            {
               varNum.set(i, (byte)n );
               success = true;
               System.out.println("Variavel alterada: |"+nome+"="+n+"|");
               i=varNome.size();
            }
         }
         return success;
      }

      private void createVar(String nome, byte n)
      {
         varNum.add( (byte)n );
         varNome.add( nome );
         System.out.println("Variavel criada: |"+nome+"="+n+"|");
      }

      private void statusVar()
      {
         if(varNum.size() > 0)
         {
            System.out.print("\nVariaveis: ");
            for(int i=0; i<varNum.size(); i++)
            {
               System.out.print(varNome.get(i) + "=" + varNum.get(i) + " // ");
            }
            System.out.print("\n");
         }
      }

   //=============================================================
   //=========== Entrada/Saida ===================================
   //=============================================================

      private void pause()
      {
         BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

         try
         {
            System.out.print("Enviar para porta [ENTER]");
            in.read();
         }
            catch(IOException ioe)
            {
               System.out.println("Erro de E/S!");
            }
      }

      private void do_read()
      {
         pPort lpt = new pPort();
         short dado = (short) lpt.input((short)(0x378));
         System.out.println("Lendo da porta: " + Integer.toString(dado));
      }

      private void do_write(short dado)
      {
         pPort lpt = new pPort();
         System.out.println("Escrevendo na porta: "+  Integer.toString(dado));
         lpt.output((short)(0x378),dado);
      }

   //=============================================================
   //=========== Obtencao dos argumentos  ========================
   //=============================================================

      private String getArgs()
      {
         String args = "";
         char tmp = ' ';

         try
         {
            do
            {
               do
               {
                  tmp = (char)arquivo.readByte();
                  if( (tmp >= 'a' && tmp <= 'z') || (tmp >= 'A' && tmp <= 'z') )
                  {
                     args += tmp;
                  }
               }while((tmp >= 'a' && tmp <= 'z') || (tmp >= 'A' && tmp <= 'z'));

               if(tmp == ',' || tmp == ')') args = args + "\n";
            }while(tmp != '\n');
         }
            catch(IOException ioe)
            {
               System.out.println("Parsing ErRor, codigo fonte invalido!:"+ioe.getStackTrace());
            }

         return args;
      }

   //=============================================================
   //=========== Manipulacao individual da cada funcao ===========
   //=============================================================

      private void NAND()
      {
      //prossegue com a leitura da linha, apos o (
         char tmp = ' ';
         String[] args = getArgs().split(Pattern.quote("\n"));

         if(!varExists(args[0]) || !varExists(args[1]))
         {
            System.out.println("ErRor: Variavel(is) nao existe!, impossivel realizar operacao NAND");
         }
         else
         {
         //preparacao do numero para envio na porta
            byte a,b,porta;

            porta = 0;
            a = getVar(args[0]);
            b = getVar(args[1]);

            a <<= 2;
            b <<= 3;

            porta = (byte)(a | porta);
            porta = (byte)(b | porta);

            System.out.print("============== Porta NAND ==============");
            statusVar();
            System.out.println("porta="+porta);

            pause();
            do_write((short)porta);

            System.out.print("========================================\n");
         }
      }

      private void NOT()
      {
      //prossegue com a leitura da linha, apos o (
         char tmp = ' ';
         String[] args = getArgs().split(Pattern.quote("\n"));

         if(!varExists(args[0]))
         {
            System.out.println("ErRor: Variavel nao existe!, impossivel realizar operacao NOT");
         }
         else
         {
         //preparacao do numero para envio na porta
            byte a,b,porta;

            porta = 2;
            a = getVar(args[0]);

            a <<= 2;

            porta = (byte)(a | porta);

            System.out.print("============== Porta NOT ===============");
            statusVar();
            System.out.println("porta="+porta);

            pause();
            do_write((short)porta);

            System.out.print("========================================\n");
         }
      }

      private void OR()
      {
      //prossegue com a leitura da linha, apos o (
         char tmp = ' ';
         String[] args = getArgs().split(Pattern.quote("\n"));

         if(!varExists(args[0]) || !varExists(args[1]))
         {
            System.out.println("ErRor: Variavel(is) nao existe!, impossivel realizar operacao OR");
         }
         else
         {
         //preparacao do numero para envio na porta
            byte a,b,porta;

            porta = 01;
            a = getVar(args[0]);
            b = getVar(args[1]);

            a <<= 2;
            b <<= 3;

            porta = (byte)(a | porta);
            porta = (byte)(b | porta);

            System.out.print("=============== Porta OR ===============");
            statusVar();
            System.out.println("porta="+porta);

            pause();
            do_write((short)porta);

            System.out.print("========================================\n");
         }
      }

      private void SUM()
      {
      //prossegue com a leitura da linha, apos o (
         char tmp = ' ';
         String[] args = getArgs().split(Pattern.quote("\n"));

         if(!varExists(args[0]) || !varExists(args[1]))
         {
            System.out.println("ErRor: Variavel(is) nao existe!, impossivel realizar operacao SUM");
         }
         else
         {
         //preparacao do numero para envio na porta
            byte a,b,porta;

            porta = 3;
            a = getVar(args[0]);
            b = getVar(args[1]);

            a <<= 2;
            b <<= 3;

            porta = (byte)(a | porta);
            porta = (byte)(b | porta);

            System.out.print("============== Porta SUM ===============");
            statusVar();
            System.out.println("porta="+porta);

            pause();
            do_write((short)porta);

            System.out.print("========================================\n");
         }
      }

      public void StepByStep(String fileName)
      {
         boolean stop = false;

         try
         {
            arquivo = new RandomAccessFile(new File(fileName), "r");
         }
            catch(FileNotFoundException fnfe)
            {
               System.out.println("Error: Arquivo nao encontrado!");
            }

         do
         {
            stop = processSimbol();
         }while(!stop);

      }
   }