typdef struct {
  unsigned char pos;
  unsigned char size;
  unsigned char tag;
  unsigned char subtag;
} sStackExpr:

unsigned char n_StackExpr = 0; //Compte le nombre d'identités dans ton expression.
sStackExpr *StackExpr [50] = NULL; //Pointeur sur tes 50 structures.
StackExpr = calloc (50, sizeof (sStackExpr); //Allocation mémoire, ne pas oublier free pour effacer cette allocation

Tu possèdes les variables suivantes qui t'indiques plusieurs choses.
unsigned char ident_pos; //Position du début l'indentité en cours.
unsigned char ident_len; //Taille de l'identité en cours.
unsigned char *ptr; //Pointe sur l'octet en cours de lecture.
unsigned char ident_tag; //TAG de l'identité en cours (TAG final supposé)!
unsigned char i; //Numéro de l'octet en cours dans la chaîne de caractères

A noter que tu peux te passer de toutes ses variables en utilisant la structure sStackExpr.
Par défaut elles sont toutes à 0, a savoir qu'il faut mieux définir un TAG_NONE et un SUBTAG_NONE.

Tu lis le premier octet et tu tombes sur c:
Tu vérifies si auparavant tu avais un TAG défini,  ici c'est pas le cas donc tu fais les choses suivantes:
ident_pos = i;  //Début de l'identité en cours.
ident_len++; //(auparavant = à zéro)
ident_tag = TAG_STRING;
ptr++;

Octet suivant tu tombes sur o:
Tu vérifies le tag précédent (ici y en a pas c'est toujours TAG_STRING donc pas de pb il suffit d'incrément len et ptr).

Tu répètes ça jusqu'à la prenthèse:
La parenthèse n'est pas un caractères compris en A et Z et a et z donc c'est une identité 
ainsi:
StackExpr [n_StackExpr].pos = ident_pos;
StackExpr [n_StackExpr].len = ident_len;
StackExpr [n_StackExpr].tag = ident_tag;
StackExpr [n_StackExpr++].subtag = SUBTAG_NONE;

Tu es tombé sur la prenthèse, la parenthèse est une identité donc:
StackExpr [n_StackExpr].pos = i;
StackExpr [n_StackExpr].len = 1;
StackExpr [n_StackExpr].tag = TAG_PARENTH_OPEN;
StackExpr [n_StackExpr++].subtag = SUBTAG_NONE;

Tu initialises tout histoire de préparer l'identité suivante:
ident_pos = i+1;
ident_len =0;
ident_tag = TAG_NONE;
ptr++;

Tu arrives sur le chiffre 2, c'est pareil qu'une chaîne de caractère, bref tu continues la lecture si l'octet est compris entre 0 et 9 (. compris si tu veux) et en même temps tu incrémentes indent_len.

Ensuite tu arrives à p:
Tu regardes ident_tag et il est différent de TAG_NONE et TAG_STRING, dans ce cas faut le stocker, même principe que la chaîne de caractères.

Et ainsi de suite jusqu'à temps d'arriver à la fin de la chaîne de caractères.
(Perso les chaînes de caractères et les nombres peuvent être traité facilement en 'même temps', c'est à dire dans le même bloque.
Bref je ferai 2 zones, une pour les nombres et les chaînes de caractères et une pour les opérations mathématiques, parenthèses... (bref les simples caractères).

unsigned char n_StackExpr = 0; //Compte le nombre d'identités dans ton expression.
sStackExpr *StackExpr = calloc (50, sizeof (sStackExpr)); //Pointeur sur tes 50 structures.
unsigned char i; //Numéro de l'octet en cours dans la chaîne de caractères
unsigned char *expr = (char*)"cos(2pi/5.2)"; //expression