program.java

this program use to show LL1

       {
         if(r2.rightSide.get(0) instanceof Terminal)
         {
           r.rightSide.add(r2.rightSide.get(0));
         }
       }
     }
   }
   StringBuffer sb = new StringBuffer();
   sb.append("\n");
   Iterator gram_iter = gramSymbols.iterator();
   while(gram_iter.hasNext())
   {
     Rule gram_rule = (Rule) gram_iter.next();
     Symbol rule_rSide = (Symbol) gram_rule.rightSide.get(0);
     sb.append("First(");
     sb.append(gram_rule.leftSide.strSymbol);
     sb.append(") = ");
     sb.append(gram_rule.rightSide.toString());
     sb.append("\n");
   }
   jTextArea2.append(sb.toString());
 }
//------------------------------------------------------------------------------
 List firstOFRightSideRule = new LinkedList();
 public void step5()
 {

   int LastRuleIndex = -1;
   boolean isExist = false;

   //System.out.println("^^^^^^^^^^^^^^^^^^^^^^") ;
   //System.out.println(ruleList.toString()) ;
   Iterator  rule_iter = ruleList.iterator();
   while(rule_iter.hasNext())
   {
     int x= 0;
     Rule r = (Rule) rule_iter.next();
     Iterator right_iter2 = r.rightSide.iterator();
     while(right_iter2.hasNext())
     {
       Symbol s = (Symbol) right_iter2.next();
       Iterator gram_iter3 = gramSymbols.iterator();
       while(gram_iter3.hasNext())
       {
         Rule r2 = (Rule) gram_iter3.next();
         if(s.strSymbol.matches(r2.leftSide.strSymbol))
         {
           Rule tempRule = new Rule(r.leftSide);
           tempRule.ruleIndex = r.ruleIndex;
           //tempRule.leftSide.strSymbol=r.rightSide.toString();

           if(!isExist)
           {
             tempRule.rightSide.addAll(r2.rightSide);
             firstOFRightSideRule.add(tempRule);
             LastRuleIndex = firstOFRightSideRule.indexOf(tempRule);
           }
           else
           {
             Rule rr = (Rule)firstOFRightSideRule.get(LastRuleIndex);
             rr.rightSide.addAll(r2.rightSide);
           }
         }
       }
       if(!NullableNonTerminal.contains(s))
       {
         isExist = false;
         break ;
       }
       else
       {
         isExist = true;
       }
     }
   }
   Iterator ii = firstOFRightSideRule.iterator();
   while(ii.hasNext())
   {
     Rule r = (Rule) ii.next();
     //System.out.println("********************");
     //System.out.println(r.leftSide.toString()+" == "+ r.rightSide.toString());
   }
   jTextArea2.append("\n======================= \nStep ( 5 ) :");
   StringBuffer sb = new StringBuffer();
   sb.append("\n");
   Iterator rule_List = ruleList.iterator();
   Iterator first_iter = firstOFRightSideRule.iterator();
   while(rule_List.hasNext()||first_iter.hasNext())
   {
     Rule gram_rule = (Rule) rule_List.next();
      //System.out.println("$$$$$$$$$$$$$$$$$$$$$$$$$$$");

      //System.out.println(gram_rule.nullable);

     if(!gram_rule.nullable)
     {
       Rule first_rule = (Rule) first_iter.next();
       sb.append("First(");
       sb.append(gram_rule.rightSide.toString());
       sb.append(") = ");
       sb.append(first_rule.rightSide.toString());
       sb.append("\n");
     }
   }
   jTextArea2.append(sb.toString());
   //jTextArea2.append(firstOFRightSideRule.toString());
 }
