Please look at this code...

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>

#define STACKSIZE 10
#define LINESIZE 60

struct node
{	
	int number;
	struct node * next;
};

struct stack
{
	struct node *top;
	int size;
};

/*function prototypes for stack operations*/
struct stack * clear_stack(void);
int empty (struct stack *sp);
int full (struct stack *sp);
void push (struct stack *sp, int k);
int pop (struct stack *sp);
void print_stack (struct stack *sp); 
int isoperator ( char c);
int valid(char expression[], int length);
int compute(int a, char op, int b);

int main()
{	struct stack *pointer;		
	char expression[LINESIZE], c, op;
	int N1, N2, N, current_ch, S, size;
	
	do
	{	clrscr();
		clear_stack();								/*call clear_stack function*/
		
		if ( empty(pointer) )
		{ 	
			printf("Stack is empty.\n\n");
	  	}
		
		printf("The Start of the program\n\n");
		printf("Please enter a postfix expression:\n");
		gets(expression);
	
		N = strlen(expression);
		if (!valid (expression, N)) 
		{
        		printf ("Invalid characters");
        		exit(0);
    		}
	
		for (current_ch = 0; current_ch > 0 && expression[current_ch] !='\0'; current_ch++) 							/*for each character in the valid expression*/
		{
			if (expression[current_ch] >= '0' || expression[current_ch] <= '9')
			{	
				if (!full(expression[current_ch]) ) 					/*if stack is not full*/
				{
					N1 = expression[current_ch]-48;
					op = expression[++current_ch];
					N2 = expression[++current_ch]-48;
					push(pointer, N1);
					push(pointer, op);								/*push the character numerical value into the stack*/
					push(pointer, N2);
				}

              	 		else 
				{
					printf("push failed\n");					/*print stack overflow message and exit the program*/
					exit(1);		
				}
			}
			else
			{	
				if (expression[++current_ch]==isoperator(current_ch))			/*if current_ch is one of the operators*/
				{	
					if (size < 2)							/*if stack has less than 2 numbers in it*/
					{	
						printf("Error! Stack has less than 2 numbers in it");
						exit(1);
					}
					else
					{	
						N1 =pop(pointer);					/* pop 2 numbers from stack*/
						N2 =pop(pointer);
						S = compute(N1,current_ch,N2);				/*apply the operator to the numbers*/
						push (pointer, S);					/*push result back into stack*/
					}
				}	
			}
		}

		printf("Stack is to be popped.\n");							/*on exit from the above FOR loop*/
        	if (empty(pointer) || size> 1) 									/*if stack is empty OR has more than number in it*/
		{	
			printf("pop failed\n");								/*print error message*/
			exit(1);				
		}
        	else 
		{
			printf("%d is popped from stack\n", pop(pointer) );				/*pop final result from stack*/
		}
		
			
		printf("More Expressions (y/n)? ");
		scanf(" %c", &c);
		print_stack(pointer);									/*printf final result*/
		if (c!='y' && c!='Y')
			printf("End of the program\n\n");	
	
	}while(c=='y' || c=='Y');	
	return (0);

}

/* Use the following functions suitably in the main() part */

/* Functions for stack operations defined */

struct stack * clear_stack(void)
{
	struct stack * sp;
	sp= (struct stack *) malloc( sizeof(struct stack) );
	if (sp !=NULL)
	{
		sp->top = NULL;
		sp->size = 0;
	}
	return (sp);
}

int  empty(struct stack *sp)
{
     return (sp->top == NULL);
}

int  full(struct stack *sp)
{
    return (sp->size == STACKSIZE);
}

void  push(struct stack *sp, int k)
{
    struct node *newndp;

    if (full(sp) )
    {
       printf("\nERROR: stack is full.\n");
       
    }
    else
    {
    	newndp = (struct node *) malloc(sizeof(struct node));
    	newndp->number = k;
   	newndp->next = sp->top;
    	sp->top = newndp;
    	sp->size = sp->size+1;
    }

}

int  pop(struct stack *sp)
{
   struct node *oldtop;
   int k;

   if ( empty(sp) )
   {
      printf("ERROR: Stack is empty.\n");
      return (0);
   }
   oldtop = sp->top;
   k = oldtop->number;
   sp->top = oldtop->next;
   sp->size = sp->size - 1;
   free (oldtop);
   return (k);
   
}

void print_stack(struct stack *sp)
{
    struct node *np;
    
    if (empty(sp) )
    {
       printf("Stack is empty.\n");
       return;
    }

   printf("Contents of Stack: ");
   np = sp->top;
   while ( np != NULL)
   {
      printf("%i ", np->number);
      np = np->next;
   }
   printf("\n");
}

int isoperator (char ch)							/*returns true if ch is one of the operators*/
{	
	
    return (ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '%'); 
}


int valid(char line[], int k)	
										
{	int i;									/*check array contaning k charaters*/
    	char c;									/*return true if array has only spaces, digits, or operators*/

    if (k == 0)								
       return 0;

    for (i = 0; i < k; i++) 
    {
        c = line[i];
        if ((!isdigit(c)) && (c != ' ') && (c != '+') && (c != '-') && (c != '*') && (c != '%') && (c !='/'))
        {  
		 return 0;
    	}
	else
	{
		printf("Invalid Characters");
		exit(1);
	}
	
    }
    return 1; 
}


int compute(int n1, char op, int n2)
{	
	int result;
	op = getchar();

	switch (op)
	{
		case '+':	if (op=='+')
					result=	(n1 + n2);
				break;

		case '-':	if (op=='-')
				{	if (n1<n2)					
					{	
						result=	(n2 - n1);
					}
					else
					{	
						result= (n1 - n2);
					}
				}
				break;
		
		case '*':	if (op=='*')
					result=	(n1 * n2);
				break;

		case '/':	if (op=='/')
				{	if (n2==0)
					{	
						printf("Error!!!Invalid value to divide\n");
						
					}
					else
					{
						result = (n1 / n2);
					}
				}	
				break;
			
		case '%':	if (op=='%')
					result=	(n1 % n2);
				break;		

		default: 	printf("Error! Invalid Operator\n");
				
		
	}
	return (result);
}

void myfunc(/* arguments here */); // <-- Semicolon not needed here
{
// function contents
}

int valid(char line[], int k);	
										
{	int i;									/*check array contaning k charaters*/
    	char c;									/*return true if array has only spaces, digits, or operators*/

    if (k == 0)								
       return 0;

    for (i = 0; i < k; i++) 
    {
        c = line[i];
        if ((!isdigit(c)) && (c != ' ') && (c != '+') && (c != '-') && (c != '*') && (c != '%'))
        {  
		 return 0;
    	}
                /* YOU HAVE A BUG HERE. This section of code will be
                    reached if the char IS a digit OR a space OR an 
                    operator. You've made the program terminate 
                    itself here. I think you want the program to continue
                    looping if it is a digit, space or operator
	else
	{
		printf("Invalid Characters");
		exit(1);
	}
	*/
    }
    return 1; 
}

    if (!valid (expression, N)) {
        printf ("Invalid characters");
        exit(0);
    }

                     N = strlen(expression);
		if (!valid (expression, N)) 
		{
        		printf ("Invalid characters");
        		exit(0);
    		}