Want to convert infix to postfix in C but getting error empty stack

I write a C code to convert infix expression to postfix expression. The expression may include '^' , "+", "-" , "/", "*" and all three types of brackets i.e." ({[ ". The code should first check whether the brackets are balanced or not and then do the conversion. But the code is showing an empty stack at the output.

Here is my sample code

#include "stackar.h"

#include "fatal.h"

#include <stdlib.h>

#define EmptyTOS(-1)
#define MinStackSize(5)

struct StackRecord {
   int Capacity;
   int TopOfStack;
   ElementType * Array;
};

/* START: fig3_48.txt */
int
IsEmpty(Stack S) {
   return S -> TopOfStack == EmptyTOS;
}
/* END */

int
IsFull(Stack S) {
   return S -> TopOfStack == S -> Capacity - 1;
}

/* START: fig3_46.txt */
Stack
CreateStack(int MaxElements) {
   Stack S;

   /* 1*/
   if (MaxElements < MinStackSize)
      /* 2*/
      Error("Stack size is too small");

   /* 3*/
   S = malloc(sizeof(struct StackRecord));
   /* 4*/
   if (S == NULL)
      /* 5*/
      FatalError("Out of space!!!");

   /* 6*/
   S -> Array = malloc(sizeof(ElementType) * MaxElements);
   /* 7*/
   if (S -> Array == NULL)
      /* 8*/
      FatalError("Out of space!!!");
   /* 9*/
   S -> Capacity = MaxElements;
   /*10*/
   MakeEmpty(S);

   /*11*/
   return S;
}
/* END */

/* START: fig3_49.txt */
void
MakeEmpty(Stack S) {
   S -> TopOfStack = EmptyTOS;
}
/* END */

/* START: fig3_47.txt */
void
DisposeStack(Stack S) {
   if (S != NULL) {
      free(S -> Array);
      free(S);
   }
}
/* END */

/* START: fig3_50.txt */
void
Push(ElementType X, Stack S) {
   if (IsFull(S))
      Error("Full stack");
   else
      S -> Array[++S -> TopOfStack] = X;
}
/* END */

/* START: fig3_51.txt */
ElementType
Top(Stack S) {
   if (!IsEmpty(S))
      return S -> Array[S -> TopOfStack];
   Error("Empty stack");
   return 0; /* Return value used to avoid warning */
}
/* END */

/* START: fig3_52.txt */
void
Pop(Stack S) {
   if (IsEmpty(S))
      Error("Empty stack");
   else
      S -> TopOfStack--;
}
/* END */

/* START: fig3_53.txt */
ElementType
TopAndPop(Stack S) {
   if (!IsEmpty(S))
      return S -> Array[S -> TopOfStack--];
   Error("Empty stack");
   return 0; /* Return value used to avoid warning */
}
/* END */

/* MYCODE TO CONVERT INFIX TO POSTFIX STARTS FROM HERE. THE ABOVE FILE IS "stacker.c"*/

#include <stdio.h>

#include<ctype.h>

#include "stackar.h"

int ismatchingpair(char char1, char char2) // check whether the bracket are same or not
{
   if (char1 == '(' && char2 == ')')
      return 1;
   if (char1 == '[' && char2 == ']')
      return 1;
   if (char1 == '{' && char2 == '}')
      return 1;
   else
      return 0;
}
int bracketsBalance(char * str) {
   Stack S;
   S = CreateStack(20);
   int i;
   for (int i = 0; str[i]; ++i) {
      if (str[i] == '(' || str[i] == '{' || str[i] == '[') // if opening bracket, push it in the stack
      {
         Push(str[i], S);
      } else if (str[i] == ')' || str[i] == '}' || str[i] == ']') // if closing bracket, check whether it matches the opening bracket
      {
         if (ismatchingpair(Top(S), str[i])) // if it matches the opening bracket, pop it in the stack
         {
            Pop(S);
         }
      }
   }
   if (IsEmpty(S)) // if stack is empty, return 1
   {
      return 1;
   } else // else return 0
   {
      return 0;
   }
}

int pr(char symbol) {
   /* Function for precedence */

   if (symbol == '^') /* exponent operator, highest precedence*/ {
      return (3);
   } else if (symbol == '*' || symbol == '/') {
      return (2);
   } else if (symbol == '+' || symbol == '-') /* lowest precedence */ {
      return (1);
   } else {
      return (0);
   }
}
int openingbracket(char x) {
   if (x == '(' || x == '{' || x == '[') {
      return 1;
   } else {
      return 0;
   }
}
int closingbracket(char y) {
   if (y == ')' || y == '}' || y == ']') {
      return 1;
   } else {
      return 0;
   }
}
int checkoperator(char z) {
   if (z == '^' || z == '+' || z == '-' || z == '/' || z == '*') {
      return 1;
   } else {
      return 0;
   }
}
int infixToPostfix(char * infix, char * postfix, int str_size) {
   str_size = strlen(infix);
   Stack S;
   S = CreateStack(20);

   char i;
   for (i = 0; i < str_size; i++) {
      if (!(checkoperator(infix[i]) || openingbracket(infix[i]) || closingbracket(infix[i]))) {
         strncat(postfix, & infix[i], 1);
      } else if (openingbracket(infix[i])) {
         Push(infix[i], S);
      } else {
         checkoperator(infix[i]);
         while (pr(Top(S)) >= pr(i)) {
            strcat(postfix, & infix[i]);
            Pop(S);
         }
         Push(i, S);
      }
   }
   while (Top(S) != '#') {
      TopAndPop(S);
      strncat(postfix, & infix[i], 1);
   }
}
main() {
   int roll_no = 5;
   char in [1000] = "[(62.1+9.0)*(84+roll_no)-2]*4)";
   char post[1000];
   if (bracketsBalance( in )) {
      printf("Brackets in %s are balanced\n", in );
      infixToPostfix( & in [0], & post[0], 1);
      printf("Postfix expressionof %s is: %s\n", in , & post[0]);
   } else {
      printf("Brackets unbalanced. No conversion performed");
   }
   return 0;
}

---

1 Answers