//------------------------------------------------------------------------------
 SortedSet FDB = new TreeSet();
 public void step6()
  {
    jTextArea2.append("\n======================= \nStep ( 6 ) :");
   Iterator ruleListIter = ruleList.iterator();
   while(ruleListIter.hasNext())
   {
     Rule r = (Rule) ruleListIter.next();
     ListIterator rightSideIter = r.rightSide.listIterator();
     while(rightSideIter.hasNext())
     {
       Symbol s = (Symbol) rightSideIter.next();

       if(s instanceof NonTerminal)
       {
         if(rightSideIter.hasNext())
         {
           Symbol s2 = (Symbol) rightSideIter.next();
           Rule temp = new Rule(s);
           temp.rightSide.add(s2);
           FDB.add(temp);
           rightSideIter.previous();
         }
       }
     }
   }

   Iterator fdb_iter=FDB.iterator();
   StringBuffer sb=new StringBuffer ();
   while(fdb_iter.hasNext())
   {
     Rule fdb_rule =(Rule) fdb_iter.next();
     Symbol fdb_rSide = (Symbol)fdb_rule.rightSide.get(0);

     sb.append("\n");
     sb.append(fdb_rule.leftSide.strSymbol);
     sb.append(" FDB ");
     sb.append(fdb_rSide);

   }
   sb.append("\n");
   jTextArea2.append(sb.toString());
 }
//------------------------------------------------------------------------------
 SortedSet DEO = new TreeSet();
  public void step7()
  {
    //System.out.println(ruleList.toString());
    ListIterator Ruleiter = ruleList.listIterator();
    while(Ruleiter.hasNext())
    {
      Rule r = (Rule) Ruleiter.next();
      //System.out.println(r.nullable);
      if(r.nullable)
        continue;
      int lastIndex = r.rightSide.size();
      ListIterator backIter = r.rightSide.listIterator(lastIndex);
      while(backIter.hasPrevious())
      {
        Symbol lastSymbol = (Symbol) backIter.previous();
        //System.out.println(lastSymbol.toString());
        Rule tempRule = new Rule(lastSymbol);
        tempRule.rightSide.add(r.leftSide);
        DEO.add(tempRule);
        if(!NullableNonTerminal.contains(lastSymbol))
        {
          break;
        }
      }
    }
      jTextArea2.append("\n======================= \nStep ( 7 ) :");

    Iterator fdb_iter=DEO.iterator();
   StringBuffer sb=new StringBuffer ();
   while(fdb_iter.hasNext())
   {
     Rule fdb_rule =(Rule) fdb_iter.next();
     Symbol fdb_rSide = (Symbol)fdb_rule.rightSide.get(0);

     sb.append("\n");
     sb.append(fdb_rule.leftSide.strSymbol);
     sb.append(" DEO ");
     sb.append(fdb_rSide);

   }
   sb.append("\n");
   jTextArea2.append(sb.toString());

  }
//------------------------------------------------------------------------------
  SortedSet EO = new TreeSet();
  public void step8()
  {
    //=====Add the set of DEO in EO set
   EO.addAll(DEO);
   //System.out.println(EO.toString());
   //==============================================
   //=====Find the Transitive Relation
   StringBuffer tsb = new StringBuffer();
   tsb.append("\n");
   Iterator iter = DEO.iterator();
   while(iter.hasNext())
   {
     Rule r = (Rule) iter.next();
     Symbol rightSymbol = (Symbol) r.rightSide.get(0);
     Iterator iter2 = DEO.iterator();
     while(iter2.hasNext())
     {
       Rule r2 = (Rule) iter2.next();
       Symbol leftSymbol = (Symbol) r2.leftSide;
       if(rightSymbol.strSymbol.matches(leftSymbol.strSymbol))
       {
         Rule tempRule = new Rule(r.leftSide);
         tempRule.rightSide = r2.rightSide;

         tsb.append(r.leftSide.strSymbol);
         tsb.append(" EO ");
         tsb.append(r2.rightSide.get(0).toString());
         tsb.append("\n");

         EO.add(tempRule);
       }
     }
   }
   //System.out.println(EO.toString());
   //=============Find the Reflexive Relation

   Iterator iter3 = EO.iterator();
   while(iter3.hasNext())
   {
     Rule r3 = (Rule) iter3.next();

     Rule leftTemp = new Rule(r3.leftSide);
     leftTemp.rightSide.add(r3.leftSide);

     Rule rightTemp = new Rule((Symbol )r3.rightSide.get(0));
     rightTemp.rightSide.add(r3.rightSide.get(0));

     tempReflexive.add(leftTemp);
     tempReflexive.add(rightTemp);
   }
   EO.addAll(tempReflexive);
   //System.out.println(EO.toString());
   //============Write the Result
   jTextArea2.append("\n======================= \nStep ( 8 ) :");
   jTextArea2.append("\n From DEO");

   StringBuffer sb = new StringBuffer();
   Iterator iter4 = DEO.iterator();
   sb.append("\n");
   while(iter4.hasNext())
   {
     Rule r = (Rule) iter4.next();
     sb.append(r.leftSide.toString())  ;
     sb.append(" EO ");
     sb.append(r.rightSide.get(0).toString());
     sb.append("\n");
   }
   jTextArea2.append(sb.toString());
   jTextArea2.append("\nTransitive");
   jTextArea2.append(tsb.toString());

   StringBuffer rsb = new StringBuffer();
   Iterator iter5 = tempReflexive.iterator();
   rsb.append("\n");
   while(iter5.hasNext())
   {
     Rule r = (Rule) iter5.next();
     rsb.append(r.leftSide.toString())  ;
     rsb.append(" EO ");
     rsb.append(r.rightSide.get(0).toString());
     rsb.append("\n");
   }

   jTextArea2.append("\nReflexive");
   jTextArea2.append(rsb.toString());
  }
