Tengo el siguiente codigo que me compila pero no me ejecuta, me gyustraria que me dijeran cual es el error

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#define STACKSIZE 50

struct stack_struct{
       unsigned int size_algo;
       int tipo[STACKSIZE];
};

typedef struct stack_struct stack;
 
stack * crear_stack_corchete (){
      stack * corchete;
      stack l_corchete;
      corchete=&l_corchete;                                   /
      corchete->size_algo = 0;
      return corchete;
   }

stack * crear_stack_llave(){
      stack * llave;
      stack l_llave;
      llave=&l_llave;            
      llave->size_algo = 0;
      return llave;
   }
stack * crear_stack_parentesis(){
      stack * parentesis;
      stack l_parentesis;   
      parentesis=&l_parentesis;         
      parentesis->size_algo=0;
      return parentesis;
   }

void balancear(stack *parentesis, stack *corchete,stack *llave, char tipo, int linea){ 
     if ((int)tipo==40){
        parentesis->tipo[parentesis->size_algo++]=linea;     
        }
     if ((int)tipo==91){
        corchete->tipo[corchete->size_algo++]=linea;
     }
     if ((int)tipo== 123){
        llave->tipo[llave->size_algo++]=linea;
     }
     if ((int)tipo== 41){
        if (parentesis->size_algo <1){
           printf ("Error: Caracter ) no balanceado en la linea %d.\n", *parentesis);
        }
        else{
             parentesis->tipo[parentesis->size_algo--];
        }
     }             
     if ((int)tipo==93){
        if (corchete->size_algo<1){
           printf ("Error: Caracter ] no balanceado en la linea %d.\n", *corchete);
        }
        else{
        corchete->tipo[corchete->size_algo--];
        }
     }
     if ((int)tipo==125){
        if (llave->size_algo <1){
           printf ("Error: Caracter } no balanceado en la linea %d.\n", *llave);
        }
        else{
             llave->tipo[llave->size_algo--];
        }
     }
}
                                 
int main(int argc, char* argv[]){
     stack *parentesis=crear_stack_parentesis();               
     stack *corchete=crear_stack_llave();
     stack *llave=crear_stack_corchete();
     unsigned int linea;
     char es_comilla=0;                                                         
     char es_apostrofe=0;
     char caracter;
     FILE* archivo=fopen(argv[1],"r");
     caracter=(char)fgetc (archivo);
     if (archivo==NULL){                                                         
        printf("Error: archivo nulo");
     }
     else{
          while ( caracter != EOF){
                if ((int)caracter== 34){
                   if(es_comilla==1){
                                     es_comilla=0;
                   }
                   else{
                        es_comilla=1;
                          }
                if((int)caracter==39){
                   if (es_apostrofe==1){
                      es_apostrofe=0;
                   }
                   else{
                        es_apostrofe=1;
                   }
                }
                if (!(es_comilla || es_apostrofe)){
                   balancear(&parentesis,&corchete,&llave,caracter,linea);
                }
                if (caracter=='\n'){
                   linea++;
                }
          }
          if (caracter==EOF){
             if (es_comilla==0&& es_apostrofe==0 && parentesis->size_algo==0 && corchete->size_algo==0 && llave->size_algo==0){
                printf("Revision completada sin errores.\n");
             }
             if( es_comilla==1 || es_apostrofe==1){
                 printf("Error: EOF encontrado cuando se esperaba caracter limitador de parentesis o string.\n");
             }
             if (parentesis->size_algo!=0){
                while (parentesis->size_algo>0){
                      printf ("Error: Caracter ( no balanceado en la linea %d.\n", *parentesis);
                      parentesis->tipo[parentesis->size_algo--];
                }
             }
             if (corchete->size_algo!=0){
                while (corchete->size_algo>0){
                      printf("Error: Caracter [ no balanceado en la linea %d.\n", *corchete);
                      corchete->tipo[corchete->size_algo--];
                }
             }
             if (llave->size_algo!=0){
                while (parentesis->size_algo>0){
                      printf("Error: Caracter { no balanceado en la linea %d.\n", *llave);
                      llave->tipo[llave->size_algo--];
                }
             }
             
          }
      }
  }
return 0;
fclose(archivo);     
system ("pause");
}

En la función "crear_stack_corchete" retornas la dirección en memoria de una variable local:

stack *crear_stack_corchete()
{
   stack * corchete;
   stack l_corchete;
   corchete = &l_corchete; /* <== */
   corchete->size_algo = 0;
   return corchete; /* <== */
}

No es valido porque la memoria utilizada por todas las variables locales se libera al finalizar la función. Mismo caso con las funciones "crear_stack_llave" y "crear_stack_parentesis".

En la función main no debes convertir el valor de retorno de fgetc (de tipo int) al tipo char:

caracter = (char) fgetc(archivo);

Porque la función fgetc retorna un valor no negativo (el carácter leído) o bien un valor negativo (EOF) para indicar error o fin de archivo. El numero de valores posibles (cualquier carácter, EOF) no es posible almacenarlo en una variable de tipo char (por razones obvias), debe ser int.

Por ultimo si la intención es crear un verificador de sintaxis muy básico (comillas, paréntesis y corchetes balanceados) solo necesitas de una pila.

Un saludo