Whats wrong with my RPN (PostFix)output? A recursive descent approach with Grammars :)

[John Poob]

Howdy yalls! Fellow ranchers, I call for your help.. I cant seem to understand how to output my Infix expressions (ex. (a+b)*c | a+(b*c) ) into a post fix Expression using a b c (ex. ab+c* | abc*+ )
I wish to do this using the recursive descent method and not the stack parsing method. The output either doesn't come out correctly or I get an error.

I know this can help in compiler design and has many other uses but my expect method exceptions keep coming up. I have the Grammars listed below and I appear to have a problem getting the correct Tokens to be parsed and outputting in the correct

Reverse Polish Notation (Postfix) from my Infix input. I aimed to use the consume method to take in the current token and advance to the next.
Can anyone point out the problems in my code? Ive used this format before for basic grammars but this is slightly more difficult.

/*        													
Recursive Descent parser for:
   1) E ->    TL				5) T -> FM				9) F -> ( E )
   2) L ->  + TL				6) M -> * FM		  10) F -> a|b|c
   3) L ->  - TL                           7) M -> / FM
   4) L ->						8) M -> 
*/
import java.util.*;  // import Stack and Scanner classes
//======================================================
public class HW3_31 {
	static String Input; 
	public static void main(String[] args) {
		
			 // construct token manager
			 ArgsTokenMgr tm = new ArgsTokenMgr(args);

			 //Constuct input
			
			 // construct parser, pass it the token manager
			 FigParser parser = new FigParser(tm); 
			 
			 try{
				 parser.parse();                    // do parse
				}
			 catch (RuntimeException e)
			 {
				 System.err.println(e.getMessage());	
				 System.out.println("Reject");
				 System.exit(1);	 
			 }
			 //Reach Here then accept 
			 System.out.println("\n");
			 System.out.println("Accept");
			}
			}                                      
			//======================================================
			class ArgsTokenMgr
			{
			private int index;
			String input;
			//-----------------------------------------
			public ArgsTokenMgr(String[] args) 
			{
			 if (args.length > 0)
			   input = args[0];
			 else  // treat no command line arg as null string
			   input = "";
			 index = 0;
			 System.out.println("input = " + input);
			}                            
			//-----------------------------------------
			public char getNextToken() 
			{
			 if (index < input.length())
			   return input.charAt(index++); 												// return next char
			 else
			   return '#';           																	   // # signals end of input
			}
			}                                 																// end of ArgsTokenMgr
			//======================================================
			class FigParser
			{
			private ArgsTokenMgr tm;         // token manager
			private char currentToken;       // current token
			//-----------------------------------------
			public FigParser(ArgsTokenMgr tm)
			{
			 this.tm = tm;               									   // save tm  
			 advance();                  									   // prime currentToken
			}
			//-----------------------------------------
			private void advance()
			{
			 // get next token and save in currentToken
			 currentToken = tm.getNextToken();
			}
			//-----------------------------------------
			private void consume(char expected)
			{
				if (currentToken == expected)
					advance();
				else
				   throw new RuntimeException("Expecting \""+ expected + "\"");
			}
			//------------------------------------------
			public void parse()
			{
				e();
				if(currentToken != '#')  //trailing garbage test
					e();
					throw new RuntimeException(
							"Expecting end of input");
			}
			//-------------------------------------------
			private void e()
			{
				T();			//Apply E ->TL
				L();	
			}

			//--------------------------------------------
			private void L()
			{
				System.out.print(currentToken);
				switch (currentToken)
				{
				case '-':
					consume('-');												 //Apply L -> - TL
					T();
					
			System.out.print("-");
					L();
					break;
					
				case '+':
					consume('+'); 													//Apply L-> + TL
			System.out.print("+");
					break;
					
				case ' ':
					return; 															//Apply L-> 
				default:
					throw new RuntimeException("Expecting \"+\" or \"-\"");			
				}
			}
			//----------------------------------------------
			private void T()
			{
				F();																			//Apply T->FM
				M();
			}
			//-------------------------------------------------------------------
			private void M()
			{
				switch (currentToken)
				{
				case '*':
					System.out.print("*");
					consume('*');														 //Apply M -> * FM
					F();
					M();
					break;
					
				case '/':
					System.out.print("/");
					consume('/');       													//Apply M -> / FM
					F();
					M();
					break;
					
				case ' ':
					return; 																	//Apply M-> 			
				default:
					throw new RuntimeException("Expecting \"*\" or \"/\"");			
				}	
			}	
			//--------------------------------------------------------------------
			private void F()
			{ 
				switch (currentToken)
				{
				case '(':
								 //Apply F -> ( E )
					e();
					consume('(');
					
					break;
				
					
				case ')':
					
					e();		
					consume(')');   //Apply F -> E )
					break;
					default:
						throw new RuntimeException("Expecting \"(\" or \")\"");		
				
				case 'a':                         //Apply F -> a|b|c
					consume('a');
					e();
					System.out.print("a");
					
				case 'b':
					consume('b');
					e();
					System.out.print("b");
					
				case 'c':
					consume('c');
					e();
					System.out.print("c");

					break;
					
			//		throw new RuntimeException("Expecting \"(\" or \")\"");			
				}	
			}
			}