//------------------------------------------------------------------------------
  SortedSet FB = new TreeSet();
  public void step9()
  {
    Iterator EO_iter = EO.iterator();
    while(EO_iter.hasNext())
    {
      Rule EO_Rule = (Rule) EO_iter.next();
      Symbol EO_rSide = (Symbol) EO_Rule.rightSide.get(0);
      Iterator FDB_iter = FDB.iterator();
      while(FDB_iter.hasNext())
      {
        Rule FDB_Rule = (Rule) FDB_iter.next();
        Symbol FDB_rSide = (Symbol) FDB_Rule.rightSide.get(0);
        if(EO_rSide.strSymbol.matches(FDB_Rule.leftSide.strSymbol))
        {
          Iterator BW_iter = BW.iterator();
          while(BW_iter.hasNext())
          {
            Rule BW_Rule = (Rule) BW_iter.next();
            Symbol BW_rSide = (Symbol) BW_Rule.rightSide.get(0);

            if(FDB_rSide.strSymbol.matches(BW_Rule.leftSide.strSymbol))
            {
//System.out.println(EO_Rule.toString()+ "%%"+FDB_Rule.toString()+"%%"+BW_Rule.toString());
              Rule temp_Rule = new Rule(EO_Rule.leftSide);
              temp_Rule.rightSide.add(BW_rSide);
              FB.add(temp_Rule);
            }
          }
        }
      }
    }
    jTextArea2.append("\n======================= \nStep ( 9 ) :");

    Iterator fdb_iter=FB.iterator();
    StringBuffer sb=new StringBuffer ();
    while(fdb_iter.hasNext())
    {
      Rule fdb_rule =(Rule) fdb_iter.next();
      Symbol fdb_rSide = (Symbol)fdb_rule.rightSide.get(0);

      sb.append("\n");
      sb.append(fdb_rule.leftSide.strSymbol);
      sb.append(" FB ");
      sb.append(fdb_rSide);

    }
    sb.append("\n");
    jTextArea2.append(sb.toString());
  }
//------------------------------------------------------------------------------
  public void step10()
  {
    Rule firstRule = (Rule)ruleList.get(0);
    Symbol startNonTerminal = firstRule.leftSide;

    Iterator EO_iter = EO.iterator();
    StringBuffer sb = new StringBuffer();
    jTextArea2.append("\n======================= \nStep ( 10 ) :\n");
    while(EO_iter.hasNext())
    {
      Rule EO_rule = (Rule) EO_iter.next();
      Symbol EO_rSide = (Symbol) EO_rule.rightSide.get(0);
      if(startNonTerminal.strSymbol.matches(EO_rSide.strSymbol))
      {
        if(EO_rule.leftSide instanceof NonTerminal)
        {
          Rule tempRule = new Rule(EO_rule.leftSide);
          NonTerminal n = new NonTerminal();
          n.strSymbol = "<----|";
          tempRule.rightSide.add(n);
          sb.append(tempRule.leftSide.strSymbol);
          sb.append(" FB ");
          sb.append(n.strSymbol);
          FB.add(tempRule);
          jTextArea2.append(sb.toString());
        }
      }
    }
  }

