InfixTopostfix.

Question

i have this application where you enter a postfix expression and it returns it in infix form. i have it working in the sence that when you enter ( 9 * 9 ) you get back 9 9 * which is the infix form. so now i want to add a new operator say i am using the @ sign to represent a function so my new operator list is "+-*/@()". so i enter something like @date ( 9 + 5 ) + 6 it should be returned in infix form like this 9 5 + @date 6 + but instead my application returns it like this
@date 9 5 + 6 + which is wrong the @date is in the wrong position. i have been trying all day and i cant fix it . Below is the code for the InfixToPostfix. i would appreciate if someone could point out where i am going wrong.
   import java.util.*;
public class InfixToPostfixParens {
  // Nested Class
  /** Class to report a syntax error. */
  public static class SyntaxErrorException
      extends Exception {
    /** Construct a SyntaxErrorException with the specified
        message.
        @param message The message
    SyntaxErrorException(String message) {
      super(message);
  // Data Fields
  /** The operator stack */
  private static Stack operatorStack;
  /** The operators */
  private static final String OPERATORS = "+-*/@()";
  /** The precedence of the operators, matches order of OPERATORS. */
  private static final int[] PRECEDENCE = {
      1, 1, 2, 2, 3, -1, -1};
  /** The postfix string */
  private static StringBuffer postfix;
  /** Convert a string from infix to postfix.
      @param expression The infix expression
      @throws SyntaxErrorException
  static void convert2() throws SyntaxErrorException {
     String infix = Main.InputExpression.getText();
    operatorStack = new Stack();
    postfix = new StringBuffer();
    StringTokenizer infixTokens = new StringTokenizer(infix);
    try {
      // Process each token in the infix string
      // (same as for class InfixToPostfix.
      // Process each token in the infix string.
      while (infixTokens.hasMoreTokens()) {
        String nextToken = infixTokens.nextToken();
        String firstChar = nextToken.substring(0,1);
        // Is it an operand?
        if (Character.isJavaIdentifierStart(firstChar.charAt(0))
            || Character.isDigit(firstChar.charAt(0))) {
          postfix.append(nextToken);
          postfix.append(' ');
        } // Is it an operator?
        else if (isOperator(firstChar)) {
          processOperator(nextToken);
        else {
          throw new SyntaxErrorException
              ("Unexpected Character Encountered: "
               + firstChar);
      } // End while.
      // Pop any remaining operators
      // and append them to postfix.
      while (!operatorStack.empty()) {
        String op = (String) operatorStack.pop();
        // Any '(' on the stack is not matched.
        if (op.equalsIgnoreCase("(") )
          throw new SyntaxErrorException(
              "Unmatched opening parenthesis");
        postfix.append(op);
        postfix.append(' ');
      // assert: Stack is empty, return result.
      String Answer = new String(postfix);
       Main.OutputResult.setText(Answer);
    catch (EmptyStackException ex) {
      throw new SyntaxErrorException
          ("Syntax Error: The stack is empty");
  /** Method to process operators.
      @param op The operator
      @throws EmptyStackException
  private static void processOperator(String op) {
       if (operatorStack.empty() || op == "(") {
           operatorStack.push(op);
    else {
      // Peek the operator stack and
      // let topOp be the top operator.
      String topOp =
           (String) operatorStack.peek();
      if (precedence(op.substring(0,1)) > precedence(topOp.substring(0,1))) {
        operatorStack.push(op);
      else {
        // Pop all stacked operators with equal
        // or higher precedence than op.
        while (!operatorStack.empty()
               && precedence(op.substring(0,1)) <= precedence(topOp.substring(0,1))) {
          operatorStack.pop();
          if (topOp.equalsIgnoreCase("("))  {
            // Matching '(' popped - exit loop.
            break;
          postfix.append(topOp);
          postfix.append(' ');
          if (!operatorStack.empty()) {
            // Reset topOp.
            topOp =
                 (String)
                 operatorStack.peek();
        // assert: Operator stack is empty or
        //         current operator precedence >
        //         top of stack operator precedence.
        if (!op.equalsIgnoreCase(")") )
          operatorStack.push(op);
  /** Determine whether a character is an operator.
      @param ch The character to be tested
      @return true if ch is an operator
  private static boolean isOperator(String ch) {
    return OPERATORS.indexOf(ch) != -1;
  /** Determine the precedence of an operator.
      @param op The operator
      @return the precedence
  private static int precedence(String op) {
    return PRECEDENCE[OPERATORS.indexOf(op)];
}  Message was edited by:
declan156

Answer 1

i understand how it works im just asking is there away of fixing my problem. i am only learning how to program. if you see how its done once you will know how to do it the next time. thats away of learning. I changed the code around a couple of times for instance when i changed the -1's to 4's it displays it correctly except it leaves the right bracket. Then i put in   if (topOp.equalsIgnoreCase(")"))  {
              // Matching '(' popped - exit loop.
              break;
           } this gets rid of the bracket but produces the wrong output
Message was edited by:
declan156