Question

NEED THIS SOON.

Recursive Descent Parsing

Consider the following BNF grammar:

A -> I = E
E -> P O P | P
O -> + | - | * | / | **
P -> I | L | UI | UL | (E)
U -> + | - | !
I -> C | CI
C -> a | b | ... | y | z
L -> D | DL
D -> 0 | 1 | ... | 8 | 9
        

Using the technique described in class implement a recursive descent parser that recognizes strings in this language. Input should be from a file called input.txt and output should be to a file called output.txt. An example session might look like this (these strings are not necessarily in the language):

The string "a=a+b-c*d" is in the language.
The string "a=a//b++c" is not in the language.
        

You must implement the project in JAVA. Implementations that do not include a solution in both languages will, at best, receive half credit. To simplify things you will not have to handle whitespace when parsing the string, i.e. " " and similiar are illegal characters in this language. All strings should read from a file called "input.txt" and written to a file called "output.txt".

BOTH CODE NEEDS TO BE CORRECT AND NEEDS TO ACCEPT AN INPUT FILE AND NEED AN OUTPUT FILE. ONLY NEED JAVA CODE

ALSO PLEASE TYPE IT OUT.

Answer 1

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class RecursiveDescent
{
   static int ptr;
   static char[] input;
   public static void main(String[] args)
   {
       String str="";
       BufferedReader br = null;
       FileReader fr = null;
       try {

           fr = new FileReader("D:\\New folder\\string.txt");
           br = new BufferedReader(fr);
           br = new BufferedReader(new FileReader("D:\\New folder\\string.txt"));
           str= br.readLine();
           System.out.println("The Given string is"+str);
       }
       catch (IOException e)
       {
           e.printStackTrace();
       }
       input = str.toCharArray();
       if(input.length < 2)
       {
           System.out.println("The input string is invalid.");
           System.exit(0);
       }
       ptr = 0;
       boolean isValid = E();
       if((isValid) & (ptr == input.length))
       {
           System.out.println("The input string is valid.");
       }
       else
       {
           System.out.println("The input string is invalid.");
       }
   }
  
   static boolean E()
   {
       int fallback = ptr;
       if(input[ptr++] != '|')
       {
           ptr = fallback;
           return false;
       }
       if(P() == false)
       {
           ptr = fallback;
           return false;
       }
       if(O() == false)
       {
           ptr = fallback;
           return false;
       }
      
       return true;
   }
  
   private static boolean O()
   {
       int fallback = ptr;
       if(input[ptr]!= '+')
       {
           ptr = fallback;
           return false;
       }
       if(input[ptr]!= '|')
       {
           ptr = fallback;
           return false;
       }
       if(input[ptr]!= '*')
       {
           ptr = fallback;
           return false;
       }
       if(input[ptr]!= '/')
       {
           ptr = fallback;
           return false;
       }
       if(input[ptr]!= '-')
       {
           ptr = fallback;
           return false;
       }
       return true;
   }
   static boolean P()
   {
       int fallback = ptr;
       if(input[ptr]!= '|')
       {
           ptr = fallback;
           return false;
       }
       if(I()==false)
       {
           ptr = fallback;
           return false;
       }
       if(L()==false)
       {
           ptr = fallback;
           return false;
       }
       if(U()==false)
       {
           ptr = fallback;
           return false;
       }
       else
       {
           if(input[ptr++] != '(')
           {
               ptr = fallback;
               return false;
           }
           if(E() == false)
           {
               ptr = fallback;
               return false;
           }
           if(input[ptr++] != ')')
           {
               ptr = fallback;
               return false;
           }
           return true;
       }
   }
   private static boolean L()
   {
       int fallback=ptr;
       if(input[ptr]!= '|')
       {
           ptr = fallback;
           return false;
       }
       if(D() == false)
       {
           ptr = fallback;
           return false;
       }
       return false;
   }
   static boolean D()
   {
       int fallback = ptr;
       int value = (int)input[ptr];
       if(value >= 65 && value <= 90)
       {
           ptr = fallback;
           return true;
       }
       return false;
   }
   private static boolean U()
   {
       int fallback = ptr;
       if(input[ptr]!= '+')
       {
           ptr = fallback;
           return false;
       }
       if(input[ptr]!= '|')
       {
           ptr = fallback;
           return false;
       }
       if(input[ptr]!= '-')
       {
           ptr = fallback;
           return false;
       }
       if(input[ptr]!= '!')
       {
           ptr = fallback;
           return false;
       }
       return true;
   }

   private static boolean I()
   {
       int fallback = ptr;
       if(input[ptr]!= '|')
       {
           ptr = fallback;
           return false;
       }
       if(C()==false)
       {
           ptr = fallback;
           return false;
       }
       return true;
   }
   private static boolean C()
   {
       int fallback = ptr;
       if(input[ptr]>='a' &&input[ptr]<='z')
       {
           ptr = fallback;
           return true;
       }
       return false;
   }

}