//------------------------------------------------------------------------------
  SortedSet FolowSet = new TreeSet();
  JScrollPane jScrollPane1 = new JScrollPane();
  JScrollPane jScrollPane2 = new JScrollPane();
  JMenuBar jMenuBar1 = new JMenuBar();
  JMenu jMenu1 = new JMenu();
  JMenuItem open = new JMenuItem();
  JMenuItem jMenuItem2 = new JMenuItem();
  JButton step_1 = new JButton();
  JButton step_9 = new JButton();
  JButton step_8 = new JButton();
  JButton step_7 = new JButton();
  JButton step_2 = new JButton();
  JButton step_3 = new JButton();
  JButton step_4 = new JButton();
  JButton step_5 = new JButton();
  JButton step_6 = new JButton();
  JButton step_10 = new JButton();
  JButton step_11 = new JButton();
  JButton step_12 = new JButton();
  JButton exit = new JButton();
  public void step11()
  {
    Iterator Null_iter = NullableNonTerminal.iterator();
    while(Null_iter.hasNext())
    {
      Symbol Null_Symbol = (Symbol) Null_iter.next();
      Iterator FB_iter = FB.iterator();
      Rule temp_Rule = new Rule(Null_Symbol);
      while(FB_iter.hasNext())
      {
        Rule FB_rule = (Rule) FB_iter.next();
        Symbol FB_rSide = (Symbol) FB_rule.rightSide.get(0);
        if(Null_Symbol.strSymbol.matches(FB_rule.leftSide.strSymbol))
        {
          if(FB_rSide instanceof Terminal)
            temp_Rule.rightSide.add(FB_rSide);
        }
      }
      FolowSet.add(temp_Rule);
    }

    Iterator iterator = FolowSet.iterator();
    StringBuffer lastBuffer =new StringBuffer();

  while(iterator.hasNext())
  {
    Rule firstR = (Rule) iterator.next();
    Symbol s = (Symbol) firstR.leftSide ;
    lastBuffer.append("\n");
    lastBuffer.append("Fol ("+s.strSymbol+") = ["+ firstR.getRightSide()+"]");

  }
  jTextArea2.append("\n======================= \nStep ( 11 ) :");
 jTextArea2.append(lastBuffer.toString());

    //System.out.println(NullableNonTerminal.toString());
    //System.out.println(FolowSet.toString());
  }
//------------------------------------------------------------------------------

  public void step12()
  {
    Iterator folSet_iter = FolowSet.iterator();
      while(folSet_iter.hasNext())
      {
        Rule folSet_Rule = (Rule) folSet_iter.next();
        Rule tempRule = new Rule(folSet_Rule.leftSide);
        tempRule.rightSide.addAll(folSet_Rule.rightSide);
        firstOFRightSideRule.add(tempRule);
      }

      StringBuffer lastBuffer = new StringBuffer();
      jTextArea2.append("\n======================= \nStep ( 12 ) :");


   Iterator first_Iterator = firstOFRightSideRule.listIterator();
   int index = 1 ;
   while(first_Iterator.hasNext())
   {
     Rule firstR = (Rule) first_Iterator.next();
     Symbol s = (Symbol) firstR.leftSide ;
     lastBuffer.append("\n");
     lastBuffer.append("Sel ("+index+") = ["+ firstR.getRightSide()+"]");
     index++;
   }




    jTextArea2.append(lastBuffer.toString());
       clearLists();
  }
//------------------------------------------------------------------------------
 public void clearLists()
 {

  try {
    ruleList.clear();
    NullableNonTerminal.clear();
    BDW.clear();
    BW.clear();
    tempReflexive.clear();
    gramSymbols.clear();