diff --git a/ediv/src/ediv/compiler.c b/ediv/src/ediv/compiler.c
index 8731af0..742efca 100644
--- a/ediv/src/ediv/compiler.c
+++ b/ediv/src/ediv/compiler.c
@@ -550,10 +550,10 @@ void sentencia(void) {
         lexico();
         if (pieza!=p_id) error(0,59); /* esperando una variable */
 
-        if ((*o).tipo==tvglo) {
-          dir=(*o).vglo.offset; g2(lcar,dir);
-        } else if ((*o).tipo==tvloc && (!(*o).bloque || (*o).bloque==bloque_actual)) {
-          dir=-(*o).vloc.offset;
+        if (o->tipo==tvglo) {
+          dir=o->vglo.offset; g2(lcar,dir);
+        } else if (o->tipo==tvloc && (!o->bloque || o->bloque==bloque_actual)) {
+          dir=-o->vloc.offset;
           g2(lcar,-dir); g1(laid);
         } else error(0,59); /* esperando una variable */
 
diff --git a/ediv/src/ediv/compiler.h b/ediv/src/ediv/compiler.h
index 9565f15..5b2b4c9 100644
--- a/ediv/src/ediv/compiler.h
+++ b/ediv/src/ediv/compiler.h
@@ -285,4 +285,4 @@ void sentencia();
 void g1(int op);
 void g2(int op, int pa);
 
-#endif /* __EDIV_COMPILER_H_ */
\ No newline at end of file
+#endif /* __EDIV_COMPILER_H_ */
diff --git a/ediv/src/ediv/dll_load.h b/ediv/src/ediv/dll_load.h
index e1bf2f4..d36c28e 100644
--- a/ediv/src/ediv/dll_load.h
+++ b/ediv/src/ediv/dll_load.h
@@ -59,4 +59,4 @@ void CheckWindowsVersion(void);
 
 
 
-//#endif
\ No newline at end of file
+//#endif
diff --git a/ediv/src/ediv/ediv.c b/ediv/src/ediv/ediv.c
index 8ed2550..237c916 100644
--- a/ediv/src/ediv/ediv.c
+++ b/ediv/src/ediv/ediv.c
@@ -597,4 +597,4 @@ void conecta(char *servidor, char *archivo)
 
     fwrite(content, tam, 1, stdout);
 }
-#endif
\ No newline at end of file
+#endif
diff --git a/ediv/src/ediv/ediv_export.c b/ediv/src/ediv/ediv_export.c
index 9c22f61..b527200 100644
--- a/ediv/src/ediv/ediv_export.c
+++ b/ediv/src/ediv/ediv_export.c
@@ -84,14 +84,14 @@ int EDIV_Export(char* cadena, int nparam, void* hfuncion)
 
 	ob=o;
 
-	if ((*ob).tipo!=tnone) {
+	if (ob->tipo!=tnone) {
 		dll_error(5,cadena);
 		return 0;
 	}
 
-    (*ob).tipo=tfext;
-    (*ob).fext.codigo=n_externs;
-    (*ob).fext.num_par=nparam;
+    ob->tipo=tfext;
+    ob->fext.codigo=n_externs;
+    ob->fext.num_par=nparam;
 
 	n_externs++;
 
@@ -138,14 +138,14 @@ int EDIV_Export_Const(char* cadena, int valor)
 
 	ob=o;
 
-	if ((*ob).tipo!=tnone) {
+	if (ob->tipo!=tnone) {
 		dll_error(5,cadena);
 		return 0;
 	}
 
-	(*ob).tipo=tcons;
-	(*ob).cons.valor=valor;
-	(*ob).cons.literal=0;
+	ob->tipo=tcons;
+	ob->cons.valor=valor;
+	ob->cons.literal=0;
 
 	return 1;
 }
@@ -174,15 +174,15 @@ int EDIV_Export_Global(char* cadena, int valor)
 
 	ob=o;
 
-	if ((*ob).tipo!=tnone) {
+	if (ob->tipo!=tnone) {
 		dll_error(5,cadena);
 		return 0;
 	}
 
 	indexa_variable(v_global,cadena,imem);
 
-	(*ob).tipo=tvglo;
-	(*ob).vglo.offset=imem;
+	ob->tipo=tvglo;
+	ob->vglo.offset=imem;
 	mem[imem]=valor;
 
 	return imem++;
@@ -212,26 +212,26 @@ int EDIV_Export_Global_Tab(char* cadena, int numregs)
 
 	ob=o;
 
-	if ((*ob).tipo!=tnone) {
+	if (ob->tipo!=tnone) {
 		dll_error(5,cadena);
 		return 0;
 	}
 
 	indexa_variable(v_global,cadena,imem);
 
-	(*ob).tipo=ttglo;
-	(*ob).tglo.offset=imem;
-	(*ob).tglo.len1=len=numregs;
-	(*ob).tglo.len2=-1;
-	(*ob).tglo.len3=-1;
-	(*ob).tglo.totalen=len+1;
+	ob->tipo=ttglo;
+	ob->tglo.offset=imem;
+	ob->tglo.len1=len=numregs;
+	ob->tglo.len2=-1;
+	ob->tglo.len3=-1;
+	ob->tglo.totalen=len+1;
 
 	/* Inicializamos la tabla a 0 */
 	do {
 		mem[imem++]=0;
 	} while (len--);
 
-	return (*ob).tglo.offset;
+	return ob->tglo.offset;
 }
 
 
@@ -258,7 +258,7 @@ int EDIV_Export_Global_Struct(char* cadena, int numregs)
 
 	ob=o;
 
-	if ((*ob).tipo!=tnone) {
+	if (ob->tipo!=tnone) {
 		dll_error(5,cadena);
 		return 0;
 	}
@@ -267,12 +267,12 @@ int EDIV_Export_Global_Struct(char* cadena, int numregs)
 
 	decl_struct=1;
 
-	(*ob).tipo=tsglo;
-	(*ob).sglo.offset=imem;
-	(*ob).sglo.items1=numregs;
-	(*ob).sglo.items2=(*ob).sglo.items3=-1;
-	(*ob).sglo.totalitems=numregs+1;
-	(*ob).sglo.len_item=0;
+	ob->tipo=tsglo;
+	ob->sglo.offset=imem;
+	ob->sglo.items1=numregs;
+	ob->sglo.items2=ob->sglo.items3=-1;
+	ob->sglo.totalitems=numregs+1;
+	ob->sglo.len_item=0;
 	member=ob;
 	len=0;
 
@@ -308,11 +308,11 @@ int EDIV_Export_Member_Int(char* cadena, int valor)
 		return 0;
 	}
 
-	if((*ob).tipo==tsglo) {			/* int miembro de struct global */
+	if(ob->tipo==tsglo) {			/* int miembro de struct global */
 		(*ob2).tipo=tvglo;
 		(*ob2).vglo.offset=len++;
 		mem[imem]=valor;
-		(*ob).sglo.len_item++;
+		ob->sglo.len_item++;
 		return imem++;
 	}
 	else {							/* int miembro de struct local */
@@ -321,7 +321,7 @@ int EDIV_Export_Member_Int(char* cadena, int valor)
         (*ob2).tipo=tvloc;
         (*ob2).vloc.offset=len++;
         loc[iloc]=valor;
-        (*ob).sloc.len_item++;
+        ob->sloc.len_item++;
         return iloc++;
 	}
 }
@@ -355,7 +355,7 @@ int EDIV_Export_Member_Str(char* cadena, int tamano)
 		return 0;
 	}
 
-	if((*ob).tipo==tsglo) {			/* string miembro de struct global */
+	if(ob->tipo==tsglo) {			/* string miembro de struct global */
 
 		(*ob2).tipo=tcglo;
 		(*ob2).cglo.offset=len+1;
@@ -373,7 +373,7 @@ int EDIV_Export_Member_Str(char* cadena, int tamano)
 		len+=1+((*ob2).cglo.totalen+5)/4;
 		mem[imem+1]=0;
 		imem+=1+((*ob2).cglo.totalen+5)/4;
-		(*ob).sglo.len_item+=1+((*ob2).cglo.totalen+5)/4;
+		ob->sglo.len_item+=1+((*ob2).cglo.totalen+5)/4;
 		
 		return (*ob2).cglo.offset;
 	}
@@ -395,7 +395,7 @@ int EDIV_Export_Member_Str(char* cadena, int tamano)
 		len+=1+((*ob2).cloc.totalen+5)/4;
 		loc[iloc+1]=0;
 		iloc+=1+((*ob2).cloc.totalen+5)/4;
-		(*ob).sloc.len_item+=1+((*ob2).cloc.totalen+5)/4;
+		ob->sloc.len_item+=1+((*ob2).cloc.totalen+5)/4;
 		
 		return (*ob2).cloc.offset;
 	}
@@ -430,7 +430,7 @@ int EDIV_Export_Member_Tab(char* cadena, int numregs)
 		return 0;
 	}
 
-	if((*ob).tipo==tsglo) {			/* array miembro de struct global */
+	if(ob->tipo==tsglo) {			/* array miembro de struct global */
 		(*ob2).tipo=ttglo;
 		(*ob2).tglo.offset=len;
 		(*ob2).tglo.len1=numregs;
@@ -440,7 +440,7 @@ int EDIV_Export_Member_Tab(char* cadena, int numregs)
 		len+=numregs+1;
 		memset(&mem[imem],0,(numregs+1)*4);
 		imem+=numregs+1;
-		(*ob).sglo.len_item+=numregs+1;
+		ob->sglo.len_item+=numregs+1;
 		
 		return (*ob2).tglo.offset;
 	}
@@ -456,7 +456,7 @@ int EDIV_Export_Member_Tab(char* cadena, int numregs)
 		len+=numregs+1;
 		memset(&loc[iloc],0,(numregs+1)*4);
 		iloc+=numregs+1;
-		(*ob).sloc.len_item+=numregs+1;
+		ob->sloc.len_item+=numregs+1;
 		
 		return (*ob2).tloc.offset;
 	}
@@ -476,28 +476,28 @@ int EDIV_Export_EndStruct()
 
 	member=NULL;
 
-	if((*ob).tipo==tsglo) {			/* cierra estructura global */
-		if ((*ob).sglo.len_item==0) {
+	if(ob->tipo==tsglo) {			/* cierra estructura global */
+		if (ob->sglo.len_item==0) {
 			dll_error(10);
 			return 0;
 		}
-		if ((*ob).sglo.totalitems>1) {
-			len=((*ob).sglo.totalitems-1)*(*ob).sglo.len_item-1;
+		if (ob->sglo.totalitems>1) {
+			len=(ob->sglo.totalitems-1)*ob->sglo.len_item-1;
 			do {
-				mem[imem]=mem[imem-(*ob).sglo.len_item];
+				mem[imem]=mem[imem-ob->sglo.len_item];
 				imem++;
 			} while (len--);
 		}
 	}
 	else {							/* cierra estructura local */
-		if ((*ob).sloc.len_item==0) {
+		if (ob->sloc.len_item==0) {
 			dll_error(10);
 			return 0;
 		}
-		if ((*ob).sloc.totalitems>1) {
-			len=((*ob).sloc.totalitems-1)*(*ob).sloc.len_item-1;
+		if (ob->sloc.totalitems>1) {
+			len=(ob->sloc.totalitems-1)*ob->sloc.len_item-1;
 			do {
-				loc[iloc]=loc[iloc-(*ob).sloc.len_item];
+				loc[iloc]=loc[iloc-ob->sloc.len_item];
 				iloc++;
 			} while (len--);
 		}
@@ -533,15 +533,15 @@ int EDIV_Export_Local(char* cadena, int valor)
 
 	ob=o;
 
-	if ((*ob).tipo!=tnone) {
+	if (ob->tipo!=tnone) {
 		dll_error(5,cadena);
 		return 0;
 	}
 
 	indexa_variable(v_local,cadena,iloc);
 
-	(*ob).tipo=tvloc;
-    (*ob).vloc.offset=iloc;
+	ob->tipo=tvloc;
+    ob->vloc.offset=iloc;
     loc[iloc]=valor;
 
     return iloc++;
@@ -571,26 +571,26 @@ int EDIV_Export_Local_Tab(char* cadena, int numregs)
 
 	ob=o;
 
-	if ((*ob).tipo!=tnone) {
+	if (ob->tipo!=tnone) {
 		dll_error(5,cadena);
 		return 0;
 	}
 
 	indexa_variable(v_local,cadena,iloc);
 
-	(*ob).tipo=ttloc;
-	(*ob).tloc.offset=iloc;
-	(*ob).tloc.len1=len=numregs;
-	(*ob).tloc.len2=-1;
-	(*ob).tloc.len3=-1;
-	(*ob).tloc.totalen=len+1;
+	ob->tipo=ttloc;
+	ob->tloc.offset=iloc;
+	ob->tloc.len1=len=numregs;
+	ob->tloc.len2=-1;
+	ob->tloc.len3=-1;
+	ob->tloc.totalen=len+1;
 
 	/* Inicializamos la tabla a 0 */
 	do {
 		loc[iloc++]=0;
 	} while (len--);
 
-	return (*ob).tloc.offset;
+	return ob->tloc.offset;
 }
 
 
@@ -617,7 +617,7 @@ int EDIV_Export_Local_Struct(char* cadena, int numregs)
 
 	ob=o;
 
-	if ((*ob).tipo!=tnone) {
+	if (ob->tipo!=tnone) {
 		dll_error(5,cadena);
 		return 0;
 	}
@@ -630,12 +630,12 @@ int EDIV_Export_Local_Struct(char* cadena, int numregs)
 		indexa_variable(v_local,cadena,iloc);
 	}
 
-	(*ob).tipo=tsloc;
-	(*ob).sloc.offset=iloc;
-	(*ob).sloc.items1=numregs;
-	(*ob).sloc.items2=(*ob).sloc.items3=-1;
-	(*ob).sloc.totalitems=numregs+1;
-	(*ob).sloc.len_item=0;
+	ob->tipo=tsloc;
+	ob->sloc.offset=iloc;
+	ob->sloc.items1=numregs;
+	ob->sloc.items2=ob->sloc.items3=-1;
+	ob->sloc.totalitems=numregs+1;
+	ob->sloc.len_item=0;
 	member=ob;
 	len=0;
 
diff --git a/ediv/src/ediv/encrypt.h b/ediv/src/ediv/encrypt.h
index 0322efe..8f90c33 100644
--- a/ediv/src/ediv/encrypt.h
+++ b/ediv/src/ediv/encrypt.h
@@ -24,4 +24,4 @@
 void _encriptar(int encode, char * fichero, char * clave);
 void _comprimir(int encode, char *fichero);
 
-#endif
\ No newline at end of file
+#endif
diff --git a/ediv/src/ediv/expresion.c b/ediv/src/ediv/expresion.c
index b9ba36a..4af75d8 100644
--- a/ediv/src/ediv/expresion.c
+++ b/ediv/src/ediv/expresion.c
@@ -153,25 +153,25 @@ void generar_expresion(void) {
   struct objeto * ob;
 
   do {
-    switch ((*e).tipo) {
+    switch (e->tipo) {
       case econs:
-        g2(lcar,(*e).valor); break;
+        g2(lcar,e->valor); break;
       case estring:
-        g2(lcar,(*e).valor); break;
+        g2(lcar,e->valor); break;
       case erango:
-        g2(lrng,(*e).valor); break;
+        g2(lrng,e->valor); break;
       case ewhoami:
         g1(lcid); break;
       case ecall:
-        ob=(*e).objeto; g2(lcal,(*ob).proc.offset);
-        if ((*ob).usado) (*ob).proc.offset=imem-1; break;
+        ob=e->objeto; g2(lcal,ob->proc.offset);
+        if (ob->usado) ob->proc.offset=imem-1; break;
       case efext:
-        ob=(*e).objeto; g2(lext,(*ob).fext.codigo); break;
+        ob=e->objeto; g2(lext,ob->fext.codigo); break;
       case echeck:
         g1(lchk); break;
       case enull:
         g1(lnul); break;
-      case eoper: switch((*e).token) {
+      case eoper: switch(e->token) {
         case p_asig: g1(lasi); break;
         case p_or: g1(lori); break;
         case p_xor: g1(lxor); break;
@@ -282,13 +282,13 @@ int constante (void) {
 	_linea=linea; _ierror=ierror; exp00(0);
 	swap(linea,_linea); __ierror=ierror; ierror=_ierror;
 
-	do switch ((*e).tipo) {
+	do switch (e->tipo) {
     case econs:
-      pila[++i]=(*e).valor; break;
+      pila[++i]=e->valor; break;
     case estring:
-      pila[++i]=(*e).valor; break;
+      pila[++i]=e->valor; break;
 
-    case eoper: switch((*e).token) {
+    case eoper: switch(e->token) {
       case p_or: pila[i-1]|=pila[i]; i--; break;
       case p_xor: pila[i-1]^=pila[i]; i--; break;
       case p_and: pila[i-1]&=pila[i]; i--; break;
@@ -525,8 +525,8 @@ void exp6() { /* Operador de acceso a variables o tablas locales ajenas */
      * (bueno, si, hacer aquí una búsqueda del p_punto entre e-1 y _exp ...)
 	 */
 
-    if ((*e).tipo==eoper && (*e).token==p_punto)
-      (*e).token=p_add; else error(4,17); /* local no se puede acceder */
+    if (e->tipo==eoper && e->token==p_punto)
+      e->token=p_add; else error(4,17); /* local no se puede acceder */
 
   }
 }
@@ -570,14 +570,14 @@ void factor(void) {
 
     case p_type:
       lexico(); if (pieza!=p_id) error(0,21); /* esperando el nombre de un proceso */
-      switch((*o).tipo) {
+      switch(o->tipo) {
         case tnone:
-          (*o).linea=linea; (*o).ierror=ierror;
-          (*_exp).tipo=econs; (*_exp++).valor=(int)o; (*o).usado=1; break;
+          o->linea=linea; o->ierror=ierror;
+          (*_exp).tipo=econs; (*_exp++).valor=(int)o; o->usado=1; break;
         case tproc:
           (*_exp).tipo=econs; (*_exp++).valor=(int)o; break;
         case tsglo:
-			if (!strcmp((*o).name,"mouse")) { /* "type mouse" = "0"  */
+			if (!strcmp(o->name,"mouse")) { /* "type mouse" = "0"  */
             (*_exp).tipo=econs; (*_exp++).valor=0; break;
           }
         default: error(0,20); /* no es un tipo de proceso */
@@ -588,17 +588,17 @@ void factor(void) {
       lexico(); if (pieza!=p_abrir) error(3,22);	/* esperando '(' */
       lexico(); if (pieza!=p_id) error(3,23);		/* esperando un nombre */
       (*_exp).tipo=econs;
-      switch((*o).tipo) {
+      switch(o->tipo) {
         case tsglo: case tsloc:
-          (*_exp++).valor=(*o).sglo.len_item*(*o).sglo.totalitems; break;
+          (*_exp++).valor=o->sglo.len_item*o->sglo.totalitems; break;
         case tpsgl: case tpslo:
-          (*_exp++).valor=(*((*o).psgl.ostruct)).sglo.len_item*(*o).sglo.totalitems; break;
+          (*_exp++).valor=(*(o->psgl.ostruct)).sglo.len_item*o->sglo.totalitems; break;
         case ttglo: case ttloc:
         case tbglo: case tbloc:
         case twglo: case twloc:
-          (*_exp++).valor=(*o).tglo.totalen; break;
+          (*_exp++).valor=o->tglo.totalen; break;
         case tcglo: case tcloc:
-          (*_exp++).valor=((*o).cglo.totalen+5)/4; break;
+          (*_exp++).valor=(o->cglo.totalen+5)/4; break;
         case tvglo: case tvloc:
           (*_exp++).valor=1; break;
         default: error(0,24); /* no se puede calcular el tamaño */
@@ -612,13 +612,13 @@ void factor(void) {
         lexico();
         if (pieza!=p_pointer) error(0,26); /* No se define el pointer así */
         lexico(); if (pieza!=p_id) error(1,27); obs=o;
-        if ((*obs).tipo==tnone) error(0,28); /* No se define el pointer así */
-        if ((*obs).tipo!=tsglo && (*obs).tipo!=tsloc) error(0,28);
+        if (obs->tipo==tnone) error(0,28); /* No se define el pointer así */
+        if (obs->tipo!=tsglo && obs->tipo!=tsloc) error(0,28);
         lexico(); ob=o;
         analiza_pointer_struct(tpslo,iloc++,obs);
-        (*ob).linea=linea; (*ob).ierror=ierror;
-        (*ob).param=1; parametros++;
-        (*_exp).tipo=econs; (*_exp++).valor=(*ob).pslo.offset;
+        ob->linea=linea; ob->ierror=ierror;
+        ob->param=1; parametros++;
+        (*_exp).tipo=econs; (*_exp++).valor=ob->pslo.offset;
         (*_exp).tipo=eoper; (*_exp++).token=p_punto;
         (*_exp).tipo=eoper; (*_exp++).token=p_pointer;
       } break;
@@ -631,42 +631,42 @@ void factor(void) {
         if (pieza==p_pointer) { /* Recibe un puntero a string */
           lexico();
           ob=analiza_pointer(tpclo,iloc++);
-          (*ob).linea=linea; (*ob).ierror=ierror;
-          (*ob).param=1; parametros++;
-          (*_exp).tipo=econs; (*_exp++).valor=(*ob).pclo.offset;
+          ob->linea=linea; ob->ierror=ierror;
+          ob->param=1; parametros++;
+          (*_exp).tipo=econs; (*_exp++).valor=ob->pclo.offset;
           (*_exp).tipo=eoper; (*_exp++).token=p_punto;
           (*_exp).tipo=eoper; (*_exp++).token=p_pointer;
           break;
         }
         if (pieza!=p_id) error(1,29);	/* esperando el nombre de la cadena */
-        ob=o; if ((*ob).tipo!=tnone) error(0,30);	/* el nombre no es nuevo */
-        (*ob).linea=linea; (*ob).ierror=ierror;
-        (*ob).param=1;
-        (*ob).tipo=tcloc; lexico();
+        ob=o; if (ob->tipo!=tnone) error(0,30);	/* el nombre no es nuevo */
+        ob->linea=linea; ob->ierror=ierror;
+        ob->param=1;
+        ob->tipo=tcloc; lexico();
         if (pieza==p_corab) {
           lexico();
           if (pieza==p_corce) {
             lexico();
-            (*ob).cloc.totalen=255;
+            ob->cloc.totalen=255;
           } else {
             e=_exp;
-            if (((*ob).cloc.totalen=constante())<0) error(4,31); /* cadena de long. negativa */
-            if ((*ob).cloc.totalen>0xFFFFF) error(4,32); /* cadena demasiado larga */
+            if ((ob->cloc.totalen=constante())<0) error(4,31); /* cadena de long. negativa */
+            if (ob->cloc.totalen>0xFFFFF) error(4,32); /* cadena demasiado larga */
             if (pieza!=p_corce) error(3,19);	/* esperando ']' */
             lexico();
             _exp=e;
           }
-        } else (*ob).cloc.totalen=255;
+        } else ob->cloc.totalen=255;
         if (parametros>1) g2(lpar,parametros-1); parametros=1;
         g2(lpri,0); _imem=imem;
-        imem+=1+((*ob).cloc.totalen+5)/4;
+        imem+=1+(ob->cloc.totalen+5)/4;
         test_buffer(&mem,&imem_max,imem);
-        mem[_imem]=0xDAD00000|(*ob).cloc.totalen;
-        memset(&mem[imem+1],0,(((*ob).cloc.totalen+5)&-5));
-        (*ob).cloc.offset=iloc+1;
-        iloc+=1+((*ob).cloc.totalen+5)/4;
+        mem[_imem]=0xDAD00000|ob->cloc.totalen;
+        memset(&mem[imem+1],0,((ob->cloc.totalen+5)&-5));
+        ob->cloc.offset=iloc+1;
+        iloc+=1+(ob->cloc.totalen+5)/4;
         mem[_imem-1]=imem; // pri
-        (*_exp).tipo=estring; (*_exp++).valor=(*ob).cloc.offset;
+        (*_exp).tipo=estring; (*_exp++).valor=ob->cloc.offset;
         (*_exp).tipo=eoper; (*_exp++).token=p_punto;
         (*_exp).tipo=eoper; (*_exp++).token=p_string;
       } break;
@@ -679,25 +679,25 @@ void factor(void) {
         if (pieza==p_pointer) {
           lexico();
           ob=analiza_pointer(tpblo,iloc++);
-          (*ob).linea=linea; (*ob).ierror=ierror;
-          (*ob).param=1; parametros++;
-          (*_exp).tipo=econs; (*_exp++).valor=(*ob).pblo.offset;
+          ob->linea=linea; ob->ierror=ierror;
+          ob->param=1; parametros++;
+          (*_exp).tipo=econs; (*_exp++).valor=ob->pblo.offset;
           (*_exp).tipo=eoper; (*_exp++).token=p_punto;
           (*_exp).tipo=eoper; (*_exp++).token=p_pointer;
           break;
         }
         if (pieza!=p_id) error(1,23); /* esperando un nombre */
-        ob=o; if ((*ob).tipo!=tnone) error(0,30); /* el nombre no es nuevo */
-        (*ob).linea=linea; (*ob).ierror=ierror;
-        (*ob).param=1;
-        (*ob).tipo=tbloc; lexico();
+        ob=o; if (ob->tipo!=tnone) error(0,30); /* el nombre no es nuevo */
+        ob->linea=linea; ob->ierror=ierror;
+        ob->param=1;
+        ob->tipo=tbloc; lexico();
         if (pieza==p_corab) error(2,33); /* no se puede pasar una tabla como parametro */
-        parametros++; (*ob).bloc.offset=iloc++;
-        (*ob).bloc.len1=0;
-        (*ob).bloc.len2=-1;
-        (*ob).bloc.len3=-1;
-        (*ob).bloc.totalen=1;
-        (*_exp).tipo=econs; (*_exp++).valor=(*ob).bloc.offset;
+        parametros++; ob->bloc.offset=iloc++;
+        ob->bloc.len1=0;
+        ob->bloc.len2=-1;
+        ob->bloc.len3=-1;
+        ob->bloc.totalen=1;
+        (*_exp).tipo=econs; (*_exp++).valor=ob->bloc.offset;
         (*_exp).tipo=eoper; (*_exp++).token=p_punto;
         (*_exp).tipo=econs; (*_exp++).valor=0;
         (*_exp).tipo=eoper; (*_exp++).token=p_pointerbyte;
@@ -711,25 +711,25 @@ void factor(void) {
         if (pieza==p_pointer) {
           lexico();
           ob=analiza_pointer(tpwlo,iloc++);
-          (*ob).linea=linea; (*ob).ierror=ierror;
-          (*ob).param=1; parametros++;
-          (*_exp).tipo=econs; (*_exp++).valor=(*ob).pwlo.offset;
+          ob->linea=linea; ob->ierror=ierror;
+          ob->param=1; parametros++;
+          (*_exp).tipo=econs; (*_exp++).valor=ob->pwlo.offset;
           (*_exp).tipo=eoper; (*_exp++).token=p_punto;
           (*_exp).tipo=eoper; (*_exp++).token=p_pointer;
           break;
         }
         if (pieza!=p_id) error(1,23); /* esperando un nombre */
-        ob=o; if ((*ob).tipo!=tnone) error(0,30); /* el nombre no es nuevo */
-        (*ob).linea=linea; (*ob).ierror=ierror;
-        (*ob).param=1;
-        (*ob).tipo=twloc; lexico();
+        ob=o; if (ob->tipo!=tnone) error(0,30); /* el nombre no es nuevo */
+        ob->linea=linea; ob->ierror=ierror;
+        ob->param=1;
+        ob->tipo=twloc; lexico();
         if (pieza==p_corab) error(2,33); /* no se puede pasar una tabla como parametro */
-        parametros++; (*ob).wloc.offset=iloc++;
-        (*ob).wloc.len1=0;
-        (*ob).wloc.len2=-1;
-        (*ob).wloc.len3=-1;
-        (*ob).wloc.totalen=1;
-        (*_exp).tipo=econs; (*_exp++).valor=(*ob).wloc.offset;
+        parametros++; ob->wloc.offset=iloc++;
+        ob->wloc.len1=0;
+        ob->wloc.len2=-1;
+        ob->wloc.len3=-1;
+        ob->wloc.totalen=1;
+        (*_exp).tipo=econs; (*_exp++).valor=ob->wloc.offset;
         (*_exp).tipo=eoper; (*_exp++).token=p_punto;
         (*_exp).tipo=econs; (*_exp++).valor=0;
         (*_exp).tipo=eoper; (*_exp++).token=p_pointerword;
@@ -748,38 +748,38 @@ void factor(void) {
           } parametros++;
           lexico();
           ob=analiza_pointer(tpilo,iloc++);
-          (*ob).linea=linea; (*ob).ierror=ierror;
-          (*ob).param=1;
-          (*_exp).tipo=econs; (*_exp++).valor=(*ob).pilo.offset;
+          ob->linea=linea; ob->ierror=ierror;
+          ob->param=1;
+          (*_exp).tipo=econs; (*_exp++).valor=ob->pilo.offset;
           (*_exp).tipo=eoper; (*_exp++).token=p_punto;
           (*_exp).tipo=eoper; (*_exp++).token=p_pointer;
           break;
         } else if (pieza!=p_id) error(1,23); /* esperando un nombre */
       }
 
-    case p_id: switch ((*o).tipo) {
+    case p_id: switch (o->tipo) {
 
       case tnone:
-        ob=o; (*ob).linea=linea; (*ob).ierror=ierror; lexico();
+        ob=o; ob->linea=linea; ob->ierror=ierror; lexico();
         if (pieza!=p_abrir) {
           if (parametros>0) {
             if (pieza==p_corab) error(2,33); /* no se puede pasar una tabla como parametro */
             parametros++;
-            (*ob).tipo=tvloc; (*ob).vloc.offset=iloc++;
-            (*ob).param=1;
-            (*_exp).tipo=econs; (*_exp++).valor=(*ob).vloc.offset;
+            ob->tipo=tvloc; ob->vloc.offset=iloc++;
+            ob->param=1;
+            (*_exp).tipo=econs; (*_exp++).valor=ob->vloc.offset;
             (*_exp).tipo=eoper; (*_exp++).token=p_punto;
             (*_exp).tipo=eoper; (*_exp++).token=p_pointer; break;
           } else {
-          	error(2,34,(*ob).name); /* nombre desconocido */
+          	error(2,34,ob->name); /* nombre desconocido */
           	lexico();
           }
         }
-        (*ob).usado=1; (*ob).tipo=tproc;
-        (*ob).proc.bloque=ob; (*ob).proc.offset=0; (*ob).proc.num_par=0;
+        ob->usado=1; ob->tipo=tproc;
+        ob->proc.bloque=ob; ob->proc.offset=0; ob->proc.num_par=0;
         lexico();
         while (pieza!=p_cerrar) {
-          (*ob).proc.num_par++;
+          ob->proc.num_par++;
           exp00(0);
           if (pieza!=p_cerrar) {
           	if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
@@ -788,7 +788,7 @@ void factor(void) {
         } (*_exp).tipo=ecall; (*_exp++).objeto=ob; lexico();  break;
 
       case tcons:
-        if ((*o).cons.literal) {
+        if (o->cons.literal) {
           tipo_factor=2;
           if (tipo_expresion==1) {
             (*_exp).tipo=econs; (*_exp++).valor=(byte)mem[pieza_num];
@@ -796,45 +796,45 @@ void factor(void) {
             (*_exp).tipo=econs; (*_exp++).valor=pieza_num;
             (*_exp).tipo=eoper; (*_exp++).token=p_strlen;
           } else {
-            (*_exp).tipo=econs; (*_exp++).valor=(*o).cons.valor;
+            (*_exp).tipo=econs; (*_exp++).valor=o->cons.valor;
           }
         } else {
-          (*_exp).tipo=econs; (*_exp++).valor=(*o).cons.valor;
+          (*_exp).tipo=econs; (*_exp++).valor=o->cons.valor;
         } lexico(); break;
 
       case tvglo:
-        (*_exp).tipo=econs; (*_exp++).valor=(*o).vglo.offset;
+        (*_exp).tipo=econs; (*_exp++).valor=o->vglo.offset;
         (*_exp).tipo=eoper; (*_exp++).token=p_pointer; lexico();  break;
         break;
 
       case ttglo:
       case tpigl:
-        ob=o; offset=(*ob).tglo.offset;
+        ob=o; offset=ob->tglo.offset;
         lexico();
         (*_exp).tipo=econs; (*_exp++).valor=offset;
         if (pieza==p_corab) {
-          if ((*ob).tipo==tpigl) {
+          if (ob->tipo==tpigl) {
             (*_exp).tipo=eoper; (*_exp++).token=p_pointer;
             if (comprueba_null) (*_exp++).tipo=enull;
           }
           lexico();
           exp00(0);
-          if ((*ob).tglo.len1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).tglo.len1; }
-          if ((*ob).tglo.len2>-1) {
+          if (ob->tglo.len1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->tglo.len1; }
+          if (ob->tglo.len2>-1) {
             if (pieza!=p_coma) error(3,35); /* se esperaba una coma (multidimension) */
             lexico();
             exp00(0);
-            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).tglo.len2; }
-            if ((*ob).tglo.len3>-1) {
+            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->tglo.len2; }
+            if (ob->tglo.len3>-1) {
               if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
               lexico();
               exp00(0);
-              if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).tglo.len3; }
-              (*_exp).tipo=econs; (*_exp++).valor=(*ob).tglo.len2+1;
+              if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->tglo.len3; }
+              (*_exp).tipo=econs; (*_exp++).valor=ob->tglo.len2+1;
               (*_exp).tipo=eoper; (*_exp++).token=p_mul;
               (*_exp).tipo=eoper; (*_exp++).token=p_add;
             }
-            (*_exp).tipo=econs; (*_exp++).valor=(*ob).tglo.len1+1;
+            (*_exp).tipo=econs; (*_exp++).valor=ob->tglo.len1+1;
             (*_exp).tipo=eoper; (*_exp++).token=p_mul;
             (*_exp).tipo=eoper; (*_exp++).token=p_add;
           }
@@ -846,10 +846,10 @@ void factor(void) {
       case tbglo:
       case tpbgl:
       case tpcgl:
-        ob=o; offset=(*ob).bglo.offset;
+        ob=o; offset=ob->bglo.offset;
         lexico();
         (*_exp).tipo=econs; (*_exp++).valor=offset;
-        if ((*ob).tipo==tpbgl || (*ob).tipo==tpcgl) {
+        if (ob->tipo==tpbgl || ob->tipo==tpcgl) {
           (*_exp).tipo=eoper; (*_exp++).token=p_pointer;
           if (pieza!=p_corab) break;
           if (comprueba_null) (*_exp++).tipo=enull;
@@ -857,22 +857,22 @@ void factor(void) {
         if (pieza==p_corab) {
           lexico();
           exp00(0);
-          if ((*ob).bglo.len1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).bglo.len1; }
-          if ((*ob).bglo.len2>-1) {
+          if (ob->bglo.len1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->bglo.len1; }
+          if (ob->bglo.len2>-1) {
             if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
             lexico();
             exp00(0);
-            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).bglo.len2; }
-            if ((*ob).bglo.len3>-1) {
+            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->bglo.len2; }
+            if (ob->bglo.len3>-1) {
               if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
               lexico();
               exp00(0);
-              if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).bglo.len3; }
-              (*_exp).tipo=econs; (*_exp++).valor=(*ob).bglo.len2+1;
+              if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->bglo.len3; }
+              (*_exp).tipo=econs; (*_exp++).valor=ob->bglo.len2+1;
               (*_exp).tipo=eoper; (*_exp++).token=p_mul;
               (*_exp).tipo=eoper; (*_exp++).token=p_add;
             }
-            (*_exp).tipo=econs; (*_exp++).valor=(*ob).bglo.len1+1;
+            (*_exp).tipo=econs; (*_exp++).valor=ob->bglo.len1+1;
             (*_exp).tipo=eoper; (*_exp++).token=p_mul;
             (*_exp).tipo=eoper; (*_exp++).token=p_add;
           }
@@ -884,10 +884,10 @@ void factor(void) {
 
       case twglo:
       case tpwgl:
-        ob=o; offset=(*ob).wglo.offset;
+        ob=o; offset=ob->wglo.offset;
         lexico();
         (*_exp).tipo=econs; (*_exp++).valor=offset;
-        if ((*ob).tipo==tpwgl) {
+        if (ob->tipo==tpwgl) {
           (*_exp).tipo=eoper; (*_exp++).token=p_pointer;
           if (pieza!=p_corab) break;
           if (comprueba_null) (*_exp++).tipo=enull;
@@ -895,22 +895,22 @@ void factor(void) {
         if (pieza==p_corab) {
           lexico();
           exp00(0);
-          if ((*ob).wglo.len1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).wglo.len1; }
-          if ((*ob).wglo.len2>-1) {
+          if (ob->wglo.len1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->wglo.len1; }
+          if (ob->wglo.len2>-1) {
             if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
             lexico();
             exp00(0);
-            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).wglo.len2; }
-            if ((*ob).wglo.len3>-1) {
+            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->wglo.len2; }
+            if (ob->wglo.len3>-1) {
               if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
               lexico();
               exp00(0);
-              if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).wglo.len3; }
-              (*_exp).tipo=econs; (*_exp++).valor=(*ob).wglo.len2+1;
+              if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->wglo.len3; }
+              (*_exp).tipo=econs; (*_exp++).valor=ob->wglo.len2+1;
               (*_exp).tipo=eoper; (*_exp++).token=p_mul;
               (*_exp).tipo=eoper; (*_exp++).token=p_add;
             }
-            (*_exp).tipo=econs; (*_exp++).valor=(*ob).wglo.len1+1;
+            (*_exp).tipo=econs; (*_exp++).valor=ob->wglo.len1+1;
             (*_exp).tipo=eoper; (*_exp++).token=p_mul;
             (*_exp).tipo=eoper; (*_exp++).token=p_add;
           }
@@ -921,13 +921,13 @@ void factor(void) {
         } (*_exp).tipo=eoper; (*_exp++).token=p_pointerword; break;
 
       case tcglo:
-        ob=o; offset=(*ob).cglo.offset;
+        ob=o; offset=ob->cglo.offset;
         lexico();
         (*_exp).tipo=estring; (*_exp++).valor=offset;
         if (pieza==p_corab) {
           lexico();
           exp00(0);
-          if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).cglo.totalen; }
+          if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->cglo.totalen; }
           if (pieza!=p_corce) error(3,19); /* esperando ']' */
           lexico();
           (*_exp).tipo=eoper; (*_exp++).token=p_pointerchar;
@@ -944,8 +944,8 @@ void factor(void) {
 
       case tsglo:
       case tpsgl:
-        ob=o; lexico(); (*_exp).tipo=econs; (*_exp++).valor=(*ob).sglo.offset;
-        if ((*ob).tipo==tpsgl) {
+        ob=o; lexico(); (*_exp).tipo=econs; (*_exp++).valor=ob->sglo.offset;
+        if (ob->tipo==tpsgl) {
           (*_exp).tipo=eoper; (*_exp++).token=p_pointer;
           if (pieza!=p_corab && pieza!=p_punto) break;
           if (comprueba_null) (*_exp++).tipo=enull;
@@ -953,37 +953,37 @@ void factor(void) {
         if (pieza==p_corab) {
           lexico();
           exp00(0);
-          if ((*ob).sglo.items1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).sglo.items1; }
-          if ((*ob).sglo.items2>-1) {
+          if (ob->sglo.items1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->sglo.items1; }
+          if (ob->sglo.items2>-1) {
             if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
             lexico();
             exp00(0);
-            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).sglo.items2; }
-            if ((*ob).sglo.items3>-1) {
+            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->sglo.items2; }
+            if (ob->sglo.items3>-1) {
               if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
               lexico();
               exp00(0);
-              if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).sglo.items3; }
-              (*_exp).tipo=econs; (*_exp++).valor=(*ob).sglo.items2+1;
+              if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->sglo.items3; }
+              (*_exp).tipo=econs; (*_exp++).valor=ob->sglo.items2+1;
               (*_exp).tipo=eoper; (*_exp++).token=p_mul;
               (*_exp).tipo=eoper; (*_exp++).token=p_add;
             }
-            (*_exp).tipo=econs; (*_exp++).valor=(*ob).sglo.items1+1;
+            (*_exp).tipo=econs; (*_exp++).valor=ob->sglo.items1+1;
             (*_exp).tipo=eoper; (*_exp++).token=p_mul;
             (*_exp).tipo=eoper; (*_exp++).token=p_add;
           }
           if (pieza!=p_corce) error(3,19); lexico(); /* esperando ']' */
-          if ((*ob).tipo==tpsgl) {
-            (*_exp).tipo=econs; (*_exp++).valor=(*((*ob).psgl.ostruct)).sglo.len_item;
+          if (ob->tipo==tpsgl) {
+            (*_exp).tipo=econs; (*_exp++).valor=(*(ob->psgl.ostruct)).sglo.len_item;
           } else {
-            (*_exp).tipo=econs; (*_exp++).valor=(*ob).sglo.len_item;
+            (*_exp).tipo=econs; (*_exp++).valor=ob->sglo.len_item;
           }
           (*_exp).tipo=eoper; (*_exp++).token=p_mul;
           (*_exp).tipo=eoper; (*_exp++).token=p_add;
         }
         if (pieza==p_punto) {
           struct_pointer=p_pointer;
-          if ((*ob).tipo==tpsgl) member=(*ob).psgl.ostruct; else member=ob;
+          if (ob->tipo==tpsgl) member=ob->psgl.ostruct; else member=ob;
           lexico(); factor_struct();
           (*_exp).tipo=eoper; (*_exp++).token=struct_pointer;
         } else {
@@ -991,42 +991,42 @@ void factor(void) {
         } break;
 
       case tvloc:
-        if (acceso_remoto && (*o).bloque) error(0,37); /* no se puede acceder a PRIVATE externos */
-        (*_exp).tipo=econs; (*_exp++).valor=(*o).vloc.offset;
+        if (acceso_remoto && o->bloque) error(0,37); /* no se puede acceder a PRIVATE externos */
+        (*_exp).tipo=econs; (*_exp++).valor=o->vloc.offset;
         (*_exp).tipo=eoper; (*_exp++).token=p_punto;
         (*_exp).tipo=eoper; (*_exp++).token=p_pointer; lexico(); break;
 
       case ttloc:
       case tpilo:
-        if (acceso_remoto && (*o).bloque) error(0,37); /* no se puede acceder a PRIVATE externos */
-        ob=o; offset=(*ob).tloc.offset;
+        if (acceso_remoto && o->bloque) error(0,37); /* no se puede acceder a PRIVATE externos */
+        ob=o; offset=ob->tloc.offset;
         lexico();
         (*_exp).tipo=econs; (*_exp++).valor=offset;
         (*_exp).tipo=eoper; (*_exp++).token=p_punto;
         if (pieza==p_corab) {
-          if ((*ob).tipo==tpilo) {
+          if (ob->tipo==tpilo) {
             (*_exp).tipo=eoper; (*_exp++).token=p_pointer;
             if (comprueba_null) (*_exp++).tipo=enull;
           }
           acceso_remoto=0;
           lexico();
           exp00(0);
-          if ((*ob).tloc.len1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).tloc.len1; }
-          if ((*ob).tloc.len2>-1) {
+          if (ob->tloc.len1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->tloc.len1; }
+          if (ob->tloc.len2>-1) {
             if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
             lexico();
             exp00(0);
-            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).tloc.len2; }
-            if ((*ob).tloc.len3>-1) {
+            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->tloc.len2; }
+            if (ob->tloc.len3>-1) {
               if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
               lexico();
               exp00(0);
-              if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).tloc.len3; }
-              (*_exp).tipo=econs; (*_exp++).valor=(*ob).tloc.len2+1;
+              if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->tloc.len3; }
+              (*_exp).tipo=econs; (*_exp++).valor=ob->tloc.len2+1;
               (*_exp).tipo=eoper; (*_exp++).token=p_mul;
               (*_exp).tipo=eoper; (*_exp++).token=p_add;
             }
-            (*_exp).tipo=econs; (*_exp++).valor=(*ob).tloc.len1+1;
+            (*_exp).tipo=econs; (*_exp++).valor=ob->tloc.len1+1;
             (*_exp).tipo=eoper; (*_exp++).token=p_mul;
             (*_exp).tipo=eoper; (*_exp++).token=p_add;
           }
@@ -1039,12 +1039,12 @@ void factor(void) {
       case tbloc:
       case tpblo:
       case tpclo:
-        if (acceso_remoto && (*o).bloque) error(0,37); /* no se puede acceder a PRIVATE externos */
-        ob=o; offset=(*ob).bloc.offset;
+        if (acceso_remoto && o->bloque) error(0,37); /* no se puede acceder a PRIVATE externos */
+        ob=o; offset=ob->bloc.offset;
         lexico();
         (*_exp).tipo=econs; (*_exp++).valor=offset;
         (*_exp).tipo=eoper; (*_exp++).token=p_punto;
-        if ((*ob).tipo==tpblo || (*ob).tipo==tpclo) {
+        if (ob->tipo==tpblo || ob->tipo==tpclo) {
           (*_exp).tipo=eoper; (*_exp++).token=p_pointer;
           if (pieza!=p_corab) break;
           if (comprueba_null) (*_exp++).tipo=enull;
@@ -1053,22 +1053,22 @@ void factor(void) {
           acceso_remoto=0;
           lexico();
           exp00(0);
-          if ((*ob).bloc.len1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).bloc.len1; }
-          if ((*ob).bloc.len2>-1) {
+          if (ob->bloc.len1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->bloc.len1; }
+          if (ob->bloc.len2>-1) {
             if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
             lexico();
             exp00(0);
-            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).bloc.len2; }
-            if ((*ob).bloc.len3>-1) {
+            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->bloc.len2; }
+            if (ob->bloc.len3>-1) {
               if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
               lexico();
               exp00(0);
-              if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).bloc.len3; }
-              (*_exp).tipo=econs; (*_exp++).valor=(*ob).bloc.len2+1;
+              if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->bloc.len3; }
+              (*_exp).tipo=econs; (*_exp++).valor=ob->bloc.len2+1;
               (*_exp).tipo=eoper; (*_exp++).token=p_mul;
               (*_exp).tipo=eoper; (*_exp++).token=p_add;
             }
-            (*_exp).tipo=econs; (*_exp++).valor=(*ob).bloc.len1+1;
+            (*_exp).tipo=econs; (*_exp++).valor=ob->bloc.len1+1;
             (*_exp).tipo=eoper; (*_exp++).token=p_mul;
             (*_exp).tipo=eoper; (*_exp++).token=p_add;
           }
@@ -1080,12 +1080,12 @@ void factor(void) {
 
       case twloc:
       case tpwlo:
-        if (acceso_remoto && (*o).bloque) error(0,37); /* no se puede acceder a PRIVATE externos */
-        ob=o; offset=(*ob).wloc.offset;
+        if (acceso_remoto && o->bloque) error(0,37); /* no se puede acceder a PRIVATE externos */
+        ob=o; offset=ob->wloc.offset;
         lexico();
         (*_exp).tipo=econs; (*_exp++).valor=offset;
         (*_exp).tipo=eoper; (*_exp++).token=p_punto;
-        if ((*ob).tipo==tpwlo) {
+        if (ob->tipo==tpwlo) {
           (*_exp).tipo=eoper; (*_exp++).token=p_pointer;
           if (pieza!=p_corab) break;
           if (comprueba_null) (*_exp++).tipo=enull;
@@ -1094,22 +1094,22 @@ void factor(void) {
           acceso_remoto=0;
           lexico();
           exp00(0);
-          if ((*ob).wloc.len1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).wloc.len1; }
-          if ((*ob).wloc.len2>-1) {
+          if (ob->wloc.len1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->wloc.len1; }
+          if (ob->wloc.len2>-1) {
             if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
             lexico();
             exp00(0);
-            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).wloc.len2; }
-            if ((*ob).wloc.len3>-1) {
+            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->wloc.len2; }
+            if (ob->wloc.len3>-1) {
               if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
               lexico();
               exp00(0);
-              if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).wloc.len3; }
-              (*_exp).tipo=econs; (*_exp++).valor=(*ob).wloc.len2+1;
+              if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->wloc.len3; }
+              (*_exp).tipo=econs; (*_exp++).valor=ob->wloc.len2+1;
               (*_exp).tipo=eoper; (*_exp++).token=p_mul;
               (*_exp).tipo=eoper; (*_exp++).token=p_add;
             }
-            (*_exp).tipo=econs; (*_exp++).valor=(*ob).wloc.len1+1;
+            (*_exp).tipo=econs; (*_exp++).valor=ob->wloc.len1+1;
             (*_exp).tipo=eoper; (*_exp++).token=p_mul;
             (*_exp).tipo=eoper; (*_exp++).token=p_add;
           }
@@ -1120,8 +1120,8 @@ void factor(void) {
         } (*_exp).tipo=eoper; (*_exp++).token=p_pointerword; break;
 
       case tcloc:
-        if (acceso_remoto && (*o).bloque) error(0,37);  /* no se puede acceder a PRIVATE externos */
-        ob=o; offset=(*ob).cloc.offset;
+        if (acceso_remoto && o->bloque) error(0,37);  /* no se puede acceder a PRIVATE externos */
+        ob=o; offset=ob->cloc.offset;
         lexico();
         (*_exp).tipo=estring; (*_exp++).valor=offset;
         (*_exp).tipo=eoper; (*_exp++).token=p_punto;
@@ -1129,7 +1129,7 @@ void factor(void) {
           acceso_remoto=0;
           lexico();
           exp00(0);
-          if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).cloc.totalen; }
+          if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->cloc.totalen; }
           if (pieza!=p_corce) error(3,19); /* esperando ']' */
           lexico();
           (*_exp).tipo=eoper; (*_exp++).token=p_pointerchar;
@@ -1146,10 +1146,10 @@ void factor(void) {
 
       case tsloc:
       case tpslo:
-        if (acceso_remoto && (*o).bloque) error(0,37); /* no se puede acceder a PRIVATE externos */
-        ob=o; lexico(); (*_exp).tipo=econs; (*_exp++).valor=(*ob).sloc.offset;
+        if (acceso_remoto && o->bloque) error(0,37); /* no se puede acceder a PRIVATE externos */
+        ob=o; lexico(); (*_exp).tipo=econs; (*_exp++).valor=ob->sloc.offset;
         (*_exp).tipo=eoper; (*_exp++).token=p_punto;
-        if ((*ob).tipo==tpslo) {
+        if (ob->tipo==tpslo) {
           (*_exp).tipo=eoper; (*_exp++).token=p_pointer;
           if (pieza!=p_corab && pieza!=p_punto) break;
           if (comprueba_null) (*_exp++).tipo=enull;
@@ -1158,37 +1158,37 @@ void factor(void) {
           acceso_remoto=0;
           lexico();
           exp00(0);
-          if ((*ob).sloc.items1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).sloc.items1; }
-          if ((*ob).sloc.items2>-1) {
+          if (ob->sloc.items1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->sloc.items1; }
+          if (ob->sloc.items2>-1) {
             if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
             lexico();
             exp00(0);
-            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).sloc.items2; }
-            if ((*ob).sloc.items3>-1) {
+            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->sloc.items2; }
+            if (ob->sloc.items3>-1) {
               if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
               lexico();
               exp00(0);
-              if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).sloc.items3; }
-              (*_exp).tipo=econs; (*_exp++).valor=(*ob).sloc.items2+1;
+              if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->sloc.items3; }
+              (*_exp).tipo=econs; (*_exp++).valor=ob->sloc.items2+1;
               (*_exp).tipo=eoper; (*_exp++).token=p_mul;
               (*_exp).tipo=eoper; (*_exp++).token=p_add;
             }
-            (*_exp).tipo=econs; (*_exp++).valor=(*ob).sloc.items1+1;
+            (*_exp).tipo=econs; (*_exp++).valor=ob->sloc.items1+1;
             (*_exp).tipo=eoper; (*_exp++).token=p_mul;
             (*_exp).tipo=eoper; (*_exp++).token=p_add;
           }
           if (pieza!=p_corce) error(3,19); lexico(); /* esperando ']' */
-          if ((*ob).tipo==tpslo) {
-            (*_exp).tipo=econs; (*_exp++).valor=(*((*ob).pslo.ostruct)).sloc.len_item;
+          if (ob->tipo==tpslo) {
+            (*_exp).tipo=econs; (*_exp++).valor=(*(ob->pslo.ostruct)).sloc.len_item;
           } else {
-            (*_exp).tipo=econs; (*_exp++).valor=(*ob).sloc.len_item;
+            (*_exp).tipo=econs; (*_exp++).valor=ob->sloc.len_item;
           }
           (*_exp).tipo=eoper; (*_exp++).token=p_mul;
           (*_exp).tipo=eoper; (*_exp++).token=p_add;
         }
         if (pieza==p_punto) {
           struct_pointer=p_pointer;
-          if ((*ob).tipo==tpslo) member=(*ob).psgl.ostruct; else member=ob;
+          if (ob->tipo==tpslo) member=ob->psgl.ostruct; else member=ob;
           lexico(); factor_struct();
           (*_exp).tipo=eoper; (*_exp++).token=struct_pointer;
         } else {
@@ -1205,7 +1205,7 @@ void factor(void) {
           	else { lexico(); if (pieza==p_cerrar) error(3,36); } /* se esperaba otro parametro */
           }
         }
-        if (p!=(*ob).proc.num_par) error(1,38); /* numero de parametros incorrecto */
+        if (p!=ob->proc.num_par) error(1,38); /* numero de parametros incorrecto */
         (*_exp).tipo=ecall; (*_exp++).objeto=ob; lexico(); break;
 
       // POR HACER: implementar soporte para qsort (ver comentario aquí arriba)
@@ -1224,8 +1224,8 @@ void factor(void) {
 
 		while(1) {
 			if(ob==NULL) break;
-			if((*ob).tipo==tfext && (*ob).fext.num_par==p) break;
-			ob=(*ob).anterior;
+			if(ob->tipo==tfext && ob->fext.num_par==p) break;
+			ob=ob->anterior;
 		}
 		if(ob==NULL) error(1,38); /* numero de parametros incorrecto */
         (*_exp).tipo=efext; (*_exp++).objeto=ob; lexico(); break;
@@ -1280,42 +1280,42 @@ void factor_struct(void) {
   struct objeto * ob;
 
   if (pieza!=p_id) error(3,39); /* esperando un elemento de la estructura */
-  switch ((*o).tipo) {
+  switch (o->tipo) {
 
     case tvglo:
-      (*_exp).tipo=econs; (*_exp++).valor=(*o).vglo.offset;
+      (*_exp).tipo=econs; (*_exp++).valor=o->vglo.offset;
       (*_exp).tipo=eoper; (*_exp++).token=p_add;
       member=NULL; lexico();
       break;
 
     case ttglo:
     case tpigl:
-      (*_exp).tipo=econs; (*_exp++).valor=(*o).tglo.offset; ob=o;
+      (*_exp).tipo=econs; (*_exp++).valor=o->tglo.offset; ob=o;
       (*_exp).tipo=eoper; (*_exp++).token=p_add;
       member=NULL; lexico();
       if (pieza==p_corab) {
-        if ((*ob).tipo==tpigl) {
+        if (ob->tipo==tpigl) {
           (*_exp).tipo=eoper; (*_exp++).token=p_pointer;
           if (comprueba_null) (*_exp++).tipo=enull;
         }
         lexico();
         exp00(0);
-        if ((*ob).tglo.len1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).tglo.len1; }
-        if ((*ob).tglo.len2>-1) {
+        if (ob->tglo.len1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->tglo.len1; }
+        if (ob->tglo.len2>-1) {
           if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
           lexico();
           exp00(0);
-          if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).tglo.len2; }
-          if ((*ob).tglo.len3>-1) {
+          if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->tglo.len2; }
+          if (ob->tglo.len3>-1) {
             if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
             lexico();
             exp00(0);
-            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).tglo.len3; }
-            (*_exp).tipo=econs; (*_exp++).valor=(*ob).tglo.len2+1;
+            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->tglo.len3; }
+            (*_exp).tipo=econs; (*_exp++).valor=ob->tglo.len2+1;
             (*_exp).tipo=eoper; (*_exp++).token=p_mul;
             (*_exp).tipo=eoper; (*_exp++).token=p_add;
           }
-          (*_exp).tipo=econs; (*_exp++).valor=(*ob).tglo.len1+1;
+          (*_exp).tipo=econs; (*_exp++).valor=ob->tglo.len1+1;
           (*_exp).tipo=eoper; (*_exp++).token=p_mul;
           (*_exp).tipo=eoper; (*_exp++).token=p_add;
         }
@@ -1326,10 +1326,10 @@ void factor_struct(void) {
     case tbglo:
     case tpbgl:
     case tpcgl:
-      (*_exp).tipo=econs; (*_exp++).valor=(*o).bglo.offset; ob=o;
+      (*_exp).tipo=econs; (*_exp++).valor=o->bglo.offset; ob=o;
       (*_exp).tipo=eoper; (*_exp++).token=p_add;
       member=NULL; lexico();
-      if ((*ob).tipo==tpbgl || (*ob).tipo==tpcgl) {
+      if (ob->tipo==tpbgl || ob->tipo==tpcgl) {
         if (pieza!=p_corab) break;
         (*_exp).tipo=eoper; (*_exp++).token=p_pointer;
         if (comprueba_null) (*_exp++).tipo=enull;
@@ -1337,22 +1337,22 @@ void factor_struct(void) {
       if (pieza==p_corab) {
         lexico();
         exp00(0);
-        if ((*ob).bglo.len1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).bglo.len1; }
-        if ((*ob).bglo.len2>-1) {
+        if (ob->bglo.len1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->bglo.len1; }
+        if (ob->bglo.len2>-1) {
           if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
           lexico();
           exp00(0);
-          if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).bglo.len2; }
-          if ((*ob).bglo.len3>-1) {
+          if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->bglo.len2; }
+          if (ob->bglo.len3>-1) {
             if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
             lexico();
             exp00(0);
-            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).bglo.len3; }
-            (*_exp).tipo=econs; (*_exp++).valor=(*ob).bglo.len2+1;
+            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->bglo.len3; }
+            (*_exp).tipo=econs; (*_exp++).valor=ob->bglo.len2+1;
             (*_exp).tipo=eoper; (*_exp++).token=p_mul;
             (*_exp).tipo=eoper; (*_exp++).token=p_add;
           }
-          (*_exp).tipo=econs; (*_exp++).valor=(*ob).bglo.len1+1;
+          (*_exp).tipo=econs; (*_exp++).valor=ob->bglo.len1+1;
           (*_exp).tipo=eoper; (*_exp++).token=p_mul;
           (*_exp).tipo=eoper; (*_exp++).token=p_add;
         }
@@ -1363,10 +1363,10 @@ void factor_struct(void) {
 
     case twglo:
     case tpwgl:
-      (*_exp).tipo=econs; (*_exp++).valor=(*o).wglo.offset; ob=o;
+      (*_exp).tipo=econs; (*_exp++).valor=o->wglo.offset; ob=o;
       (*_exp).tipo=eoper; (*_exp++).token=p_add;
       member=NULL; lexico();
-      if ((*ob).tipo==tpwgl) {
+      if (ob->tipo==tpwgl) {
         if (pieza!=p_corab) break;
         (*_exp).tipo=eoper; (*_exp++).token=p_pointer;
         if (comprueba_null) (*_exp++).tipo=enull;
@@ -1374,22 +1374,22 @@ void factor_struct(void) {
       if (pieza==p_corab) {
         lexico();
         exp00(0);
-        if ((*ob).wglo.len1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).wglo.len1; }
-        if ((*ob).wglo.len2>-1) {
+        if (ob->wglo.len1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->wglo.len1; }
+        if (ob->wglo.len2>-1) {
           if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
           lexico();
           exp00(0);
-          if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).wglo.len2; }
-          if ((*ob).wglo.len3>-1) {
+          if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->wglo.len2; }
+          if (ob->wglo.len3>-1) {
             if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
             lexico();
             exp00(0);
-            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).wglo.len3; }
-            (*_exp).tipo=econs; (*_exp++).valor=(*ob).wglo.len2+1;
+            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->wglo.len3; }
+            (*_exp).tipo=econs; (*_exp++).valor=ob->wglo.len2+1;
             (*_exp).tipo=eoper; (*_exp++).token=p_mul;
             (*_exp).tipo=eoper; (*_exp++).token=p_add;
           }
-          (*_exp).tipo=econs; (*_exp++).valor=(*ob).wglo.len1+1;
+          (*_exp).tipo=econs; (*_exp++).valor=ob->wglo.len1+1;
           (*_exp).tipo=eoper; (*_exp++).token=p_mul;
           (*_exp).tipo=eoper; (*_exp++).token=p_add;
         }
@@ -1399,13 +1399,13 @@ void factor_struct(void) {
       } struct_pointer=p_pointerword; break;
 
     case tcglo:
-      (*_exp).tipo=estring; (*_exp++).valor=(*o).cglo.offset; ob=o;
+      (*_exp).tipo=estring; (*_exp++).valor=o->cglo.offset; ob=o;
       (*_exp).tipo=eoper; (*_exp++).token=p_add;
       member=NULL; lexico();
       if (pieza==p_corab) {
         lexico();
         exp00(0);
-        if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).cglo.totalen; }
+        if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->cglo.totalen; }
         if (pieza!=p_corce) error(3,19); /* esperando ']' */
         lexico();
         struct_pointer=p_pointerchar;
@@ -1422,10 +1422,10 @@ void factor_struct(void) {
 
     case tsglo:
     case tpsgl:
-      (*_exp).tipo=econs; (*_exp++).valor=(*o).sglo.offset; ob=o;
+      (*_exp).tipo=econs; (*_exp++).valor=o->sglo.offset; ob=o;
       (*_exp).tipo=eoper; (*_exp++).token=p_add;
       member=NULL; lexico();
-      if ((*ob).tipo==tpsgl) {
+      if (ob->tipo==tpsgl) {
         if (pieza!=p_corab && pieza!=p_punto) break;
         (*_exp).tipo=eoper; (*_exp++).token=p_pointer;
         if (comprueba_null) (*_exp++).tipo=enull;
@@ -1433,72 +1433,72 @@ void factor_struct(void) {
       if (pieza==p_corab) {
         lexico();
         exp00(0);
-        if ((*ob).sglo.items1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).sglo.items1; }
-        if ((*ob).sglo.items2>-1) {
+        if (ob->sglo.items1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->sglo.items1; }
+        if (ob->sglo.items2>-1) {
           if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
           lexico();
           exp00(0);
-          if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).sglo.items2; }
-          if ((*ob).sglo.items3>-1) {
+          if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->sglo.items2; }
+          if (ob->sglo.items3>-1) {
             if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
             lexico();
             exp00(0);
-            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).sglo.items3; }
-            (*_exp).tipo=econs; (*_exp++).valor=(*ob).sglo.items2+1;
+            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->sglo.items3; }
+            (*_exp).tipo=econs; (*_exp++).valor=ob->sglo.items2+1;
             (*_exp).tipo=eoper; (*_exp++).token=p_mul;
             (*_exp).tipo=eoper; (*_exp++).token=p_add;
           }
-          (*_exp).tipo=econs; (*_exp++).valor=(*ob).sglo.items1+1;
+          (*_exp).tipo=econs; (*_exp++).valor=ob->sglo.items1+1;
           (*_exp).tipo=eoper; (*_exp++).token=p_mul;
           (*_exp).tipo=eoper; (*_exp++).token=p_add;
         }
         if (pieza!=p_corce) error(3,19); lexico(); /* esperando ']' */
-        if ((*ob).tipo==tpsgl) {
-          (*_exp).tipo=econs; (*_exp++).valor=(*((*ob).psgl.ostruct)).sglo.len_item;
+        if (ob->tipo==tpsgl) {
+          (*_exp).tipo=econs; (*_exp++).valor=(*(ob->psgl.ostruct)).sglo.len_item;
         } else {
-          (*_exp).tipo=econs; (*_exp++).valor=(*ob).sglo.len_item;
+          (*_exp).tipo=econs; (*_exp++).valor=ob->sglo.len_item;
         }
         (*_exp).tipo=eoper; (*_exp++).token=p_mul;
         (*_exp).tipo=eoper; (*_exp++).token=p_add;
       }
       if (pieza==p_punto) {
-        if ((*ob).tipo==tpsgl) member=(*ob).psgl.ostruct; else member=ob;
+        if (ob->tipo==tpsgl) member=ob->psgl.ostruct; else member=ob;
         lexico(); factor_struct();
       } break;
 
     case tvloc:
-      (*_exp).tipo=econs; (*_exp++).valor=(*o).vloc.offset;
+      (*_exp).tipo=econs; (*_exp++).valor=o->vloc.offset;
       (*_exp).tipo=eoper; (*_exp++).token=p_add;
       member=NULL; lexico(); break;
 
     case ttloc:
     case tpilo:
-      (*_exp).tipo=econs; (*_exp++).valor=(*o).tloc.offset; ob=o;
+      (*_exp).tipo=econs; (*_exp++).valor=o->tloc.offset; ob=o;
       (*_exp).tipo=eoper; (*_exp++).token=p_add;
       member=NULL; lexico();
       if (pieza==p_corab) {
-        if ((*ob).tipo==tpilo) {
+        if (ob->tipo==tpilo) {
           (*_exp).tipo=eoper; (*_exp++).token=p_pointer;
           if (comprueba_null) (*_exp++).tipo=enull;
         }
         lexico();
         exp00(0);
-        if ((*ob).tloc.len1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).tloc.len1; }
-        if ((*ob).tloc.len2>-1) {
+        if (ob->tloc.len1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->tloc.len1; }
+        if (ob->tloc.len2>-1) {
           if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
           lexico();
           exp00(0);
-          if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).tloc.len2; }
-          if ((*ob).tloc.len3>-1) {
+          if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->tloc.len2; }
+          if (ob->tloc.len3>-1) {
             if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
             lexico();
             exp00(0);
-            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).tloc.len3; }
-            (*_exp).tipo=econs; (*_exp++).valor=(*ob).tloc.len2+1;
+            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->tloc.len3; }
+            (*_exp).tipo=econs; (*_exp++).valor=ob->tloc.len2+1;
             (*_exp).tipo=eoper; (*_exp++).token=p_mul;
             (*_exp).tipo=eoper; (*_exp++).token=p_add;
           }
-          (*_exp).tipo=econs; (*_exp++).valor=(*ob).tloc.len1+1;
+          (*_exp).tipo=econs; (*_exp++).valor=ob->tloc.len1+1;
           (*_exp).tipo=eoper; (*_exp++).token=p_mul;
           (*_exp).tipo=eoper; (*_exp++).token=p_add;
         }
@@ -1509,10 +1509,10 @@ void factor_struct(void) {
     case tbloc:
     case tpblo:
     case tpclo:
-      (*_exp).tipo=econs; (*_exp++).valor=(*o).bloc.offset; ob=o;
+      (*_exp).tipo=econs; (*_exp++).valor=o->bloc.offset; ob=o;
       (*_exp).tipo=eoper; (*_exp++).token=p_add;
       member=NULL; lexico();
-      if ((*ob).tipo==tpblo || (*ob).tipo==tpcgl) {
+      if (ob->tipo==tpblo || ob->tipo==tpcgl) {
         if (pieza!=p_corab) break;
         (*_exp).tipo=eoper; (*_exp++).token=p_pointer;
         if (comprueba_null) (*_exp++).tipo=enull;
@@ -1520,22 +1520,22 @@ void factor_struct(void) {
       if (pieza==p_corab) {
         lexico();
         exp00(0);
-        if ((*ob).bloc.len1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).bloc.len1; }
-        if ((*ob).bloc.len2>-1) {
+        if (ob->bloc.len1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->bloc.len1; }
+        if (ob->bloc.len2>-1) {
           if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
           lexico();
           exp00(0);
-          if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).bloc.len2; }
-          if ((*ob).bloc.len3>-1) {
+          if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->bloc.len2; }
+          if (ob->bloc.len3>-1) {
             if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
             lexico();
             exp00(0);
-            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).bloc.len3; }
-            (*_exp).tipo=econs; (*_exp++).valor=(*ob).bloc.len2+1;
+            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->bloc.len3; }
+            (*_exp).tipo=econs; (*_exp++).valor=ob->bloc.len2+1;
             (*_exp).tipo=eoper; (*_exp++).token=p_mul;
             (*_exp).tipo=eoper; (*_exp++).token=p_add;
           }
-          (*_exp).tipo=econs; (*_exp++).valor=(*ob).bloc.len1+1;
+          (*_exp).tipo=econs; (*_exp++).valor=ob->bloc.len1+1;
           (*_exp).tipo=eoper; (*_exp++).token=p_mul;
           (*_exp).tipo=eoper; (*_exp++).token=p_add;
         }
@@ -1546,10 +1546,10 @@ void factor_struct(void) {
 
     case twloc:
     case tpwlo:
-      (*_exp).tipo=econs; (*_exp++).valor=(*o).wloc.offset; ob=o;
+      (*_exp).tipo=econs; (*_exp++).valor=o->wloc.offset; ob=o;
       (*_exp).tipo=eoper; (*_exp++).token=p_add;
       member=NULL; lexico();
-      if ((*ob).tipo==tpwlo) {
+      if (ob->tipo==tpwlo) {
         if (pieza!=p_corab) break;
         (*_exp).tipo=eoper; (*_exp++).token=p_pointer;
         if (comprueba_null) (*_exp++).tipo=enull;
@@ -1557,22 +1557,22 @@ void factor_struct(void) {
       if (pieza==p_corab) {
         lexico();
         exp00(0);
-        if ((*ob).wloc.len1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).wloc.len1; }
-        if ((*ob).wloc.len2>-1) {
+        if (ob->wloc.len1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->wloc.len1; }
+        if (ob->wloc.len2>-1) {
           if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
           lexico();
           exp00(0);
-          if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).wloc.len2; }
-          if ((*ob).wloc.len3>-1) {
+          if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->wloc.len2; }
+          if (ob->wloc.len3>-1) {
             if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
             lexico();
             exp00(0);
-            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).wloc.len3; }
-            (*_exp).tipo=econs; (*_exp++).valor=(*ob).wloc.len2+1;
+            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->wloc.len3; }
+            (*_exp).tipo=econs; (*_exp++).valor=ob->wloc.len2+1;
             (*_exp).tipo=eoper; (*_exp++).token=p_mul;
             (*_exp).tipo=eoper; (*_exp++).token=p_add;
           }
-          (*_exp).tipo=econs; (*_exp++).valor=(*ob).wloc.len1+1;
+          (*_exp).tipo=econs; (*_exp++).valor=ob->wloc.len1+1;
           (*_exp).tipo=eoper; (*_exp++).token=p_mul;
           (*_exp).tipo=eoper; (*_exp++).token=p_add;
         }
@@ -1582,13 +1582,13 @@ void factor_struct(void) {
       } struct_pointer=p_pointerword; break;
 
     case tcloc:
-      (*_exp).tipo=estring; (*_exp++).valor=(*o).cloc.offset; ob=o;
+      (*_exp).tipo=estring; (*_exp++).valor=o->cloc.offset; ob=o;
       (*_exp).tipo=eoper; (*_exp++).token=p_add;
       member=NULL; lexico();
       if (pieza==p_corab) {
         lexico();
         exp00(0);
-        if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).cloc.totalen; }
+        if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->cloc.totalen; }
         if (pieza!=p_corce) error(3,19); /* esperando ']' */
         lexico();
         struct_pointer=p_pointerchar;
@@ -1605,10 +1605,10 @@ void factor_struct(void) {
 
     case tsloc:
     case tpslo:
-      (*_exp).tipo=econs; (*_exp++).valor=(*o).sloc.offset; ob=o;
+      (*_exp).tipo=econs; (*_exp++).valor=o->sloc.offset; ob=o;
       (*_exp).tipo=eoper; (*_exp++).token=p_add;
       member=NULL; lexico();
-      if ((*ob).tipo==tpslo) {
+      if (ob->tipo==tpslo) {
         if (pieza!=p_corab && pieza!=p_punto) break;
         (*_exp).tipo=eoper; (*_exp++).token=p_pointer;
         if (comprueba_null) (*_exp++).tipo=enull;
@@ -1616,36 +1616,36 @@ void factor_struct(void) {
       if (pieza==p_corab) {
         lexico();
         exp00(0);
-        if ((*ob).sloc.items1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).sloc.items1; }
-        if ((*ob).sloc.items2>-1) {
+        if (ob->sloc.items1>-1) if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->sloc.items1; }
+        if (ob->sloc.items2>-1) {
           if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
           lexico();
           exp00(0);
-          if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).sloc.items2; }
-          if ((*ob).sloc.items3>-1) {
+          if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->sloc.items2; }
+          if (ob->sloc.items3>-1) {
             if (pieza!=p_coma) error(3,35); /* se esperaba una coma */
             lexico();
             exp00(0);
-            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=(*ob).sloc.items3; }
-            (*_exp).tipo=econs; (*_exp++).valor=(*ob).sloc.items2+1;
+            if (comprueba_rango) { (*_exp).tipo=erango; (*_exp++).valor=ob->sloc.items3; }
+            (*_exp).tipo=econs; (*_exp++).valor=ob->sloc.items2+1;
             (*_exp).tipo=eoper; (*_exp++).token=p_mul;
             (*_exp).tipo=eoper; (*_exp++).token=p_add;
           }
-          (*_exp).tipo=econs; (*_exp++).valor=(*ob).sloc.items1+1;
+          (*_exp).tipo=econs; (*_exp++).valor=ob->sloc.items1+1;
           (*_exp).tipo=eoper; (*_exp++).token=p_mul;
           (*_exp).tipo=eoper; (*_exp++).token=p_add;
         }
         if (pieza!=p_corce) error(3,19); lexico(); /* esperando ']' */
-        if ((*ob).tipo==tpslo) {
-          (*_exp).tipo=econs; (*_exp++).valor=(*((*ob).pslo.ostruct)).sloc.len_item;
+        if (ob->tipo==tpslo) {
+          (*_exp).tipo=econs; (*_exp++).valor=(*(ob->pslo.ostruct)).sloc.len_item;
         } else {
-          (*_exp).tipo=econs; (*_exp++).valor=(*ob).sloc.len_item;
+          (*_exp).tipo=econs; (*_exp++).valor=ob->sloc.len_item;
         }
         (*_exp).tipo=eoper; (*_exp++).token=p_mul;
         (*_exp).tipo=eoper; (*_exp++).token=p_add;
       }
       if (pieza==p_punto) {
-        if ((*ob).tipo==tpslo) member=(*ob).pslo.ostruct; else member=ob;
+        if (ob->tipo==tpslo) member=ob->pslo.ostruct; else member=ob;
         lexico(); factor_struct();
       } break;
 
diff --git a/ediv/src/ediv/expresion.h b/ediv/src/ediv/expresion.h
index 0ca34af..141ddc9 100644
--- a/ediv/src/ediv/expresion.h
+++ b/ediv/src/ediv/expresion.h
@@ -57,4 +57,4 @@ void expresion_cpa(void);
 void generar_expresion(void);
 int constante(void);
 
-#endif
\ No newline at end of file
+#endif
diff --git a/ediv/src/ediv/listados.h b/ediv/src/ediv/listados.h
index 09d052d..893d072 100644
--- a/ediv/src/ediv/listados.h
+++ b/ediv/src/ediv/listados.h
@@ -24,4 +24,4 @@
 void listado_objetos (void);
 void listado_ensamblador (void);
 
-#endif
\ No newline at end of file
+#endif
diff --git a/ediv/src/ediv/ltlex.c b/ediv/src/ediv/ltlex.c
index dc44a8e..cfdd781 100644
--- a/ediv/src/ediv/ltlex.c
+++ b/ediv/src/ediv/ltlex.c
@@ -123,27 +123,27 @@ void analiza_ltlex(void){
 						if (num_nodos++==max_nodos)
 							ltlex_error(3);
 						e=lex_case[*buf]=ilex_simb++;
-						(*e).caracter=*buf++;			
+						e->caracter=*buf++;			
 					} 
 					else
 						buf++;
 					while (*buf!=' ' && *buf!=tab && *buf!=cr) {
 						if (lower[*buf]) ltlex_error(4);
-						if ((*e).siguiente==0)
+						if (e->siguiente==0)
 							if (num_nodos++==max_nodos) ltlex_error(3);
-							else e=(*e).siguiente=ilex_simb++;
+							else e=e->siguiente=ilex_simb++;
 						else {
-							e=(*e).siguiente;
-							while ((*e).caracter!=*buf && (*e).alternativa)
-								e=(*e).alternativa;
-							if ((*e).caracter!=*buf) {
+							e=e->siguiente;
+							while (e->caracter!=*buf && e->alternativa)
+								e=e->alternativa;
+							if (e->caracter!=*buf) {
 								if (num_nodos++==max_nodos) ltlex_error(3);
-								else e=(*e).alternativa=ilex_simb++;
+								else e=e->alternativa=ilex_simb++;
 							}
 						}
-						(*e).caracter=*buf++;
+						e->caracter=*buf++;
 					}
-					(*e).token=t;
+					e->token=t;
 				} break;
 		}} while (cont);
 
diff --git a/ediv/src/ediv/main.h b/ediv/src/ediv/main.h
index 95e8c47..7898836 100644
--- a/ediv/src/ediv/main.h
+++ b/ediv/src/ediv/main.h
@@ -69,4 +69,4 @@ void save_error(word tipo);			 /* guarda una posición de error
 void error(word tipo,word num, ...); /* error de compilación                              */
 void warning(int num, ...);			 /* warning en el proceso                             */
 
-#endif
\ No newline at end of file
+#endif
diff --git a/ediv/src/ediv/modulos.h b/ediv/src/ediv/modulos.h
index 7558801..0d63a80 100644
--- a/ediv/src/ediv/modulos.h
+++ b/ediv/src/ediv/modulos.h
@@ -29,4 +29,4 @@ int leedll();
 void dll_func();
 void dll_func2();
 
-#endif
\ No newline at end of file
+#endif
diff --git a/ediv/src/ediv/parser.c b/ediv/src/ediv/parser.c
index 2900d2d..42e3233 100644
--- a/ediv/src/ediv/parser.c
+++ b/ediv/src/ediv/parser.c
@@ -52,12 +52,12 @@ int crea_objeto(byte * nombre, int nparam)
 
 		if(nparam==-1) {
 			// busca si el id encontrado se encuentra en la misma struct
-			while(o!=NULL && ((*o).member!=member)) o=(*o).anterior;
+			while(o!=NULL && (o->member!=member)) o=o->anterior;
 			if(o==NULL) { // ok, no hay problema
-				o=iobj++; (*o).anterior=*ptr_o; *ptr_o=o;
-				(*o).name=(byte*)(ptr_o+1);
-				(*o).member=member;
-				(*o).param=0;
+				o=iobj++; o->anterior=*ptr_o; *ptr_o=o;
+				o->name=(byte*)(ptr_o+1);
+				o->member=member;
+				o->param=0;
 				if (num_obj++==max_obj) return 3;	// error "demasiados objetos"
 			} else {
 				return 2;		// dos nombres iguales en el mismo nivel de struct -> "el nombre no es nuevo"
@@ -67,15 +67,15 @@ int crea_objeto(byte * nombre, int nparam)
 			// se trata de una funcion externa. buscamos si es posible la sobrecarga
 			while(1) {
 				if(o==NULL) break;
-				if((*o).tipo==tfext && (*o).fext.num_par==nparam) break;
-				o=(*o).anterior;
+				if(o->tipo==tfext && o->fext.num_par==nparam) break;
+				o=o->anterior;
 			}
-			//while(o!=NULL && (((*o).tipo==tfext) ^^ ((*o).fext.num_par!=nparam))) o=(*o).anterior;
+			//while(o!=NULL && ((o->tipo==tfext) ^^ (o->fext.num_par!=nparam))) o=o->anterior;
 			if(o==NULL) { // ok, lo añadimos a la lista
-				o=iobj++; (*o).anterior=*ptr_o; *ptr_o=o;
-				(*o).name=(byte*)(ptr_o+1);
-				(*o).member=member;
-				(*o).param=0;
+				o=iobj++; o->anterior=*ptr_o; *ptr_o=o;
+				o->name=(byte*)(ptr_o+1);
+				o->member=member;
+				o->param=0;
 				if (num_obj++==max_obj) return 3;	// error "demasiados objetos"
 			} else {
 				return 2;		// dos funciones iguales con el mismo numero de parametros -> "el nombre no es nuevo"
@@ -84,13 +84,13 @@ int crea_objeto(byte * nombre, int nparam)
 
 	} else {
         *ptr=_ivnom; ptr_o=(void*)(_ivnom+4); *ptr_o=o=iobj++; // id nuevo
-        (*o).name=(byte*)_ivnom+8;
-        (*o).member=member;
+        o->name=(byte*)_ivnom+8;
+        o->member=member;
         if (num_obj++==max_obj) return 3;	// error "demasiados objetos"
 	}
 	
-	(*o).dll=numdlls;
-//	(*o).usado_dll=0;
+	o->dll=numdlls;
+//	o->usado_dll=0;
 	
 	return 0;
 }
@@ -250,14 +250,14 @@ lex_scan:
 		default: 									// puntero a un lex_ele
 			e=lex_case[*_source++];
 			_ivnom=_source;
-			pieza=(*e).token;
+			pieza=e->token;
 
-			while (e=(*e).siguiente) {
-				while (*_source!=(*e).caracter && (*e).alternativa)
-					e=(*e).alternativa;
+			while (e=e->siguiente) {
+				while (*_source!=e->caracter && e->alternativa)
+					e=e->alternativa;
 
-				if (*_source++==(*e).caracter && (*e).token) {
-					pieza=(*e).token;
+				if (*_source++==e->caracter && e->token) {
+					pieza=e->token;
 					_ivnom=_source;
 				}
 			}
@@ -337,8 +337,8 @@ void sintactico(void)
 		do {
 			if (pieza==p_ptocoma) { lexico(); break; }
 			if (pieza==p_coma) lexico();
-			if (pieza==p_id && (*o).tipo==tcons) {
-				switch((*o).cons.valor) {
+			if (pieza==p_id && o->tipo==tcons) {
+				switch(o->cons.valor) {
 					case 0: // _max_process
 						lexico();
 						if (pieza!=p_asig) error(3,7);	// se esperaba '='
@@ -439,12 +439,12 @@ void sintactico(void)
 	if (pieza!=p_id) error(1,45);	// esperando el nombre del programa
 	
 	ob=o;
-	if ((*ob).tipo!=tnone) error(0,30); // el nombre no es nuevo
-	(*ob).tipo=tproc;
-	(*ob).proc.bloque=bloque_actual=ob;
-	(*ob).proc.offset=0;
-	(*ob).proc.num_par=0;
-	nombre_program=(*ob).name;
+	if (ob->tipo!=tnone) error(0,30); // el nombre no es nuevo
+	ob->tipo=tproc;
+	ob->proc.bloque=bloque_actual=ob;
+	ob->proc.offset=0;
+	ob->proc.num_par=0;
+	nombre_program=ob->name;
 	lexico();
 	if (!free_sintax) if (pieza!=p_ptocoma) error(3,9); // esperando ';'
 	while (pieza==p_ptocoma || pieza==p_coma) lexico();
@@ -459,7 +459,7 @@ void sintactico(void)
 	while (pieza==p_import) {
 		warning(2);	// sintaxis antigua
 		lexico();
-		if (pieza!=p_lit && !(pieza==p_id && (*o).tipo==tcons && (*o).cons.literal))
+		if (pieza!=p_lit && !(pieza==p_id && o->tipo==tcons && o->cons.literal))
 			error(1,46); // se esperaba un literal
 		lexico();
 		if (!free_sintax) if (pieza!=p_ptocoma) error(3,9); // esperando ';'
@@ -476,17 +476,17 @@ void sintactico(void)
 		pasa_ptocoma();
 		while (pieza==p_id) {
 			ob=o;
-			if ((*ob).tipo!=tnone && (*ob).tipo!=tcons) error(0,30); // el nombre no es nuevo
-			(*ob).tipo=tcons;
+			if (ob->tipo!=tnone && ob->tipo!=tcons) error(0,30); // el nombre no es nuevo
+			ob->tipo=tcons;
 			lexico(); if (pieza!=p_asig) error(3,7); // esperando '='
 			
 			lexico();
-			if (pieza==p_lit || (pieza==p_id && (*o).tipo==tcons && (*o).cons.literal))
-				(*ob).cons.literal=1;
+			if (pieza==p_lit || (pieza==p_id && o->tipo==tcons && o->cons.literal))
+				ob->cons.literal=1;
 			else
-				(*ob).cons.literal=0;
+				ob->cons.literal=0;
 				
-			(*ob).cons.valor=constante();
+			ob->cons.valor=constante();
 			if (!free_sintax) if (pieza!=p_ptocoma && pieza!=p_coma) error(3,9); // esperando ';'
 			while (pieza==p_ptocoma || pieza==p_coma) lexico();
 		}
@@ -515,8 +515,8 @@ void sintactico(void)
           if (pieza==p_pointer) { // Se define un puntero a struct
 
             lexico(); if (pieza!=p_id) error(1,27); ob=o; // esperando el nombre de la estructura
-            if ((*ob).tipo==tnone) error(0,28); // No se define el pointer así
-            if ((*ob).tipo!=tsglo && (*ob).tipo!=tsloc) error(0,28);
+            if (ob->tipo==tnone) error(0,28); // No se define el pointer así
+            if (ob->tipo!=tsglo && ob->tipo!=tsloc) error(0,28);
             lexico();
             puntero_a_struct:
             analiza_pointer_struct(tpsgl,imem,ob);
@@ -537,48 +537,48 @@ void sintactico(void)
             if (pieza!=p_id) error(1,27); // esperando el nombre de la estructura
             ob=o; member=ob; lexico();
 
-            if ((*ob).tipo!=tnone) error(2,30); // el nombre no es nuevo
+            if (ob->tipo!=tnone) error(2,30); // el nombre no es nuevo
 
-            (*ob).tipo=tsglo; (*ob).sglo.offset=_imem=imem;
+            ob->tipo=tsglo; ob->sglo.offset=_imem=imem;
             if (pieza==p_corab) {
               member2=member; member=NULL; lexico();
-              if (((*ob).sglo.items1=constante())<0) error(4,43); // estructura de longitud negativa
+              if ((ob->sglo.items1=constante())<0) error(4,43); // estructura de longitud negativa
               if (pieza==p_coma) {
                 lexico();
-                if (((*ob).sglo.items2=constante())<0) error(4,43); // idem
+                if ((ob->sglo.items2=constante())<0) error(4,43); // idem
                 if (pieza==p_coma) {
                   lexico();
-                  if (((*ob).sglo.items3=constante())<0) error(4,43); // reidem
-                } else (*ob).sglo.items3=-1;
-              } else { (*ob).sglo.items2=-1; (*ob).sglo.items3=-1; }
+                  if ((ob->sglo.items3=constante())<0) error(4,43); // reidem
+                } else ob->sglo.items3=-1;
+              } else { ob->sglo.items2=-1; ob->sglo.items3=-1; }
               member=member2;
-              (*ob).sglo.totalitems=(*ob).sglo.items1+1;
-              if ((*ob).sglo.items2>-1) (*ob).sglo.totalitems*=(*ob).sglo.items2+1;
-              if ((*ob).sglo.items3>-1) (*ob).sglo.totalitems*=(*ob).sglo.items3+1;
+              ob->sglo.totalitems=ob->sglo.items1+1;
+              if (ob->sglo.items2>-1) ob->sglo.totalitems*=ob->sglo.items2+1;
+              if (ob->sglo.items3>-1) ob->sglo.totalitems*=ob->sglo.items3+1;
               if (pieza!=p_corce) error(3,19); lexico(); // espernado ']'
             } else {
-              (*ob).sglo.totalitems=1;
-              (*ob).sglo.items1=0; (*ob).sglo.items2=-1; (*ob).sglo.items3=-1;
+              ob->sglo.totalitems=1;
+              ob->sglo.items1=0; ob->sglo.items2=-1; ob->sglo.items3=-1;
             }
-            if (((*ob).sglo.len_item=analiza_struct(_imem))==0) error(0,47); // estructua vacia
+            if ((ob->sglo.len_item=analiza_struct(_imem))==0) error(0,47); // estructua vacia
             member=NULL; lexico();
-            imem=(*ob).sglo.offset; dup=(*ob).sglo.totalitems+1;
+            imem=ob->sglo.offset; dup=ob->sglo.totalitems+1;
             if (dup>1) {
-              test_buffer(&mem,&imem_max,imem+(*ob).sglo.len_item*(*ob).sglo.totalitems);
-              test_buffer(&frm,&ifrm_max,imem+(*ob).sglo.len_item*(*ob).sglo.totalitems);
+              test_buffer(&mem,&imem_max,imem+ob->sglo.len_item*ob->sglo.totalitems);
+              test_buffer(&frm,&ifrm_max,imem+ob->sglo.len_item*ob->sglo.totalitems);
               while (--dup) {
-                memcpy(&mem[imem],&mem[_imem],(*ob).sglo.len_item<<2);
-                memcpy(&frm[imem],&frm[_imem],(*ob).sglo.len_item<<2);
-                imem+=(*ob).sglo.len_item;
+                memcpy(&mem[imem],&mem[_imem],ob->sglo.len_item<<2);
+                memcpy(&frm[imem],&frm[_imem],ob->sglo.len_item<<2);
+                imem+=ob->sglo.len_item;
               }
             } imem=_imem;
             if (pieza==p_asig) {
               save_error(1);
               lexico(); tglo_init(0);
-              if (imem-_imem-1>=(*ob).sglo.len_item*(*ob).sglo.totalitems) error(4,55); // demasiados valores para la estructura
+              if (imem-_imem-1>=ob->sglo.len_item*ob->sglo.totalitems) error(4,55); // demasiados valores para la estructura
             } while (pieza==p_ptocoma) lexico();
 
-            imem=_imem+(*ob).sglo.len_item*(*ob).sglo.totalitems;
+            imem=_imem+ob->sglo.len_item*ob->sglo.totalitems;
             test_buffer(&mem,&imem_max,imem);
           }
 
@@ -600,39 +600,39 @@ void sintactico(void)
           } else {
 
             if (pieza!=p_id) error(1,29); // esperando el nombre de la cadena
-            ob=o; if ((*ob).tipo!=tnone) error(0,30); lexico();	// el nombre no es nuevo
-            (*ob).tipo=tcglo;
+            ob=o; if (ob->tipo!=tnone) error(0,30); lexico();	// el nombre no es nuevo
+            ob->tipo=tcglo;
             _imem=imem;
-            (*ob).cglo.offset=_imem+1;
+            ob->cglo.offset=_imem+1;
             if (pieza==p_corab) {
               lexico();
               if (pieza==p_corce) {
                 lexico();
-                (*ob).cglo.totalen=255;
+                ob->cglo.totalen=255;
               } else {
-                if (((*ob).cglo.totalen=constante())<0) error(4,31); // cadena de long. negativa
-                if ((*ob).cglo.totalen>0xFFFFF) error(4,32); // cadena demasiado larga
+                if ((ob->cglo.totalen=constante())<0) error(4,31); // cadena de long. negativa
+                if (ob->cglo.totalen>0xFFFFF) error(4,32); // cadena demasiado larga
                 if (pieza!=p_corce) error(3,19); // esperando ']'
                 lexico();
               }
-            } else (*ob).cglo.totalen=255;
+            } else ob->cglo.totalen=255;
             if (pieza==p_asig) {
               save_error(1);
               _itxt=itxt;
               lexico();
-              if (pieza!=p_lit && !(pieza==p_id && (*o).tipo==tcons && (*o).cons.literal))
+              if (pieza!=p_lit && !(pieza==p_id && o->tipo==tcons && o->cons.literal))
                 error(3,46); // se esperaba un literal
-              if (strlen((char*)&mem[pieza_num])>(*ob).cglo.totalen+1)
+              if (strlen((char*)&mem[pieza_num])>ob->cglo.totalen+1)
                 error(4,49); // literal demasiado largo
-              imem=_imem+1+((*ob).cglo.totalen+5)/4; // ej. c[32] -> c[0]..c[32],NUL
+              imem=_imem+1+(ob->cglo.totalen+5)/4; // ej. c[32] -> c[0]..c[32],NUL
               test_buffer(&mem,&imem_max,imem);
               strcpy((char*)&mem[_imem+1],(char*)&mem[pieza_num]);
               itxt=_itxt; // Saca la cadena del segmento de textos
               lexico();
             } else {
-              imem=_imem+1+((*ob).cglo.totalen+5)/4;
+              imem=_imem+1+(ob->cglo.totalen+5)/4;
               test_buffer(&mem,&imem_max,imem);
-            } mem[_imem]=0xDAD00000|(*ob).cglo.totalen;
+            } mem[_imem]=0xDAD00000|ob->cglo.totalen;
           }
 
           if (pieza==p_coma) pieza=p_string; else {
@@ -658,54 +658,54 @@ void sintactico(void)
           } else {
 
             if (pieza!=p_id) error(1,23); // esperando un nombre
-            ob=o; if ((*ob).tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
-            (*ob).tipo=tbglo; (*ob).bglo.offset=_imem=imem;
+            ob=o; if (ob->tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
+            ob->tipo=tbglo; ob->bglo.offset=_imem=imem;
             if (pieza==p_corab) {
               lexico();
               if (pieza==p_corce) {
                 lexico(); if (pieza!=p_asig) error(3,7); lexico(); // esperando '='
                 oimemptr=(byte*)&mem[imem];
                 tglo_init(2);
-                (*ob).bglo.len1=imemptr-oimemptr-1;
-                (*ob).bglo.len2=-1;
-                (*ob).bglo.len3=-1;
-                (*ob).bglo.totalen=((*ob).bglo.len1+4)/4;
+                ob->bglo.len1=imemptr-oimemptr-1;
+                ob->bglo.len2=-1;
+                ob->bglo.len3=-1;
+                ob->bglo.totalen=(ob->bglo.len1+4)/4;
               } else {
-                if (((*ob).bglo.len1=constante())<0) error(4,40); // tabla de longitud negativa
+                if ((ob->bglo.len1=constante())<0) error(4,40); // tabla de longitud negativa
                 if (pieza==p_coma) {
                   lexico();
-                  if (((*ob).bglo.len2=constante())<0) error(4,40); // idem
+                  if ((ob->bglo.len2=constante())<0) error(4,40); // idem
                   if (pieza==p_coma) {
                     lexico();
-                    if (((*ob).bglo.len3=constante())<0) error(4,40); // reidem
-                  } else (*ob).bglo.len3=-1;
-                } else { (*ob).bglo.len2=-1; (*ob).bglo.len3=-1; }
+                    if ((ob->bglo.len3=constante())<0) error(4,40); // reidem
+                  } else ob->bglo.len3=-1;
+                } else { ob->bglo.len2=-1; ob->bglo.len3=-1; }
 
-                (*ob).bglo.totalen=(*ob).bglo.len1+1;
-                if ((*ob).bglo.len2>-1) (*ob).bglo.totalen*=(*ob).bglo.len2+1;
-                if ((*ob).bglo.len3>-1) (*ob).bglo.totalen*=(*ob).bglo.len3+1;
+                ob->bglo.totalen=ob->bglo.len1+1;
+                if (ob->bglo.len2>-1) ob->bglo.totalen*=ob->bglo.len2+1;
+                if (ob->bglo.len3>-1) ob->bglo.totalen*=ob->bglo.len3+1;
                 if (pieza!=p_corce) error(3,19); lexico(); // esperando ']'
                 if (pieza==p_asig) {
                   save_error(1);
                   lexico();
                   oimemptr=(byte*)&mem[imem];
                   tglo_init(2);
-                  if (imemptr-oimemptr>(*ob).bglo.totalen) error(4,48); // demasiados valores para la tabla
-                } (*ob).bglo.totalen=((*ob).bglo.totalen+3)/4;
+                  if (imemptr-oimemptr>ob->bglo.totalen) error(4,48); // demasiados valores para la tabla
+                } ob->bglo.totalen=(ob->bglo.totalen+3)/4;
               }
             } else {                                          // Byte global
-              (*ob).tipo=tbglo; (*ob).bglo.offset=imem;
-              (*ob).bglo.len1=0;
-              (*ob).bglo.len2=-1;
-              (*ob).bglo.len3=-1;
-              (*ob).bglo.totalen=1; // 1 int
+              ob->tipo=tbglo; ob->bglo.offset=imem;
+              ob->bglo.len1=0;
+              ob->bglo.len2=-1;
+              ob->bglo.len3=-1;
+              ob->bglo.totalen=1; // 1 int
               if (pieza==p_asig) {
                 save_error(1);
                 lexico();
                 mem[imem]=constante();
                 if (mem[imem]<0 || mem[imem]>255) error(4,50); // valor byte fuera de rango
               }
-            } imem=_imem+(*ob).bglo.totalen; test_buffer(&mem,&imem_max,imem);
+            } imem=_imem+ob->bglo.totalen; test_buffer(&mem,&imem_max,imem);
           }
 
           if (pieza==p_coma) pieza=p_byte; else {
@@ -731,54 +731,54 @@ void sintactico(void)
           } else {
 
             if (pieza!=p_id) error(1,23); // esperando un nombre
-            ob=o; if ((*ob).tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
-            (*ob).tipo=twglo; (*ob).wglo.offset=_imem=imem;
+            ob=o; if (ob->tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
+            ob->tipo=twglo; ob->wglo.offset=_imem=imem;
             if (pieza==p_corab) {
               lexico();
               if (pieza==p_corce) {
                 lexico(); if (pieza!=p_asig) error(3,7); lexico(); // esperando '='
                 oimemptr=(byte*)&mem[imem];
                 tglo_init(1);
-                (*ob).wglo.len1=(imemptr-oimemptr)/2-1;
-                (*ob).wglo.len2=-1;
-                (*ob).wglo.len3=-1;
-                (*ob).wglo.totalen=((*ob).wglo.len1+2)/2;
+                ob->wglo.len1=(imemptr-oimemptr)/2-1;
+                ob->wglo.len2=-1;
+                ob->wglo.len3=-1;
+                ob->wglo.totalen=(ob->wglo.len1+2)/2;
               } else {
-                if (((*ob).wglo.len1=constante())<0) error(4,40); // tabla de longitud negativa
+                if ((ob->wglo.len1=constante())<0) error(4,40); // tabla de longitud negativa
                 if (pieza==p_coma) {
                   lexico();
-                  if (((*ob).wglo.len2=constante())<0) error(4,40); // idem
+                  if ((ob->wglo.len2=constante())<0) error(4,40); // idem
                   if (pieza==p_coma) {
                     lexico();
-                    if (((*ob).wglo.len3=constante())<0) error(4,40); // reidem
-                  } else (*ob).wglo.len3=-1;
-                } else { (*ob).wglo.len2=-1; (*ob).wglo.len3=-1; }
+                    if ((ob->wglo.len3=constante())<0) error(4,40); // reidem
+                  } else ob->wglo.len3=-1;
+                } else { ob->wglo.len2=-1; ob->wglo.len3=-1; }
 
-                (*ob).wglo.totalen=(*ob).wglo.len1+1;
-                if ((*ob).wglo.len2>-1) (*ob).wglo.totalen*=(*ob).wglo.len2+1;
-                if ((*ob).wglo.len3>-1) (*ob).wglo.totalen*=(*ob).wglo.len3+1;
+                ob->wglo.totalen=ob->wglo.len1+1;
+                if (ob->wglo.len2>-1) ob->wglo.totalen*=ob->wglo.len2+1;
+                if (ob->wglo.len3>-1) ob->wglo.totalen*=ob->wglo.len3+1;
                 if (pieza!=p_corce) error(3,19); lexico(); // esperando ']'
                 if (pieza==p_asig) {
                   save_error(1);
                   lexico();
                   oimemptr=(byte*)&mem[imem];
                   tglo_init(1);
-                  if (imemptr-oimemptr>(*ob).wglo.totalen*2) error(4,48); // demasiados valores para la tabla
-                } (*ob).wglo.totalen=((*ob).wglo.totalen+1)/2;
+                  if (imemptr-oimemptr>ob->wglo.totalen*2) error(4,48); // demasiados valores para la tabla
+                } ob->wglo.totalen=(ob->wglo.totalen+1)/2;
               }
             } else {                                          // Word global
-              (*ob).tipo=twglo; (*ob).wglo.offset=imem;
-              (*ob).wglo.len1=0;
-              (*ob).wglo.len2=-1;
-              (*ob).wglo.len3=-1;
-              (*ob).wglo.totalen=1; // 1 int
+              ob->tipo=twglo; ob->wglo.offset=imem;
+              ob->wglo.len1=0;
+              ob->wglo.len2=-1;
+              ob->wglo.len3=-1;
+              ob->wglo.totalen=1; // 1 int
               if (pieza==p_asig) {
                 save_error(1);
                 lexico();
                 mem[imem]=constante();
                 if (mem[imem]<0 || mem[imem]>65535) error(4,51); // valor word fuera de rango
               }
-            } imem=_imem+(*ob).wglo.totalen; test_buffer(&mem,&imem_max,imem);
+            } imem=_imem+ob->wglo.totalen; test_buffer(&mem,&imem_max,imem);
           }
 
           if (pieza==p_coma) pieza=p_word; else {
@@ -806,43 +806,43 @@ void sintactico(void)
 
           } else {
 
-            ob=o; if ((*ob).tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
+            ob=o; if (ob->tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
             if (pieza==p_corab) {                           // Tabla global
               lexico();
-              (*ob).tipo=ttglo; (*ob).tglo.offset=_imem=imem;
+              ob->tipo=ttglo; ob->tglo.offset=_imem=imem;
               if (pieza==p_corce) {
                 lexico(); if (pieza!=p_asig) error(3,7); lexico(); // esperando '='
                 tglo_init(3);
-                (*ob).tglo.len1=imem-_imem-1;
-                (*ob).tglo.len2=-1;
-                (*ob).tglo.len3=-1;
-                (*ob).tglo.totalen=imem-_imem;
+                ob->tglo.len1=imem-_imem-1;
+                ob->tglo.len2=-1;
+                ob->tglo.len3=-1;
+                ob->tglo.totalen=imem-_imem;
               } else {
-                if (((*ob).tglo.len1=constante())<0) error(4,40); // tabla de longitud negativa
+                if ((ob->tglo.len1=constante())<0) error(4,40); // tabla de longitud negativa
                 if (pieza==p_coma) {
                   lexico();
-                  if (((*ob).tglo.len2=constante())<0) error(4,40); // idem
+                  if ((ob->tglo.len2=constante())<0) error(4,40); // idem
                   if (pieza==p_coma) {
                     lexico();
-                    if (((*ob).tglo.len3=constante())<0) error(4,40); // reidem
-                  } else (*ob).tglo.len3=-1;
-                } else { (*ob).tglo.len2=-1; (*ob).tglo.len3=-1; }
-                (*ob).tglo.totalen=(*ob).tglo.len1+1;
-                if ((*ob).tglo.len2>-1) (*ob).tglo.totalen*=(*ob).tglo.len2+1;
-                if ((*ob).tglo.len3>-1) (*ob).tglo.totalen*=(*ob).tglo.len3+1;
+                    if ((ob->tglo.len3=constante())<0) error(4,40); // reidem
+                  } else ob->tglo.len3=-1;
+                } else { ob->tglo.len2=-1; ob->tglo.len3=-1; }
+                ob->tglo.totalen=ob->tglo.len1+1;
+                if (ob->tglo.len2>-1) ob->tglo.totalen*=ob->tglo.len2+1;
+                if (ob->tglo.len3>-1) ob->tglo.totalen*=ob->tglo.len3+1;
                 if (pieza!=p_corce) error(3,19); lexico(); // esperando ']'
                 if (pieza==p_asig) {
                   save_error(1);
                   lexico(); tglo_init(3);
-                  if (imem-_imem>(*ob).tglo.totalen) error(4,48); // demasiados valores para la tabla
+                  if (imem-_imem>ob->tglo.totalen) error(4,48); // demasiados valores para la tabla
                 }
               }
-              imem=_imem+(*ob).tglo.totalen;
+              imem=_imem+ob->tglo.totalen;
               test_buffer(&mem,&imem_max,imem);
 
             } else {                                          // Variable global
 
-              (*ob).tipo=tvglo; (*ob).vglo.offset=imem;
+              ob->tipo=tvglo; ob->vglo.offset=imem;
               if (pieza==p_asig) { lexico(); mem[imem]=constante(); }
               test_buffer(&mem,&imem_max,++imem);
 
@@ -874,8 +874,8 @@ void sintactico(void)
           if (pieza==p_pointer) { // Se define un puntero a struct
 
             lexico(); if (pieza!=p_id) error(1,27); ob=o; // esperando el nombre de la estructura
-            if ((*ob).tipo==tnone) error(0,28); // No se define el pointer así
-            if ((*ob).tipo!=tsglo && (*ob).tipo!=tsloc) error(0,28);
+            if (ob->tipo==tnone) error(0,28); // No se define el pointer así
+            if (ob->tipo!=tsglo && ob->tipo!=tsloc) error(0,28);
             lexico();
             puntero_a_struct_local:
             analiza_pointer_struct(tpslo,iloc,ob);
@@ -896,46 +896,46 @@ void sintactico(void)
             if (pieza!=p_id) error(1,27); // esperando el nombre de la estructura
             ob=o; member=ob; lexico();
 
-            if ((*ob).tipo!=tnone) error(2,30); // el nombre no es nuevo
+            if (ob->tipo!=tnone) error(2,30); // el nombre no es nuevo
 
-            (*ob).tipo=tsloc; (*ob).sloc.offset=_imem=iloc;
+            ob->tipo=tsloc; ob->sloc.offset=_imem=iloc;
             if (pieza==p_corab) {
               member2=member; member=NULL; lexico();
-              if (((*ob).sloc.items1=constante())<0) error(4,43); // estructura de longitud negativa
+              if ((ob->sloc.items1=constante())<0) error(4,43); // estructura de longitud negativa
               if (pieza==p_coma) {
                 lexico();
-                if (((*ob).sloc.items2=constante())<0) error(4,43); // idem
+                if ((ob->sloc.items2=constante())<0) error(4,43); // idem
                 if (pieza==p_coma) {
                   lexico();
-                  if (((*ob).sloc.items3=constante())<0) error(4,43); // reidem
-                } else (*ob).sloc.items3=-1;
-              } else { (*ob).sloc.items2=-1; (*ob).sloc.items3=-1; }
+                  if ((ob->sloc.items3=constante())<0) error(4,43); // reidem
+                } else ob->sloc.items3=-1;
+              } else { ob->sloc.items2=-1; ob->sloc.items3=-1; }
               member=member2;
-              (*ob).sloc.totalitems=(*ob).sloc.items1+1;
-              if ((*ob).sloc.items2>-1) (*ob).sloc.totalitems*=(*ob).sloc.items2+1;
-              if ((*ob).sloc.items3>-1) (*ob).sloc.totalitems*=(*ob).sloc.items3+1;
+              ob->sloc.totalitems=ob->sloc.items1+1;
+              if (ob->sloc.items2>-1) ob->sloc.totalitems*=ob->sloc.items2+1;
+              if (ob->sloc.items3>-1) ob->sloc.totalitems*=ob->sloc.items3+1;
               if (pieza!=p_corce) error(3,19); lexico(); // esperando ']'
             } else {
-              (*ob).sloc.totalitems=1;
-              (*ob).sloc.items1=0; (*ob).sloc.items2=-1; (*ob).sloc.items3=-1;
+              ob->sloc.totalitems=1;
+              ob->sloc.items1=0; ob->sloc.items2=-1; ob->sloc.items3=-1;
             }
-            if (((*ob).sloc.len_item=analiza_struct_local(_imem))==0) error(0,47); // estructura vacia
+            if ((ob->sloc.len_item=analiza_struct_local(_imem))==0) error(0,47); // estructura vacia
             member=NULL; lexico();
-            iloc=(*ob).sloc.offset; dup=(*ob).sloc.totalitems+1;
+            iloc=ob->sloc.offset; dup=ob->sloc.totalitems+1;
             if (dup>1) {
-              test_buffer(&loc,&iloc_max,iloc+(*ob).sloc.len_item*(*ob).sloc.totalitems);
-              test_buffer(&frm,&ifrm_max,imem+(*ob).sloc.len_item*(*ob).sloc.totalitems);
+              test_buffer(&loc,&iloc_max,iloc+ob->sloc.len_item*ob->sloc.totalitems);
+              test_buffer(&frm,&ifrm_max,imem+ob->sloc.len_item*ob->sloc.totalitems);
               while (--dup) {
-                memcpy(&loc[iloc],&loc[_imem],(*ob).sloc.len_item<<2);
-                memcpy(&frm[iloc],&frm[_imem],(*ob).sloc.len_item<<2);
-                iloc+=(*ob).sloc.len_item;
+                memcpy(&loc[iloc],&loc[_imem],ob->sloc.len_item<<2);
+                memcpy(&frm[iloc],&frm[_imem],ob->sloc.len_item<<2);
+                iloc+=ob->sloc.len_item;
               }
             } iloc=_imem;
             if (pieza==p_asig) {
               save_error(1); lexico(); tloc_init(0);
-              if (iloc-_imem-1>=(*ob).sloc.len_item*(*ob).sloc.totalitems) error(4,55); // demasiados valores para la estructura
+              if (iloc-_imem-1>=ob->sloc.len_item*ob->sloc.totalitems) error(4,55); // demasiados valores para la estructura
             } while (pieza==p_ptocoma) lexico();
-            iloc=_imem+(*ob).sloc.len_item*(*ob).sloc.totalitems;
+            iloc=_imem+ob->sloc.len_item*ob->sloc.totalitems;
             test_buffer(&loc,&iloc_max,iloc);
           }
 
@@ -957,39 +957,39 @@ void sintactico(void)
           } else {
 
             if (pieza!=p_id) error(1,29); // esperando el nombre de la cadena
-            ob=o; if ((*ob).tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
-            (*ob).tipo=tcloc;
+            ob=o; if (ob->tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
+            ob->tipo=tcloc;
             _imem=iloc;
-            (*ob).cloc.offset=_imem+1;
+            ob->cloc.offset=_imem+1;
             if (pieza==p_corab) {
               lexico();
               if (pieza==p_corce) {
                 lexico();
-                (*ob).cloc.totalen=255;
+                ob->cloc.totalen=255;
               } else {
-                if (((*ob).cloc.totalen=constante())<0) error(4,31); // cadena de long. negativa
-                if ((*ob).cloc.totalen>0xFFFFF) error(4,32); // cadena demasiado larga
+                if ((ob->cloc.totalen=constante())<0) error(4,31); // cadena de long. negativa
+                if (ob->cloc.totalen>0xFFFFF) error(4,32); // cadena demasiado larga
                 if (pieza!=p_corce) error(3,19); // esperando ']'
                 lexico();
               }
-            } else (*ob).cloc.totalen=255;
+            } else ob->cloc.totalen=255;
             if (pieza==p_asig) {
               save_error(1);
               _itxt=itxt;
               lexico();
-              if (pieza!=p_lit && !(pieza==p_id && (*o).tipo==tcons && (*o).cons.literal))
+              if (pieza!=p_lit && !(pieza==p_id && o->tipo==tcons && o->cons.literal))
                 error(3,46); // se esperaba un literal
-              if (strlen((char*)&mem[pieza_num])>(*ob).cloc.totalen+1)
+              if (strlen((char*)&mem[pieza_num])>ob->cloc.totalen+1)
                 error(4,49); // literal demasiado largo
-              iloc=_imem+1+((*ob).cloc.totalen+5)/4; // ej. c[32] -> c[0]..c[32],NUL
+              iloc=_imem+1+(ob->cloc.totalen+5)/4; // ej. c[32] -> c[0]..c[32],NUL
               test_buffer(&loc,&iloc_max,iloc);
               strcpy((char*)&loc[_imem+1],(char*)&mem[pieza_num]);
               itxt=_itxt; // Saca la cadena del segmento de textos
               lexico();
             } else {
-              iloc=_imem+1+((*ob).cloc.totalen+5)/4;
+              iloc=_imem+1+(ob->cloc.totalen+5)/4;
               test_buffer(&loc,&iloc_max,iloc);
-            } loc[_imem]=0xDAD00000|(*ob).cloc.totalen;
+            } loc[_imem]=0xDAD00000|ob->cloc.totalen;
           }
 
           if (pieza==p_coma) pieza=p_string; else {
@@ -1015,54 +1015,54 @@ void sintactico(void)
           } else {
 
             if (pieza!=p_id) error(1,23); // esperando un nombre
-            ob=o; if ((*ob).tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
-            (*ob).tipo=tbloc; (*ob).bloc.offset=_imem=iloc;
+            ob=o; if (ob->tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
+            ob->tipo=tbloc; ob->bloc.offset=_imem=iloc;
             if (pieza==p_corab) {
               lexico();
               if (pieza==p_corce) {
                 lexico(); if (pieza!=p_asig) error(3,7); lexico(); // esperando '='
                 oimemptr=(byte*)&loc[iloc];
                 tloc_init(2);
-                (*ob).bloc.len1=imemptr-oimemptr-1;
-                (*ob).bloc.len2=-1;
-                (*ob).bloc.len3=-1;
-                (*ob).bloc.totalen=((*ob).bloc.len1+4)/4;
+                ob->bloc.len1=imemptr-oimemptr-1;
+                ob->bloc.len2=-1;
+                ob->bloc.len3=-1;
+                ob->bloc.totalen=(ob->bloc.len1+4)/4;
               } else {
-                if (((*ob).bloc.len1=constante())<0) error(4,40); // tabla de long. negativa
+                if ((ob->bloc.len1=constante())<0) error(4,40); // tabla de long. negativa
                 if (pieza==p_coma) {
                   lexico();
-                  if (((*ob).bloc.len2=constante())<0) error(4,40); // idem
+                  if ((ob->bloc.len2=constante())<0) error(4,40); // idem
                   if (pieza==p_coma) {
                     lexico();
-                    if (((*ob).bloc.len3=constante())<0) error(4,40); // reidem
-                  } else (*ob).bloc.len3=-1;
-                } else { (*ob).bloc.len2=-1; (*ob).bloc.len3=-1; }
+                    if ((ob->bloc.len3=constante())<0) error(4,40); // reidem
+                  } else ob->bloc.len3=-1;
+                } else { ob->bloc.len2=-1; ob->bloc.len3=-1; }
 
-                (*ob).bloc.totalen=(*ob).bloc.len1+1;
-                if ((*ob).bloc.len2>-1) (*ob).bloc.totalen*=(*ob).bloc.len2+1;
-                if ((*ob).bloc.len3>-1) (*ob).bloc.totalen*=(*ob).bloc.len3+1;
+                ob->bloc.totalen=ob->bloc.len1+1;
+                if (ob->bloc.len2>-1) ob->bloc.totalen*=ob->bloc.len2+1;
+                if (ob->bloc.len3>-1) ob->bloc.totalen*=ob->bloc.len3+1;
                 if (pieza!=p_corce) error(3,19); lexico(); // esperando ']'
                 if (pieza==p_asig) {
                   save_error(1);
                   lexico();
                   oimemptr=(byte*)&loc[iloc];
                   tloc_init(2);
-                  if (imemptr-oimemptr>(*ob).bloc.totalen) error(4,48); // demasiados valores para la tabla
-                } (*ob).bloc.totalen=((*ob).bloc.totalen+3)/4;
+                  if (imemptr-oimemptr>ob->bloc.totalen) error(4,48); // demasiados valores para la tabla
+                } ob->bloc.totalen=(ob->bloc.totalen+3)/4;
               }
             } else {                                          // Byte local
-              (*ob).tipo=tbloc; (*ob).bloc.offset=iloc;
-              (*ob).bloc.len1=0;
-              (*ob).bloc.len2=-1;
-              (*ob).bloc.len3=-1;
-              (*ob).bloc.totalen=1; // 1 int
+              ob->tipo=tbloc; ob->bloc.offset=iloc;
+              ob->bloc.len1=0;
+              ob->bloc.len2=-1;
+              ob->bloc.len3=-1;
+              ob->bloc.totalen=1; // 1 int
               if (pieza==p_asig) {
                 save_error(1);
                 lexico();
                 loc[iloc]=constante();
                 if (loc[iloc]<0 || loc[iloc]>255) error(4,50); // valor byte fuera de rango
               }
-            } iloc=_imem+(*ob).bloc.totalen; test_buffer(&loc,&iloc_max,iloc);
+            } iloc=_imem+ob->bloc.totalen; test_buffer(&loc,&iloc_max,iloc);
           }
 
           if (pieza==p_coma) pieza=p_byte; else {
@@ -1088,54 +1088,54 @@ void sintactico(void)
           } else {
 
             if (pieza!=p_id) error(1,23); // esperando un nombre
-            ob=o; if ((*ob).tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
-            (*ob).tipo=twloc; (*ob).wloc.offset=_imem=iloc;
+            ob=o; if (ob->tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
+            ob->tipo=twloc; ob->wloc.offset=_imem=iloc;
             if (pieza==p_corab) {
               lexico();
               if (pieza==p_corce) {
                 lexico(); if (pieza!=p_asig) error(3,7); lexico(); // esperando '='
                 oimemptr=(byte*)&loc[iloc];
                 tloc_init(1);
-                (*ob).wloc.len1=(imemptr-oimemptr)/2-1;
-                (*ob).wloc.len2=-1;
-                (*ob).wloc.len3=-1;
-                (*ob).wloc.totalen=((*ob).wloc.len1+2)/2;
+                ob->wloc.len1=(imemptr-oimemptr)/2-1;
+                ob->wloc.len2=-1;
+                ob->wloc.len3=-1;
+                ob->wloc.totalen=(ob->wloc.len1+2)/2;
               } else {
-                if (((*ob).wloc.len1=constante())<0) error(4,40); // tabla de long. negativa
+                if ((ob->wloc.len1=constante())<0) error(4,40); // tabla de long. negativa
                 if (pieza==p_coma) {
                   lexico();
-                  if (((*ob).wloc.len2=constante())<0) error(4,40); // idem
+                  if ((ob->wloc.len2=constante())<0) error(4,40); // idem
                   if (pieza==p_coma) {
                     lexico();
-                    if (((*ob).wloc.len3=constante())<0) error(4,40); // reidem
-                  } else (*ob).wloc.len3=-1;
-                } else { (*ob).wloc.len2=-1; (*ob).wloc.len3=-1; }
+                    if ((ob->wloc.len3=constante())<0) error(4,40); // reidem
+                  } else ob->wloc.len3=-1;
+                } else { ob->wloc.len2=-1; ob->wloc.len3=-1; }
 
-                (*ob).wloc.totalen=(*ob).wloc.len1+1;
-                if ((*ob).wloc.len2>-1) (*ob).wloc.totalen*=(*ob).wloc.len2+1;
-                if ((*ob).wloc.len3>-1) (*ob).wloc.totalen*=(*ob).wloc.len3+1;
+                ob->wloc.totalen=ob->wloc.len1+1;
+                if (ob->wloc.len2>-1) ob->wloc.totalen*=ob->wloc.len2+1;
+                if (ob->wloc.len3>-1) ob->wloc.totalen*=ob->wloc.len3+1;
                 if (pieza!=p_corce) error(3,19); lexico(); // esperando ']'
                 if (pieza==p_asig) {
                   save_error(1);
                   lexico();
                   oimemptr=(byte*)&loc[iloc];
                   tloc_init(1);
-                  if (imemptr-oimemptr>(*ob).wloc.totalen*2) error(4,48); // demasiados valores para la tabla
-                } (*ob).wloc.totalen=((*ob).wloc.totalen+1)/2;
+                  if (imemptr-oimemptr>ob->wloc.totalen*2) error(4,48); // demasiados valores para la tabla
+                } ob->wloc.totalen=(ob->wloc.totalen+1)/2;
               }
             } else {                                          // Word local
-              (*ob).tipo=twloc; (*ob).wloc.offset=iloc;
-              (*ob).wloc.len1=0;
-              (*ob).wloc.len2=-1;
-              (*ob).wloc.len3=-1;
-              (*ob).wloc.totalen=1; // 1 int
+              ob->tipo=twloc; ob->wloc.offset=iloc;
+              ob->wloc.len1=0;
+              ob->wloc.len2=-1;
+              ob->wloc.len3=-1;
+              ob->wloc.totalen=1; // 1 int
               if (pieza==p_asig) {
                 save_error(1);
                 lexico();
                 loc[iloc]=constante();
                 if (loc[iloc]<0 || loc[iloc]>65535) error(4,51); // valor word fuera de rango
               }
-            } iloc=_imem+(*ob).wloc.totalen; test_buffer(&loc,&iloc_max,iloc);
+            } iloc=_imem+ob->wloc.totalen; test_buffer(&loc,&iloc_max,iloc);
           }
 
           if (pieza==p_coma) pieza=p_word; else {
@@ -1163,42 +1163,42 @@ void sintactico(void)
 
           } else {
 
-            ob=o; if ((*ob).tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
+            ob=o; if (ob->tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
             if (pieza==p_corab) {                             // Tabla local
               lexico();
-              (*ob).tipo=ttloc; (*ob).tloc.offset=_imem=iloc;
+              ob->tipo=ttloc; ob->tloc.offset=_imem=iloc;
               if (pieza==p_corce) {
                 lexico(); if (pieza!=p_asig) error(3,7); lexico(); // esperando '='
                 tloc_init(3);
-                (*ob).tloc.len1=iloc-_imem-1;
-                (*ob).tloc.len2=-1;
-                (*ob).tloc.len3=-1;
-                (*ob).tloc.totalen=iloc-_imem;
+                ob->tloc.len1=iloc-_imem-1;
+                ob->tloc.len2=-1;
+                ob->tloc.len3=-1;
+                ob->tloc.totalen=iloc-_imem;
               } else {
-                if (((*ob).tloc.len1=constante())<0) error(4,40); // tabla de long. negativa
+                if ((ob->tloc.len1=constante())<0) error(4,40); // tabla de long. negativa
                 if (pieza==p_coma) {
                   lexico();
-                  if (((*ob).tloc.len2=constante())<0) error(4,40); // idem
+                  if ((ob->tloc.len2=constante())<0) error(4,40); // idem
                   if (pieza==p_coma) {
                     lexico();
-                    if (((*ob).tloc.len3=constante())<0) error(4,40); // reidem
-                  } else (*ob).tloc.len3=-1;
-                } else { (*ob).tloc.len2=-1; (*ob).tloc.len3=-1; }
-                (*ob).tloc.totalen=(*ob).tloc.len1+1;
-                if ((*ob).tloc.len2>-1) (*ob).tloc.totalen*=(*ob).tloc.len2+1;
-                if ((*ob).tloc.len3>-1) (*ob).tloc.totalen*=(*ob).tloc.len3+1;
+                    if ((ob->tloc.len3=constante())<0) error(4,40); // reidem
+                  } else ob->tloc.len3=-1;
+                } else { ob->tloc.len2=-1; ob->tloc.len3=-1; }
+                ob->tloc.totalen=ob->tloc.len1+1;
+                if (ob->tloc.len2>-1) ob->tloc.totalen*=ob->tloc.len2+1;
+                if (ob->tloc.len3>-1) ob->tloc.totalen*=ob->tloc.len3+1;
                 if (pieza!=p_corce) error(3,19); lexico(); // esperando ']'
                 if (pieza==p_asig) {
                   save_error(1);
                   lexico(); tloc_init(3);
-                  if (iloc-_imem>(*ob).tloc.totalen) error(4,48); } // demasiados valores para la tabla
+                  if (iloc-_imem>ob->tloc.totalen) error(4,48); } // demasiados valores para la tabla
               }
-              iloc=_imem+(*ob).tloc.totalen;
+              iloc=_imem+ob->tloc.totalen;
               test_buffer(&loc,&iloc_max,iloc);
 
             } else {                                          // Variable local
 
-              (*ob).tipo=tvloc; (*ob).vloc.offset=iloc;
+              ob->tipo=tvloc; ob->vloc.offset=iloc;
               if (pieza==p_asig) { lexico(); loc[iloc]=constante(); }
               test_buffer(&loc,&iloc_max,++iloc);
 
@@ -1229,7 +1229,7 @@ void sintactico(void)
     if (pieza==p_import) {
 		warning(2);	// sintaxis antigua
 		lexico();
-		if (pieza!=p_lit && !(pieza==p_id && (*o).tipo==tcons && (*o).cons.literal))
+		if (pieza!=p_lit && !(pieza==p_id && o->tipo==tcons && o->cons.literal))
 			error(1,46); // se esperaba un literal
 		lexico();
 		if (!free_sintax) if (pieza!=p_ptocoma) error(3,9); // esperando ';'
@@ -1282,15 +1282,15 @@ void sintactico(void)
       n=pieza; inicio_sentencia(); lexico();
       if (pieza!=p_id) error(1,70); // esperando el nombre del proceso o funcion
       ob=o; lexico();
-      if ((*ob).tipo==tproc && (*ob).usado) {
-        num_par=(*ob).proc.num_par; bloque_lexico=bloque_actual=ob;
-        _imem=(*ob).proc.offset; while(_imem) {
+      if (ob->tipo==tproc && ob->usado) {
+        num_par=ob->proc.num_par; bloque_lexico=bloque_actual=ob;
+        _imem=ob->proc.offset; while(_imem) {
            _imem_old=mem[_imem]; mem[_imem]=imem; _imem=_imem_old; }
-      } else if ((*ob).tipo==tnone) {
-        (*ob).usado=0; (*ob).tipo=tproc;
-        (*ob).proc.bloque=bloque_lexico=bloque_actual=ob;
+      } else if (ob->tipo==tnone) {
+        ob->usado=0; ob->tipo=tproc;
+        ob->proc.bloque=bloque_lexico=bloque_actual=ob;
       } else error(2,30); // el nombre no es nuevo
-      (*ob).proc.offset=imem; (*ob).proc.num_par=0;
+      ob->proc.offset=imem; ob->proc.num_par=0;
 
       g2(ltyp,(int)bloque_actual);
       if (n==p_function) g1(lnop);
@@ -1300,12 +1300,12 @@ void sintactico(void)
       parametros=1; n=iloc; lexico();
 
       while (pieza!=p_cerrar) {
-        (*ob).proc.num_par++; expresion_cpa();
+        ob->proc.num_par++; expresion_cpa();
         if (pieza!=p_cerrar) if (pieza!=p_coma) error(3,35); // se esperaba una coma
           else { lexico(); if (pieza==p_cerrar) error(3,36); } // se esperaba otro parámetro
       }
-      if ((*ob).usado) {
-        if (num_par==(*ob).proc.num_par) (*ob).usado=0; else error(0,38); // nº de parametros incorrecto
+      if (ob->usado) {
+        if (num_par==ob->proc.num_par) ob->usado=0; else error(0,38); // nº de parametros incorrecto
       }
       pasa_ptocoma(); final_sentencia();
 
@@ -1315,7 +1315,7 @@ void sintactico(void)
 
       parametros=-1; // Para que los parámetros se puedan repetir como PRIVATE
 
-      num_par=mem[_imem]=(*ob).proc.num_par;
+      num_par=mem[_imem]=ob->proc.num_par;
 
       analiza_private(); parametros=0;
 
@@ -1416,27 +1416,27 @@ lex_scan:
 					o=*ptr_o;
 					pieza=p_id;
 					
-					while(o!=NULL && ( ((*o).bloque && bloque_lexico!=(*o).bloque) ||
-					 ((*o).member!=member) ))
-					 	o=(*o).anterior;
+					while(o!=NULL && ( (o->bloque && bloque_lexico!=o->bloque) ||
+					 (o->member!=member) ))
+					 	o=o->anterior;
 
    					if(o==NULL) { // No encontrado
-   						o=iobj++; (*o).anterior=*ptr_o; *ptr_o=o;
-   						(*o).name=(byte*)(ptr_o+1);
-   						(*o).member=member;
-   						(*o).param=0;
-						(*o).dll=-1;
-   						if (parametros) (*o).bloque=bloque_actual;
+   						o=iobj++; o->anterior=*ptr_o; *ptr_o=o;
+   						o->name=(byte*)(ptr_o+1);
+   						o->member=member;
+   						o->param=0;
+						o->dll=-1;
+   						if (parametros) o->bloque=bloque_actual;
    						if (num_obj++==max_obj)
    							error(0,6); // excedida la capacidad de la tabla de objetos
    					}
    					else {
 						//printf("->->-> %s\n",(char*)_ivnom+8);
-   						if ((*o).tipo==tcons)
-   							pieza_num=(*o).cons.valor;
-						if((*o).dll!=-1) {
+   						if (o->tipo==tcons)
+   							pieza_num=o->cons.valor;
+						if(o->dll!=-1) {
 							for(i=0;i<numdlls;i++) {
-								if(nuevo_orden[i]==(*o).dll) {
+								if(nuevo_orden[i]==o->dll) {
    									dlls[i].usado=1;
 									break;
 								}
@@ -1451,10 +1451,10 @@ lex_scan:
 				*ptr_o=o=iobj++;
 				pieza=p_id;
 				
-				(*o).name=(byte*)_ivnom+8;
-				(*o).member=member;
-				(*o).dll=-1;
-				if (parametros) (*o).bloque=bloque_actual;
+				o->name=(byte*)_ivnom+8;
+				o->member=member;
+				o->dll=-1;
+				if (parametros) o->bloque=bloque_actual;
 				if (num_obj++==max_obj)
 					error(0,6);	// excedida la capacidad de la tabla de objetos
 			}
@@ -1548,15 +1548,15 @@ lex_scan:
 
 			e=lex_case[*_source++];
 			_ivnom=_source;
-			pieza=(*e).token;
+			pieza=e->token;
 			
-			while (e=(*e).siguiente) {
+			while (e=e->siguiente) {
 			
-				while (*_source!=(*e).caracter && (*e).alternativa)
-					e=(*e).alternativa;
+				while (*_source!=e->caracter && e->alternativa)
+					e=e->alternativa;
 					
-				if (*_source++==(*e).caracter && (*e).token) {
-					pieza=(*e).token;
+				if (*_source++==e->caracter && e->token) {
+					pieza=e->token;
 					_ivnom=_source;
 				}
 			}
@@ -1698,15 +1698,15 @@ lex_scan:
 
 		default: // puntero a un lex_ele
 			e=lex_case[*_source++];
-			next_pieza=(*e).token;
+			next_pieza=e->token;
 			_ivnom=_source;
 
-			while (e=(*e).siguiente) {
-				while (*_source!=(*e).caracter && (*e).alternativa)
-					e=(*e).alternativa;
+			while (e=e->siguiente) {
+				while (*_source!=e->caracter && e->alternativa)
+					e=e->alternativa;
 					
-				if (*_source++==(*e).caracter && (*e).token) {
-					next_pieza=(*e).token;
+				if (*_source++==e->caracter && e->token) {
+					next_pieza=e->token;
 					_ivnom=_source;
 				}
 			}
@@ -1776,8 +1776,8 @@ void analiza_private(void) {
         if (pieza==p_pointer) { // Se define un puntero a struct
 
           lexico(); if (pieza!=p_id) error(1,27); ob=o; // esperando el nombre de la estructura
-          if ((*ob).tipo==tnone) error(0,28); // No se define el pointer así
-          if ((*ob).tipo!=tsglo && (*ob).tipo!=tsloc) error(0,28);
+          if (ob->tipo==tnone) error(0,28); // No se define el pointer así
+          if (ob->tipo!=tsglo && ob->tipo!=tsloc) error(0,28);
           lexico();
           puntero_a_struct:
           if (analiza_pointer_struct(tpslo,iloc,ob)==1) {
@@ -1800,51 +1800,51 @@ void analiza_private(void) {
           if (pieza!=p_id) error(1,27); // esperando el nombre de la estructura
           ob=o; member=ob; lexico();
 
-          if ((*ob).tipo!=tnone) error(2,30); // el nombre no es nuevo
+          if (ob->tipo!=tnone) error(2,30); // el nombre no es nuevo
 
-          (*ob).tipo=tsloc; (*ob).sloc.offset=_imem=imem;
+          ob->tipo=tsloc; ob->sloc.offset=_imem=imem;
           if (pieza==p_corab) {
             member2=member; member=NULL; lexico();
-            if (((*ob).sloc.items1=constante())<0) error(4,43); // estructura de long. negativa
+            if ((ob->sloc.items1=constante())<0) error(4,43); // estructura de long. negativa
             if (pieza==p_coma) {
               lexico();
-              if (((*ob).sloc.items2=constante())<0) error(4,43); // idem
+              if ((ob->sloc.items2=constante())<0) error(4,43); // idem
               if (pieza==p_coma) {
                 lexico();
-                if (((*ob).sloc.items3=constante())<0) error(4,43); // reidem
-              } else (*ob).sloc.items3=-1;
-            } else { (*ob).sloc.items2=-1; (*ob).sloc.items3=-1; }
+                if ((ob->sloc.items3=constante())<0) error(4,43); // reidem
+              } else ob->sloc.items3=-1;
+            } else { ob->sloc.items2=-1; ob->sloc.items3=-1; }
             member=member2;
-            (*ob).sloc.totalitems=(*ob).sloc.items1+1;
-            if ((*ob).sloc.items2>-1) (*ob).sloc.totalitems*=(*ob).sloc.items2+1;
-            if ((*ob).sloc.items3>-1) (*ob).sloc.totalitems*=(*ob).sloc.items3+1;
+            ob->sloc.totalitems=ob->sloc.items1+1;
+            if (ob->sloc.items2>-1) ob->sloc.totalitems*=ob->sloc.items2+1;
+            if (ob->sloc.items3>-1) ob->sloc.totalitems*=ob->sloc.items3+1;
             if (pieza!=p_corce) error(3,19); lexico(); // esperando ']'
           } else {
-            (*ob).sloc.totalitems=1;
-            (*ob).sloc.items1=0; (*ob).sloc.items2=-1; (*ob).sloc.items3=-1;
+            ob->sloc.totalitems=1;
+            ob->sloc.items1=0; ob->sloc.items2=-1; ob->sloc.items3=-1;
           }
-          if (((*ob).sloc.len_item=analiza_struct_private(_imem))==0) error(0,47); // estructura vacia
+          if ((ob->sloc.len_item=analiza_struct_private(_imem))==0) error(0,47); // estructura vacia
 
           member=NULL; lexico();
 
-          imem=(*ob).sloc.offset; dup=(*ob).sloc.totalitems+1;
+          imem=ob->sloc.offset; dup=ob->sloc.totalitems+1;
           if (dup>1) {
-            test_buffer(&mem,&imem_max,imem+(*ob).sloc.len_item*(*ob).sloc.totalitems);
-            test_buffer(&frm,&ifrm_max,imem+(*ob).sloc.len_item*(*ob).sloc.totalitems);
+            test_buffer(&mem,&imem_max,imem+ob->sloc.len_item*ob->sloc.totalitems);
+            test_buffer(&frm,&ifrm_max,imem+ob->sloc.len_item*ob->sloc.totalitems);
             while (--dup) {
-              memcpy(&mem[imem],&mem[_imem],(*ob).sloc.len_item<<2);
-              memcpy(&frm[imem],&frm[_imem],(*ob).sloc.len_item<<2);
-              imem+=(*ob).sloc.len_item;
+              memcpy(&mem[imem],&mem[_imem],ob->sloc.len_item<<2);
+              memcpy(&frm[imem],&frm[_imem],ob->sloc.len_item<<2);
+              imem+=ob->sloc.len_item;
             }
           } imem=_imem;
 
           if (pieza==p_asig) {
             save_error(1); lexico(); tglo_init(0);
-            if (imem-_imem-1>=(*ob).sloc.len_item*(*ob).sloc.totalitems) error(4,55); // demasiados valores para la estructura
+            if (imem-_imem-1>=ob->sloc.len_item*ob->sloc.totalitems) error(4,55); // demasiados valores para la estructura
           } while (pieza==p_ptocoma) lexico();
 
-          imem=_imem+(*ob).sloc.len_item*(*ob).sloc.totalitems;
-          (*ob).sloc.offset=iloc; iloc+=(*ob).sloc.len_item*(*ob).sloc.totalitems;
+          imem=_imem+ob->sloc.len_item*ob->sloc.totalitems;
+          ob->sloc.offset=iloc; iloc+=ob->sloc.len_item*ob->sloc.totalitems;
           test_buffer(&mem,&imem_max,imem);
         }
 
@@ -1867,9 +1867,9 @@ void analiza_private(void) {
         } else {
 
           if (pieza!=p_id) error(1,29); // esperando el nombre de la cadena
-          ob=o; if ((*ob).tipo!=tnone) { // Mira si se repite un parámetro ...
-            if (parametros==-1 && (*ob).param==1 && (*ob).bloque==bloque_actual) {
-              if ((*ob).tipo==tcloc) { // Se repite un string
+          ob=o; if (ob->tipo!=tnone) { // Mira si se repite un parámetro ...
+            if (parametros==-1 && ob->param==1 && ob->bloque==bloque_actual) {
+              if (ob->tipo==tcloc) { // Se repite un string
                 save_error(0);
                 lexico();
                 if (pieza==p_corab) {
@@ -1883,50 +1883,50 @@ void analiza_private(void) {
                     lexico();
                   }
                 } else dup=255;
-                if (dup!=(*ob).cloc.totalen) error(4,41); // la longitud no coincide con la declaración anterior
+                if (dup!=ob->cloc.totalen) error(4,41); // la longitud no coincide con la declaración anterior
                 else if (pieza==p_asig) error(0,42); // no se puede inicializar un parámetro
                 else {
                   while (pieza==p_ptocoma || pieza==p_coma) lexico();
-                  (*ob).param++;
+                  ob->param++;
                   continue;
                 }
               } else error(0,30); // el nombre no es nuevo
             } else error(0,30);
           } else lexico();
 
-          (*ob).tipo=tcloc;
+          ob->tipo=tcloc;
           _imem=imem;
           if (pieza==p_corab) {
             lexico();
             if (pieza==p_corce) {
               lexico();
-              (*ob).cloc.totalen=255;
+              ob->cloc.totalen=255;
             } else {
-              if (((*ob).cloc.totalen=constante())<0) error(4,31); // cadena de long. negativa
-              if ((*ob).cloc.totalen>0xFFFFF) error(4,32); // cadena demasiado larga
+              if ((ob->cloc.totalen=constante())<0) error(4,31); // cadena de long. negativa
+              if (ob->cloc.totalen>0xFFFFF) error(4,32); // cadena demasiado larga
               if (pieza!=p_corce) error(3,19); // esperando ']'
               lexico();
             }
-          } else (*ob).cloc.totalen=255;
+          } else ob->cloc.totalen=255;
           if (pieza==p_asig) {
             save_error(1);
             _itxt=itxt;
             lexico();
-            if (pieza!=p_lit && !(pieza==p_id && (*o).tipo==tcons && (*o).cons.literal))
+            if (pieza!=p_lit && !(pieza==p_id && o->tipo==tcons && o->cons.literal))
               error(3,46); // se esperaba un literal
-            if (strlen((char*)&mem[pieza_num])>(*ob).cloc.totalen+1)
+            if (strlen((char*)&mem[pieza_num])>ob->cloc.totalen+1)
               error(4,49); // literal demasiado largo
-            imem=_imem+1+((*ob).cloc.totalen+5)/4; // ej. c[32] -> c[0]..c[32],NUL
+            imem=_imem+1+(ob->cloc.totalen+5)/4; // ej. c[32] -> c[0]..c[32],NUL
             test_buffer(&mem,&imem_max,imem);
             strcpy((char*)&mem[_imem+1],(char*)&mem[pieza_num]);
             itxt=_itxt; // Saca la cadena del segmento de textos
             lexico();
           } else {
-            imem=_imem+1+((*ob).cloc.totalen+5)/4;
+            imem=_imem+1+(ob->cloc.totalen+5)/4;
             test_buffer(&mem,&imem_max,imem);
-          } mem[_imem]=0xDAD00000|(*ob).cloc.totalen;
-          (*ob).cloc.offset=iloc+1;
-          iloc+=1+((*ob).cloc.totalen+5)/4;
+          } mem[_imem]=0xDAD00000|ob->cloc.totalen;
+          ob->cloc.offset=iloc+1;
+          iloc+=1+(ob->cloc.totalen+5)/4;
         }
 
         if (pieza==p_coma) pieza=p_string; else {
@@ -1953,9 +1953,9 @@ void analiza_private(void) {
         } else {
 
           if (pieza!=p_id) error(1,23); // esperando un nombre
-          ob=o; if ((*ob).tipo!=tnone) {
-            if (parametros==-1 && (*ob).param==1 && (*ob).bloque==bloque_actual) {
-              if ((*ob).tipo==tbloc) { // Se repite un byte parámetro
+          ob=o; if (ob->tipo!=tnone) {
+            if (parametros==-1 && ob->param==1 && ob->bloque==bloque_actual) {
+              if (ob->tipo==tbloc) { // Se repite un byte parámetro
                 lexico();
                 if (pieza==p_corab) error(2,33); // no se puede pasar una tabla como parámetro
                 else if (pieza==p_asig) error(0,42); // no se puede inicializar un parámetro
@@ -1963,53 +1963,53 @@ void analiza_private(void) {
                   while (pieza==p_ptocoma || pieza==p_coma) {
                     lexico();
                   }
-                  (*ob).param++;
+                  ob->param++;
                   continue;
                 }
               } else error(0,30); // el nombre no es nuevo
             } else error(0,30);
           } else lexico();
 
-          (*ob).tipo=tbloc; _imem=imem;
+          ob->tipo=tbloc; _imem=imem;
           if (pieza==p_corab) {
             lexico();
             if (pieza==p_corce) {
               lexico(); if (pieza!=p_asig) error(3,7); lexico(); // esperando '='
               oimemptr=(byte*)&mem[imem];
               tglo_init(2);
-              (*ob).bloc.len1=imemptr-oimemptr-1;
-              (*ob).bloc.len2=-1;
-              (*ob).bloc.len3=-1;
-              (*ob).bloc.totalen=((*ob).bloc.len1+4)/4;
+              ob->bloc.len1=imemptr-oimemptr-1;
+              ob->bloc.len2=-1;
+              ob->bloc.len3=-1;
+              ob->bloc.totalen=(ob->bloc.len1+4)/4;
             } else {
-              if (((*ob).bloc.len1=constante())<0) error(4,40); // tabla de long. negativa
+              if ((ob->bloc.len1=constante())<0) error(4,40); // tabla de long. negativa
               if (pieza==p_coma) {
                 lexico();
-                if (((*ob).bloc.len2=constante())<0) error(4,40); // idem
+                if ((ob->bloc.len2=constante())<0) error(4,40); // idem
                 if (pieza==p_coma) {
                   lexico();
-                  if (((*ob).bloc.len3=constante())<0) error(4,40); // reidem
-                } else (*ob).bloc.len3=-1;
-              } else { (*ob).bloc.len2=-1; (*ob).bloc.len3=-1; }
+                  if ((ob->bloc.len3=constante())<0) error(4,40); // reidem
+                } else ob->bloc.len3=-1;
+              } else { ob->bloc.len2=-1; ob->bloc.len3=-1; }
 
-              (*ob).bloc.totalen=(*ob).bloc.len1+1;
-              if ((*ob).bloc.len2>-1) (*ob).bloc.totalen*=(*ob).bloc.len2+1;
-              if ((*ob).bloc.len3>-1) (*ob).bloc.totalen*=(*ob).bloc.len3+1;
+              ob->bloc.totalen=ob->bloc.len1+1;
+              if (ob->bloc.len2>-1) ob->bloc.totalen*=ob->bloc.len2+1;
+              if (ob->bloc.len3>-1) ob->bloc.totalen*=ob->bloc.len3+1;
               if (pieza!=p_corce) error(3,19); lexico(); // esperando ']'
               if (pieza==p_asig) {
                 save_error(1);
                 lexico();
                 oimemptr=(byte*)&mem[imem];
                 tglo_init(2);
-                if (imemptr-oimemptr>(*ob).bloc.totalen) error(4,48); // demasiados valores para la tabla
-              } (*ob).bloc.totalen=((*ob).bloc.totalen+3)/4;
+                if (imemptr-oimemptr>ob->bloc.totalen) error(4,48); // demasiados valores para la tabla
+              } ob->bloc.totalen=(ob->bloc.totalen+3)/4;
             }
           } else {                                          // Byte privado
-            (*ob).tipo=tbloc; (*ob).bloc.offset=imem;
-            (*ob).bloc.len1=0;
-            (*ob).bloc.len2=-1;
-            (*ob).bloc.len3=-1;
-            (*ob).bloc.totalen=1; // 1 int
+            ob->tipo=tbloc; ob->bloc.offset=imem;
+            ob->bloc.len1=0;
+            ob->bloc.len2=-1;
+            ob->bloc.len3=-1;
+            ob->bloc.totalen=1; // 1 int
             if (pieza==p_asig) {
               save_error(1);
               lexico();
@@ -2017,8 +2017,8 @@ void analiza_private(void) {
               if (mem[imem]<0 || mem[imem]>255) error(4,50); // valor byte fuera de rango
             }
           }
-          imem=_imem+(*ob).bloc.totalen; test_buffer(&mem,&imem_max,imem);
-          (*ob).bloc.offset=iloc; iloc+=(*ob).bloc.totalen;
+          imem=_imem+ob->bloc.totalen; test_buffer(&mem,&imem_max,imem);
+          ob->bloc.offset=iloc; iloc+=ob->bloc.totalen;
         }
 
         if (pieza==p_coma) pieza=p_byte; else {
@@ -2045,9 +2045,9 @@ void analiza_private(void) {
         } else {
 
           if (pieza!=p_id) error(1,23); // esperando un nombre
-          ob=o; if ((*ob).tipo!=tnone) {
-            if (parametros==-1 && (*ob).param==1 && (*ob).bloque==bloque_actual) {
-              if ((*ob).tipo==twloc) { // Se repite un word parámetro
+          ob=o; if (ob->tipo!=tnone) {
+            if (parametros==-1 && ob->param==1 && ob->bloque==bloque_actual) {
+              if (ob->tipo==twloc) { // Se repite un word parámetro
                 lexico();
                 if (pieza==p_corab) error(2,33); // no se puede pasar una tabla como parámetro
                 else if (pieza==p_asig) error(0,42); // no se puede inicializar un parámetro
@@ -2055,53 +2055,53 @@ void analiza_private(void) {
                   while (pieza==p_ptocoma || pieza==p_coma) {
                     lexico();
                   }
-                  (*ob).param++;
+                  ob->param++;
                   continue;
                 }
               } else error(0,30); // el nombre no es nuevo
             } else error(0,30);
           } else lexico();
 
-          (*ob).tipo=twloc; _imem=imem;
+          ob->tipo=twloc; _imem=imem;
           if (pieza==p_corab) {
             lexico();
             if (pieza==p_corce) {
               lexico(); if (pieza!=p_asig) error(3,7); lexico(); // esperando '='
               oimemptr=(byte*)&mem[imem];
               tglo_init(1);
-              (*ob).wloc.len1=(imemptr-oimemptr)/2-1;
-              (*ob).wloc.len2=-1;
-              (*ob).wloc.len3=-1;
-              (*ob).wloc.totalen=((*ob).wloc.len1+2)/2;
+              ob->wloc.len1=(imemptr-oimemptr)/2-1;
+              ob->wloc.len2=-1;
+              ob->wloc.len3=-1;
+              ob->wloc.totalen=(ob->wloc.len1+2)/2;
             } else {
-              if (((*ob).wloc.len1=constante())<0) error(4,40); // tabla de long. negativa
+              if ((ob->wloc.len1=constante())<0) error(4,40); // tabla de long. negativa
               if (pieza==p_coma) {
                 lexico();
-                if (((*ob).wloc.len2=constante())<0) error(4,40); // idem
+                if ((ob->wloc.len2=constante())<0) error(4,40); // idem
                 if (pieza==p_coma) {
                   lexico();
-                  if (((*ob).wloc.len3=constante())<0) error(4,40); // reidem
-                } else (*ob).wloc.len3=-1;
-              } else { (*ob).wloc.len2=-1; (*ob).wloc.len3=-1; }
+                  if ((ob->wloc.len3=constante())<0) error(4,40); // reidem
+                } else ob->wloc.len3=-1;
+              } else { ob->wloc.len2=-1; ob->wloc.len3=-1; }
 
-              (*ob).wloc.totalen=(*ob).wloc.len1+1;
-              if ((*ob).wloc.len2>-1) (*ob).wloc.totalen*=(*ob).wloc.len2+1;
-              if ((*ob).wloc.len3>-1) (*ob).wloc.totalen*=(*ob).wloc.len3+1;
+              ob->wloc.totalen=ob->wloc.len1+1;
+              if (ob->wloc.len2>-1) ob->wloc.totalen*=ob->wloc.len2+1;
+              if (ob->wloc.len3>-1) ob->wloc.totalen*=ob->wloc.len3+1;
               if (pieza!=p_corce) error(3,19); lexico(); // esperando ']'
               if (pieza==p_asig) {
                 save_error(1);
                 lexico();
                 oimemptr=(byte*)&mem[imem];
                 tglo_init(1);
-                if (imemptr-oimemptr>(*ob).wloc.totalen*2) error(4,48); // demasiados valores para la tabla
-              } (*ob).wloc.totalen=((*ob).wloc.totalen+1)/2;
+                if (imemptr-oimemptr>ob->wloc.totalen*2) error(4,48); // demasiados valores para la tabla
+              } ob->wloc.totalen=(ob->wloc.totalen+1)/2;
             }
           } else {                                          // Word privado
-            (*ob).tipo=twloc; (*ob).wloc.offset=imem;
-            (*ob).wloc.len1=0;
-            (*ob).wloc.len2=-1;
-            (*ob).wloc.len3=-1;
-            (*ob).wloc.totalen=1; // 1 int
+            ob->tipo=twloc; ob->wloc.offset=imem;
+            ob->wloc.len1=0;
+            ob->wloc.len2=-1;
+            ob->wloc.len3=-1;
+            ob->wloc.totalen=1; // 1 int
             if (pieza==p_asig) {
               save_error(1);
               lexico();
@@ -2109,8 +2109,8 @@ void analiza_private(void) {
               if (mem[imem]<0 || mem[imem]>65535) error(4,51); // valor word fuera de rango
             }
           }
-          imem=_imem+(*ob).wloc.totalen; test_buffer(&mem,&imem_max,imem);
-          (*ob).wloc.offset=iloc; iloc+=(*ob).wloc.totalen;
+          imem=_imem+ob->wloc.totalen; test_buffer(&mem,&imem_max,imem);
+          ob->wloc.offset=iloc; iloc+=ob->wloc.totalen;
         }
 
         if (pieza==p_coma) pieza=p_word; else {
@@ -2141,9 +2141,9 @@ void analiza_private(void) {
 
           // Si el objeto no es tnone, se repite un parámetro o bien es un error
 
-          ob=o; if ((*ob).tipo!=tnone) {
-            if (parametros==-1 && (*ob).param==1 && (*ob).bloque==bloque_actual) {
-              if ((*ob).tipo==tvloc) { // Se repite una variable local
+          ob=o; if (ob->tipo!=tnone) {
+            if (parametros==-1 && ob->param==1 && ob->bloque==bloque_actual) {
+              if (ob->tipo==tvloc) { // Se repite una variable local
                 lexico();
                 if (pieza==p_corab) error(2,33); // no se puede pasar una tabla como parámetro
                 else if (pieza==p_asig) error(0,42); // no se puede inicializar un parámetro
@@ -2151,7 +2151,7 @@ void analiza_private(void) {
                   while (pieza==p_ptocoma || pieza==p_coma) {
                     lexico();
                   }
-                  (*ob).param++;
+                  ob->param++;
                   continue;
                 }
               } else error(0,30); // el nombre no es nuevo
@@ -2160,46 +2160,46 @@ void analiza_private(void) {
 
           if (pieza==p_corab) {                             // Tabla privada
             lexico();
-            (*ob).tipo=ttloc; _imem=imem;
+            ob->tipo=ttloc; _imem=imem;
             if (pieza==p_corce) {
               lexico(); if (pieza!=p_asig) error(3,7); lexico(); // esperando '='
               tglo_init(3);
-              (*ob).tloc.len1=imem-_imem-1;
-              (*ob).tloc.len2=-1;
-              (*ob).tloc.len3=-1;
-              (*ob).tloc.totalen=imem-_imem;
+              ob->tloc.len1=imem-_imem-1;
+              ob->tloc.len2=-1;
+              ob->tloc.len3=-1;
+              ob->tloc.totalen=imem-_imem;
             } else {
-              if (((*ob).tloc.len1=constante())<0) error(4,40); // tabla de long. negativa
+              if ((ob->tloc.len1=constante())<0) error(4,40); // tabla de long. negativa
               if (pieza==p_coma) {
                 lexico();
-                if (((*ob).tloc.len2=constante())<0) error(4,40); // idem
+                if ((ob->tloc.len2=constante())<0) error(4,40); // idem
                 if (pieza==p_coma) {
                   lexico();
-                  if (((*ob).tloc.len3=constante())<0) error(4,40); // reidem
-                } else (*ob).tloc.len3=-1;
-              } else { (*ob).tloc.len2=-1; (*ob).tloc.len3=-1; }
-              (*ob).tloc.totalen=(*ob).tloc.len1+1;
-              if ((*ob).tloc.len2>-1) (*ob).tloc.totalen*=(*ob).tloc.len2+1;
-              if ((*ob).tloc.len3>-1) (*ob).tloc.totalen*=(*ob).tloc.len3+1;
+                  if ((ob->tloc.len3=constante())<0) error(4,40); // reidem
+                } else ob->tloc.len3=-1;
+              } else { ob->tloc.len2=-1; ob->tloc.len3=-1; }
+              ob->tloc.totalen=ob->tloc.len1+1;
+              if (ob->tloc.len2>-1) ob->tloc.totalen*=ob->tloc.len2+1;
+              if (ob->tloc.len3>-1) ob->tloc.totalen*=ob->tloc.len3+1;
               if (pieza!=p_corce) error(3,19); lexico(); // esperando ']'
               if (pieza==p_asig) {
                 save_error(1); lexico(); tglo_init(3);
-                if (imem-_imem>(*ob).tloc.totalen) error(4,48); } // demasiados valores para la tabla
+                if (imem-_imem>ob->tloc.totalen) error(4,48); } // demasiados valores para la tabla
             }
-            imem=_imem+(*ob).tloc.totalen;
+            imem=_imem+ob->tloc.totalen;
             test_buffer(&mem,&imem_max,imem);
-            (*ob).tloc.offset=iloc; iloc+=(*ob).tloc.totalen;
+            ob->tloc.offset=iloc; iloc+=ob->tloc.totalen;
 
           } else {                                          // Variable privada
 
-            (*ob).tipo=tvloc; (*ob).vloc.offset=iloc++;
+            ob->tipo=tvloc; ob->vloc.offset=iloc++;
             if (pieza==p_asig) { lexico(); mem[imem]=constante(); }
             test_buffer(&mem,&imem_max,++imem);
           }
         }
         if (!free_sintax) if (pieza!=p_ptocoma && pieza!=p_coma) error(3,9); // esperando ';'
         while (pieza==p_ptocoma || pieza==p_coma) lexico();
-      } (*ob).bloque=bloque_actual;
+      } ob->bloque=bloque_actual;
     }
 
     mem[_imem_old]=imem;
@@ -2218,9 +2218,9 @@ struct objeto * analiza_pointer(int tipo, int offset)
   int len1,len2,len3;
 
   if (pieza!=p_id) error(1,23);	// esperando un nombre
-  ob=o; if ((*ob).tipo!=tnone) {
-    if (parametros==-1 && (*ob).param==1 && (*ob).bloque==bloque_actual) {
-      if ((*ob).tipo==tipo) { // Se repite un pointer parámetro como private
+  ob=o; if (ob->tipo!=tnone) {
+    if (parametros==-1 && ob->param==1 && ob->bloque==bloque_actual) {
+      if (ob->tipo==tipo) { // Se repite un pointer parámetro como private
         save_error(0); lexico();
         len1=-1; len2=-1; len3=-1;
         if (pieza==p_corab) { lexico();
@@ -2234,35 +2234,35 @@ struct objeto * analiza_pointer(int tipo, int offset)
             }
           } if (pieza!=p_corce) error(3,19); lexico(); // esperando ']'
         }
-        if (len1!=(*ob).pilo.len1 || len2!=(*ob).pilo.len2 || len3!=(*ob).pilo.len3) error(4,41); // la longitud no coincide con la declaración anterior
+        if (len1!=ob->pilo.len1 || len2!=ob->pilo.len2 || len3!=ob->pilo.len3) error(4,41); // la longitud no coincide con la declaración anterior
         else if (pieza==p_asig) error(0,42); // no se puede inicializar un parámetro
         else {
           while (pieza==p_ptocoma || pieza==p_coma) lexico();
-          (*ob).param++; // No permite volver a redeclararlo
+          ob->param++; // No permite volver a redeclararlo
           return(NULL);
         }
       } else error(0,30); // el nombre no es nuevo
     } else error(0,30);
   } else lexico();
-  if (parametros==-1) (*ob).bloque=bloque_actual;
-  (*ob).pilo.len1=-1; (*ob).pilo.len2=-1; (*ob).pilo.len3=-1;
+  if (parametros==-1) ob->bloque=bloque_actual;
+  ob->pilo.len1=-1; ob->pilo.len2=-1; ob->pilo.len3=-1;
   if (pieza==p_corab) { lexico();
-    if (((*ob).pilo.len1=constante())<0) error(4,40); // tabla de longitud negativa
+    if ((ob->pilo.len1=constante())<0) error(4,40); // tabla de longitud negativa
     if (pieza==p_coma) {
       lexico();
-      if (((*ob).pilo.len2=constante())<0) error(4,40); // tabla de longitud negativa
+      if ((ob->pilo.len2=constante())<0) error(4,40); // tabla de longitud negativa
       if (pieza==p_coma) {
         lexico();
-        if (((*ob).pilo.len3=constante())<0) error(4,40); // tabla de longitud negativa
+        if ((ob->pilo.len3=constante())<0) error(4,40); // tabla de longitud negativa
       }
     }
     if (pieza!=p_corce) error(3,19); lexico(); // esperando ']'
-  } (*ob).pilo.totalen=0;
-  if ((*ob).pilo.len1>-1) (*ob).pilo.totalen=(*ob).pilo.len1+1;
-  if ((*ob).pilo.len2>-1) (*ob).pilo.totalen*=(*ob).pilo.len2+1;
-  if ((*ob).pilo.len3>-1) (*ob).pilo.totalen*=(*ob).pilo.len3+1;
+  } ob->pilo.totalen=0;
+  if (ob->pilo.len1>-1) ob->pilo.totalen=ob->pilo.len1+1;
+  if (ob->pilo.len2>-1) ob->pilo.totalen*=ob->pilo.len2+1;
+  if (ob->pilo.len3>-1) ob->pilo.totalen*=ob->pilo.len3+1;
 
-  (*ob).tipo=tipo; (*ob).pilo.offset=offset;
+  ob->tipo=tipo; ob->pilo.offset=offset;
 
   return(ob);
 }
@@ -2288,8 +2288,8 @@ int analiza_struct(int offstruct) { // tras " struct id [ <const> ] " // idðmem
         old_member=member; member=NULL; lexico(); member=old_member;
         if (pieza!=p_id) error(1,27); ob=o; // esperando el nombre de la estructura
 
-        if ((*ob).tipo==tnone) error(0,28); // No se define el pointer así
-        if ((*ob).tipo!=tsglo && (*ob).tipo!=tsloc) error(0,28);
+        if (ob->tipo==tnone) error(0,28); // No se define el pointer así
+        if (ob->tipo!=tsglo && ob->tipo!=tsloc) error(0,28);
         lexico();
         puntero_a_struct:
         analiza_pointer_struct(tpsgl,len,ob);
@@ -2312,41 +2312,41 @@ int analiza_struct(int offstruct) { // tras " struct id [ <const> ] " // idðmem
         if (pieza!=p_id) error(1,27); // esperando el nombre de la estructura
         ob=o;
         old_member=member; member=ob; lexico();
-        if ((*ob).tipo!=tnone) error(2,30); // el nombre no es nuevo
+        if (ob->tipo!=tnone) error(2,30); // el nombre no es nuevo
 
-        (*ob).tipo=tsglo; (*ob).sglo.offset=len;
+        ob->tipo=tsglo; ob->sglo.offset=len;
         if (pieza==p_corab) {
           member2=member; member=NULL; lexico();
-          if (((*ob).sglo.items1=constante())<0) error(4,43); // estructura de longitud negativa
+          if ((ob->sglo.items1=constante())<0) error(4,43); // estructura de longitud negativa
           if (pieza==p_coma) {
             lexico();
-            if (((*ob).sglo.items2=constante())<0) error(4,43); // idem
+            if ((ob->sglo.items2=constante())<0) error(4,43); // idem
             if (pieza==p_coma) {
               lexico();
-              if (((*ob).sglo.items3=constante())<0) error(4,43); // reidem
-            } else (*ob).sglo.items3=-1;
-          } else { (*ob).sglo.items2=-1; (*ob).sglo.items3=-1; }
+              if ((ob->sglo.items3=constante())<0) error(4,43); // reidem
+            } else ob->sglo.items3=-1;
+          } else { ob->sglo.items2=-1; ob->sglo.items3=-1; }
           member=member2;
-          (*ob).sglo.totalitems=(*ob).sglo.items1+1;
-          if ((*ob).sglo.items2>-1) (*ob).sglo.totalitems*=(*ob).sglo.items2+1;
-          if ((*ob).sglo.items3>-1) (*ob).sglo.totalitems*=(*ob).sglo.items3+1;
+          ob->sglo.totalitems=ob->sglo.items1+1;
+          if (ob->sglo.items2>-1) ob->sglo.totalitems*=ob->sglo.items2+1;
+          if (ob->sglo.items3>-1) ob->sglo.totalitems*=ob->sglo.items3+1;
           if (pieza!=p_corce) error(3,19); lexico(); // esperando ']'
         } else {
-          (*ob).sglo.totalitems=1;
-          (*ob).sglo.items1=0; (*ob).sglo.items2=-1; (*ob).sglo.items3=-1;
+          ob->sglo.totalitems=1;
+          ob->sglo.items1=0; ob->sglo.items2=-1; ob->sglo.items3=-1;
         }
-        if (((*ob).sglo.len_item=analiza_struct(offstruct+len))==0) error(0,47); // estructura vacia
-        i=offstruct+len; dup=(*ob).sglo.totalitems+1;
+        if ((ob->sglo.len_item=analiza_struct(offstruct+len))==0) error(0,47); // estructura vacia
+        i=offstruct+len; dup=ob->sglo.totalitems+1;
         if (dup>1) {
-          test_buffer(&mem,&imem_max,i+(*ob).sglo.len_item*(*ob).sglo.totalitems);
-          test_buffer(&frm,&ifrm_max,i+(*ob).sglo.len_item*(*ob).sglo.totalitems);
+          test_buffer(&mem,&imem_max,i+ob->sglo.len_item*ob->sglo.totalitems);
+          test_buffer(&frm,&ifrm_max,i+ob->sglo.len_item*ob->sglo.totalitems);
           while (--dup) {
-            memcpy(&mem[i],&mem[offstruct+len],(*ob).sglo.len_item<<2);
-            memcpy(&frm[i],&frm[offstruct+len],(*ob).sglo.len_item<<2);
-            i+=(*ob).sglo.len_item;
+            memcpy(&mem[i],&mem[offstruct+len],ob->sglo.len_item<<2);
+            memcpy(&frm[i],&frm[offstruct+len],ob->sglo.len_item<<2);
+            i+=ob->sglo.len_item;
           }
         }
-        len+=(*ob).sglo.len_item*(*ob).sglo.totalitems;
+        len+=ob->sglo.len_item*ob->sglo.totalitems;
         member=old_member; lexico();
         while (pieza==p_ptocoma) lexico();
       }
@@ -2371,20 +2371,20 @@ int analiza_struct(int offstruct) { // tras " struct id [ <const> ] " // idðmem
       } else {
 
         if (pieza!=p_id) error(1,29); // esperando el nombre de la cadena
-        ob=o; if ((*ob).tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
-        (*ob).tipo=tcglo; (*ob).cglo.offset=len+1;
+        ob=o; if (ob->tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
+        ob->tipo=tcglo; ob->cglo.offset=len+1;
         if (pieza==p_corab) {
           lexico();
           if (pieza==p_corce) {
             lexico();
-            (*ob).cglo.totalen=255;
+            ob->cglo.totalen=255;
           } else {
-            if (((*ob).cglo.totalen=constante())<0) error(4,31); // cadena de longitud negativa
-            if ((*ob).cglo.totalen>0xFFFFF) error(4,32); // cadena demasiado larga
+            if ((ob->cglo.totalen=constante())<0) error(4,31); // cadena de longitud negativa
+            if (ob->cglo.totalen>0xFFFFF) error(4,32); // cadena demasiado larga
             if (pieza!=p_corce) error(3,19); // esperando ']'
             lexico();
           }
-        } else (*ob).cglo.totalen=255;
+        } else ob->cglo.totalen=255;
 
         test_buffer(&frm,&ifrm_max,offstruct+len);
         frm[offstruct+len]=0xDAD00000;
@@ -2393,20 +2393,20 @@ int analiza_struct(int offstruct) { // tras " struct id [ <const> ] " // idðmem
           save_error(1);
           _itxt=itxt;
           lexico();
-          if (pieza!=p_lit && !(pieza==p_id && (*o).tipo==tcons && (*o).cons.literal))
+          if (pieza!=p_lit && !(pieza==p_id && o->tipo==tcons && o->cons.literal))
             error(3,46); // se esperaba un literal
-          if (strlen((char*)&mem[pieza_num])>(*ob).cglo.totalen+1)
+          if (strlen((char*)&mem[pieza_num])>ob->cglo.totalen+1)
             error(4,49); // literal demasiado largo
           test_buffer(&mem,&imem_max,offstruct+len);
-          mem[offstruct+len]=0xDAD00000|(*ob).cglo.totalen;
+          mem[offstruct+len]=0xDAD00000|ob->cglo.totalen;
           strcpy((char*)&mem[offstruct+len+1],(char*)&mem[pieza_num]);
-          len+=1+((*ob).cglo.totalen+5)/4;
+          len+=1+(ob->cglo.totalen+5)/4;
           itxt=_itxt; // Saca la cadena del segmento de textos
           lexico();
         } else {
           test_buffer(&mem,&imem_max,offstruct+len);
-          mem[offstruct+len]=0xDAD00000|(*ob).cglo.totalen;
-          len+=1+((*ob).cglo.totalen+5)/4;
+          mem[offstruct+len]=0xDAD00000|ob->cglo.totalen;
+          len+=1+(ob->cglo.totalen+5)/4;
         }
       }
 
@@ -2436,41 +2436,41 @@ int analiza_struct(int offstruct) { // tras " struct id [ <const> ] " // idðmem
       } else {
 
         if (pieza!=p_id) error(1,23); // esperando un nombre
-        ob=o; if ((*ob).tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
-        (*ob).tipo=tbglo; (*ob).bglo.offset=len;
+        ob=o; if (ob->tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
+        ob->tipo=tbglo; ob->bglo.offset=len;
         if (pieza==p_corab) { lexico();
-          if (((*ob).bglo.len1=constante())<0) error(4,40); // tabla de longitud negativa
+          if ((ob->bglo.len1=constante())<0) error(4,40); // tabla de longitud negativa
           if (pieza==p_coma) {
             lexico();
-            if (((*ob).bglo.len2=constante())<0) error(4,40); // idem
+            if ((ob->bglo.len2=constante())<0) error(4,40); // idem
             if (pieza==p_coma) {
               lexico();
-              if (((*ob).bglo.len3=constante())<0) error(4,40); // reidem
-            } else (*ob).bglo.len3=-1;
-          } else { (*ob).bglo.len2=-1; (*ob).bglo.len3=-1; }
-          (*ob).bglo.totalen=(*ob).bglo.len1+1;
-          if ((*ob).bglo.len2>-1) (*ob).bglo.totalen*=(*ob).bglo.len2+1;
-          if ((*ob).bglo.len3>-1) (*ob).bglo.totalen*=(*ob).bglo.len3+1;
+              if ((ob->bglo.len3=constante())<0) error(4,40); // reidem
+            } else ob->bglo.len3=-1;
+          } else { ob->bglo.len2=-1; ob->bglo.len3=-1; }
+          ob->bglo.totalen=ob->bglo.len1+1;
+          if (ob->bglo.len2>-1) ob->bglo.totalen*=ob->bglo.len2+1;
+          if (ob->bglo.len3>-1) ob->bglo.totalen*=ob->bglo.len3+1;
           if (pieza!=p_corce) error(3,19); lexico(); // esperando ']'
-          test_buffer(&mem,&imem_max,offstruct+len+((*ob).bglo.totalen+3)/4);
+          test_buffer(&mem,&imem_max,offstruct+len+(ob->bglo.totalen+3)/4);
 
-          test_buffer(&frm,&ifrm_max,offstruct+len+((*ob).bglo.totalen+3)/4);
-          memset(&frm[offstruct+len],2,(*ob).bglo.totalen);
+          test_buffer(&frm,&ifrm_max,offstruct+len+(ob->bglo.totalen+3)/4);
+          memset(&frm[offstruct+len],2,ob->bglo.totalen);
 
           if (pieza==p_asig) {
             _imem=imem; imem=offstruct+len;
             save_error(1); lexico();
             oimemptr=(byte*)&mem[imem];
             tglo_init(2);
-            if (imemptr-oimemptr>(*ob).bglo.totalen) error(4,48); // demasiados valores para la tabla
+            if (imemptr-oimemptr>ob->bglo.totalen) error(4,48); // demasiados valores para la tabla
             imem=_imem;
-          } (*ob).bglo.totalen=((*ob).bglo.totalen+3)/4;
+          } ob->bglo.totalen=(ob->bglo.totalen+3)/4;
         } else {
-          (*ob).tipo=tbglo; (*ob).bglo.offset=len;
-          (*ob).bglo.len1=0;
-          (*ob).bglo.len2=-1;
-          (*ob).bglo.len3=-1;
-          (*ob).bglo.totalen=1; // 1 int
+          ob->tipo=tbglo; ob->bglo.offset=len;
+          ob->bglo.len1=0;
+          ob->bglo.len2=-1;
+          ob->bglo.len3=-1;
+          ob->bglo.totalen=1; // 1 int
 
           test_buffer(&frm,&ifrm_max,offstruct+len);
           frm[offstruct+len]=2;
@@ -2482,7 +2482,7 @@ int analiza_struct(int offstruct) { // tras " struct id [ <const> ] " // idðmem
             mem[offstruct+len]=constante();
             if (mem[offstruct+len]<0 || mem[offstruct+len]>255) error(4,50); // valor byte fuera de rango
           }
-        } len+=(*ob).bglo.totalen;
+        } len+=ob->bglo.totalen;
       }
 
       if (pieza==p_coma) pieza=p_byte; else {
@@ -2510,41 +2510,41 @@ int analiza_struct(int offstruct) { // tras " struct id [ <const> ] " // idðmem
       } else {
 
         if (pieza!=p_id) error(1,23); // esperando un nombre
-        ob=o; if ((*ob).tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
-        (*ob).tipo=twglo; (*ob).wglo.offset=len;
+        ob=o; if (ob->tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
+        ob->tipo=twglo; ob->wglo.offset=len;
         if (pieza==p_corab) { lexico();
-          if (((*ob).wglo.len1=constante())<0) error(4,40); // tabla de longitud negativa
+          if ((ob->wglo.len1=constante())<0) error(4,40); // tabla de longitud negativa
           if (pieza==p_coma) {
             lexico();
-            if (((*ob).wglo.len2=constante())<0) error(4,40); // idem
+            if ((ob->wglo.len2=constante())<0) error(4,40); // idem
             if (pieza==p_coma) {
               lexico();
-              if (((*ob).wglo.len3=constante())<0) error(4,40); // idem
-            } else (*ob).wglo.len3=-1;
-          } else { (*ob).wglo.len2=-1; (*ob).wglo.len3=-1; }
-          (*ob).wglo.totalen=(*ob).wglo.len1+1;
-          if ((*ob).wglo.len2>-1) (*ob).wglo.totalen*=(*ob).wglo.len2+1;
-          if ((*ob).wglo.len3>-1) (*ob).wglo.totalen*=(*ob).wglo.len3+1;
+              if ((ob->wglo.len3=constante())<0) error(4,40); // idem
+            } else ob->wglo.len3=-1;
+          } else { ob->wglo.len2=-1; ob->wglo.len3=-1; }
+          ob->wglo.totalen=ob->wglo.len1+1;
+          if (ob->wglo.len2>-1) ob->wglo.totalen*=ob->wglo.len2+1;
+          if (ob->wglo.len3>-1) ob->wglo.totalen*=ob->wglo.len3+1;
           if (pieza!=p_corce) error(3,19); lexico(); // esperando ']'
-          test_buffer(&mem,&imem_max,offstruct+len+((*ob).wglo.totalen+1)/2);
+          test_buffer(&mem,&imem_max,offstruct+len+(ob->wglo.totalen+1)/2);
 
-          test_buffer(&frm,&ifrm_max,offstruct+len+((*ob).wglo.totalen+1)/2);
-          memset(&frm[offstruct+len],1,(*ob).wglo.totalen*2);
+          test_buffer(&frm,&ifrm_max,offstruct+len+(ob->wglo.totalen+1)/2);
+          memset(&frm[offstruct+len],1,ob->wglo.totalen*2);
 
           if (pieza==p_asig) {
             _imem=imem; imem=offstruct+len;
             save_error(1); lexico();
             oimemptr=(byte*)&mem[imem];
             tglo_init(1);
-            if (imemptr-oimemptr>(*ob).wglo.totalen*2) error(4,48); // demasiados valores para la tabla
+            if (imemptr-oimemptr>ob->wglo.totalen*2) error(4,48); // demasiados valores para la tabla
             imem=_imem;
-          } (*ob).wglo.totalen=((*ob).wglo.totalen+1)/2;
+          } ob->wglo.totalen=(ob->wglo.totalen+1)/2;
         } else {
-          (*ob).tipo=twglo; (*ob).wglo.offset=len;
-          (*ob).wglo.len1=0;
-          (*ob).wglo.len2=-1;
-          (*ob).wglo.len3=-1;
-          (*ob).wglo.totalen=1; // 1 int
+          ob->tipo=twglo; ob->wglo.offset=len;
+          ob->wglo.len1=0;
+          ob->wglo.len2=-1;
+          ob->wglo.len3=-1;
+          ob->wglo.totalen=1; // 1 int
 
           test_buffer(&frm,&ifrm_max,offstruct+len);
           frm[offstruct+len]=1;
@@ -2556,7 +2556,7 @@ int analiza_struct(int offstruct) { // tras " struct id [ <const> ] " // idðmem
             mem[offstruct+len]=constante();
             if (mem[offstruct+len]<0 || mem[offstruct+len]>65535) error(4,51); // valor word fuera de rango
           }
-        } len+=(*ob).wglo.totalen;
+        } len+=ob->wglo.totalen;
       }
 
       if (pieza==p_coma) pieza=p_word; else {
@@ -2586,34 +2586,34 @@ int analiza_struct(int offstruct) { // tras " struct id [ <const> ] " // idðmem
 
       } else {
 
-        ob=o; if ((*ob).tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
+        ob=o; if (ob->tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
         if (pieza==p_corab) { lexico();                   // Miembro tabla
-          (*ob).tipo=ttglo; (*ob).tglo.offset=len;
-          if (((*ob).tglo.len1=constante())<0) error(4,40); // tabla de longitud negativa
+          ob->tipo=ttglo; ob->tglo.offset=len;
+          if ((ob->tglo.len1=constante())<0) error(4,40); // tabla de longitud negativa
           if (pieza==p_coma) {
             lexico();
-            if (((*ob).tglo.len2=constante())<0) error(4,40); // idem
+            if ((ob->tglo.len2=constante())<0) error(4,40); // idem
             if (pieza==p_coma) {
               lexico();
-              if (((*ob).tglo.len3=constante())<0) error(4,40); // idem
-            } else (*ob).tglo.len3=-1;
-          } else { (*ob).tglo.len2=-1; (*ob).tglo.len3=-1; }
-          (*ob).tglo.totalen=(*ob).tglo.len1+1;
-          if ((*ob).tglo.len2>-1) (*ob).tglo.totalen*=(*ob).tglo.len2+1;
-          if ((*ob).tglo.len3>-1) (*ob).tglo.totalen*=(*ob).tglo.len3+1;
+              if ((ob->tglo.len3=constante())<0) error(4,40); // idem
+            } else ob->tglo.len3=-1;
+          } else { ob->tglo.len2=-1; ob->tglo.len3=-1; }
+          ob->tglo.totalen=ob->tglo.len1+1;
+          if (ob->tglo.len2>-1) ob->tglo.totalen*=ob->tglo.len2+1;
+          if (ob->tglo.len3>-1) ob->tglo.totalen*=ob->tglo.len3+1;
           if (pieza!=p_corce) error(3,19); lexico(); // esperando ']'
 
-          test_buffer(&mem,&imem_max,offstruct+len+(*ob).tglo.totalen);
+          test_buffer(&mem,&imem_max,offstruct+len+ob->tglo.totalen);
           if (pieza==p_asig) {
             _imem=imem; imem=offstruct+len;
             save_error(1); lexico(); tglo_init(0);
-            if (imem-(offstruct+len)>(*ob).tglo.totalen) error(4,48); // demasiados valores para la tabla
+            if (imem-(offstruct+len)>ob->tglo.totalen) error(4,48); // demasiados valores para la tabla
             imem=_imem;
-          } len+=(*ob).tglo.totalen;
+          } len+=ob->tglo.totalen;
 
         } else {                                          // Miembro variable
 
-          (*ob).tipo=tvglo; (*ob).vglo.offset=len;
+          ob->tipo=tvglo; ob->vglo.offset=len;
           test_buffer(&mem,&imem_max,offstruct+len);
           if (pieza==p_asig) {
             lexico(); mem[offstruct+len]=constante();
@@ -2648,8 +2648,8 @@ int analiza_struct_local(int offstruct) { // tras " struct id [ <const> ] " // i
         old_member=member; member=NULL; lexico(); member=old_member;
         if (pieza!=p_id) error(1,27); ob=o; // esperando el nombre de la estructura
 
-        if ((*ob).tipo==tnone) error(0,28); // No se define el pointer así
-        if ((*ob).tipo!=tsglo && (*ob).tipo!=tsloc) error(0,28);
+        if (ob->tipo==tnone) error(0,28); // No se define el pointer así
+        if (ob->tipo!=tsglo && ob->tipo!=tsloc) error(0,28);
         lexico();
         puntero_a_struct:
         analiza_pointer_struct(tpslo,len,ob);
@@ -2673,41 +2673,41 @@ int analiza_struct_local(int offstruct) { // tras " struct id [ <const> ] " // i
         ob=o;
 
         old_member=member; member=ob; lexico();
-        if ((*ob).tipo!=tnone) error(2,30); // el nombre no es nuevo
+        if (ob->tipo!=tnone) error(2,30); // el nombre no es nuevo
 
-        (*ob).tipo=tsloc; (*ob).sloc.offset=len;
+        ob->tipo=tsloc; ob->sloc.offset=len;
         if (pieza==p_corab) {
           member2=member; member=NULL; lexico();
-          if (((*ob).sloc.items1=constante())<0) error(4,43); // estructura de long. negativa
+          if ((ob->sloc.items1=constante())<0) error(4,43); // estructura de long. negativa
           if (pieza==p_coma) {
             lexico();
-            if (((*ob).sloc.items2=constante())<0) error(4,43); // idem
+            if ((ob->sloc.items2=constante())<0) error(4,43); // idem
             if (pieza==p_coma) {
               lexico();
-              if (((*ob).sloc.items3=constante())<0) error(4,43); // reidem
-            } else (*ob).sloc.items3=-1;
-          } else { (*ob).sloc.items2=-1; (*ob).sloc.items3=-1; }
+              if ((ob->sloc.items3=constante())<0) error(4,43); // reidem
+            } else ob->sloc.items3=-1;
+          } else { ob->sloc.items2=-1; ob->sloc.items3=-1; }
           member=member2;
-          (*ob).sloc.totalitems=(*ob).sloc.items1+1;
-          if ((*ob).sloc.items2>-1) (*ob).sloc.totalitems*=(*ob).sloc.items2+1;
-          if ((*ob).sloc.items3>-1) (*ob).sloc.totalitems*=(*ob).sloc.items3+1;
+          ob->sloc.totalitems=ob->sloc.items1+1;
+          if (ob->sloc.items2>-1) ob->sloc.totalitems*=ob->sloc.items2+1;
+          if (ob->sloc.items3>-1) ob->sloc.totalitems*=ob->sloc.items3+1;
           if (pieza!=p_corce) error(3,19); lexico(); // esperando ']'
         } else {
-          (*ob).sloc.totalitems=1;
-          (*ob).sloc.items1=0; (*ob).sloc.items2=-1; (*ob).sloc.items3=-1;
+          ob->sloc.totalitems=1;
+          ob->sloc.items1=0; ob->sloc.items2=-1; ob->sloc.items3=-1;
         }
-        if (((*ob).sloc.len_item=analiza_struct_local(offstruct+len))==0) error(0,47); // estructura vacia
-        i=offstruct+len; dup=(*ob).sloc.totalitems+1;
+        if ((ob->sloc.len_item=analiza_struct_local(offstruct+len))==0) error(0,47); // estructura vacia
+        i=offstruct+len; dup=ob->sloc.totalitems+1;
         if (dup>1) {
-          test_buffer(&loc,&iloc_max,i+(*ob).sloc.len_item*(*ob).sloc.totalitems);
-          test_buffer(&frm,&ifrm_max,i+(*ob).sloc.len_item*(*ob).sloc.totalitems);
+          test_buffer(&loc,&iloc_max,i+ob->sloc.len_item*ob->sloc.totalitems);
+          test_buffer(&frm,&ifrm_max,i+ob->sloc.len_item*ob->sloc.totalitems);
           while (--dup) {
-            memcpy(&loc[i],&loc[offstruct+len],(*ob).sloc.len_item<<2);
-            memcpy(&frm[i],&frm[offstruct+len],(*ob).sloc.len_item<<2);
-            i+=(*ob).sloc.len_item;
+            memcpy(&loc[i],&loc[offstruct+len],ob->sloc.len_item<<2);
+            memcpy(&frm[i],&frm[offstruct+len],ob->sloc.len_item<<2);
+            i+=ob->sloc.len_item;
           }
         }
-        len+=(*ob).sloc.len_item*(*ob).sloc.totalitems;
+        len+=ob->sloc.len_item*ob->sloc.totalitems;
         member=old_member; lexico();
         while (pieza==p_ptocoma) lexico();
       }
@@ -2732,20 +2732,20 @@ int analiza_struct_local(int offstruct) { // tras " struct id [ <const> ] " // i
       } else {
 
         if (pieza!=p_id) error(1,29); // esperando el nombre de la cadena
-        ob=o; if ((*ob).tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
-        (*ob).tipo=tcloc; (*ob).cloc.offset=len+1;
+        ob=o; if (ob->tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
+        ob->tipo=tcloc; ob->cloc.offset=len+1;
         if (pieza==p_corab) {
           lexico();
           if (pieza==p_corce) {
             lexico();
-            (*ob).cloc.totalen=255;
+            ob->cloc.totalen=255;
           } else {
-            if (((*ob).cloc.totalen=constante())<0) error(4,31); // cadena de long. negativa
-            if ((*ob).cloc.totalen>0xFFFFF) error(4,32); // cadena demasiado larga
+            if ((ob->cloc.totalen=constante())<0) error(4,31); // cadena de long. negativa
+            if (ob->cloc.totalen>0xFFFFF) error(4,32); // cadena demasiado larga
             if (pieza!=p_corce) error(3,19); // esperando ']'
             lexico();
           }
-        } else (*ob).cloc.totalen=255;
+        } else ob->cloc.totalen=255;
 
         test_buffer(&frm,&ifrm_max,offstruct+len);
         frm[offstruct+len]=0xDAD00000;
@@ -2754,20 +2754,20 @@ int analiza_struct_local(int offstruct) { // tras " struct id [ <const> ] " // i
           save_error(1);
           _itxt=itxt;
           lexico();
-          if (pieza!=p_lit && !(pieza==p_id && (*o).tipo==tcons && (*o).cons.literal))
+          if (pieza!=p_lit && !(pieza==p_id && o->tipo==tcons && o->cons.literal))
             error(3,46); // se esperaba un literal
-          if (strlen((char*)&mem[pieza_num])>(*ob).cloc.totalen+1)
+          if (strlen((char*)&mem[pieza_num])>ob->cloc.totalen+1)
             error(4,49); // literal demasiado largo
           test_buffer(&loc,&iloc_max,offstruct+len);
-          loc[offstruct+len]=0xDAD00000|(*ob).cloc.totalen;
+          loc[offstruct+len]=0xDAD00000|ob->cloc.totalen;
           strcpy((char*)&loc[offstruct+len+1],(char*)&mem[pieza_num]);
-          len+=1+((*ob).cloc.totalen+5)/4;
+          len+=1+(ob->cloc.totalen+5)/4;
           itxt=_itxt; // Saca la cadena del segmento de textos
           lexico();
         } else {
           test_buffer(&loc,&iloc_max,offstruct+len);
-          loc[offstruct+len]=0xDAD00000|(*ob).cloc.totalen;
-          len+=1+((*ob).cloc.totalen+5)/4;
+          loc[offstruct+len]=0xDAD00000|ob->cloc.totalen;
+          len+=1+(ob->cloc.totalen+5)/4;
         }
       }
 
@@ -2796,42 +2796,42 @@ int analiza_struct_local(int offstruct) { // tras " struct id [ <const> ] " // i
       } else {
 
         if (pieza!=p_id) error(1,23); // esperando un nombre
-        ob=o; if ((*ob).tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
-        (*ob).tipo=tbloc; (*ob).bloc.offset=len;
+        ob=o; if (ob->tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
+        ob->tipo=tbloc; ob->bloc.offset=len;
         if (pieza==p_corab) { lexico();
-          if (((*ob).bloc.len1=constante())<0) error(4,40); // tabla de long. negativa
+          if ((ob->bloc.len1=constante())<0) error(4,40); // tabla de long. negativa
           if (pieza==p_coma) {
             lexico();
-            if (((*ob).bloc.len2=constante())<0) error(4,40); // idem
+            if ((ob->bloc.len2=constante())<0) error(4,40); // idem
             if (pieza==p_coma) {
               lexico();
-              if (((*ob).bloc.len3=constante())<0) error(4,40); // reidem
-            } else (*ob).bloc.len3=-1;
-          } else { (*ob).bloc.len2=-1; (*ob).bloc.len3=-1; }
-          (*ob).bloc.totalen=(*ob).bloc.len1+1;
-          if ((*ob).bloc.len2>-1) (*ob).bloc.totalen*=(*ob).bloc.len2+1;
-          if ((*ob).bloc.len3>-1) (*ob).bloc.totalen*=(*ob).bloc.len3+1;
+              if ((ob->bloc.len3=constante())<0) error(4,40); // reidem
+            } else ob->bloc.len3=-1;
+          } else { ob->bloc.len2=-1; ob->bloc.len3=-1; }
+          ob->bloc.totalen=ob->bloc.len1+1;
+          if (ob->bloc.len2>-1) ob->bloc.totalen*=ob->bloc.len2+1;
+          if (ob->bloc.len3>-1) ob->bloc.totalen*=ob->bloc.len3+1;
           if (pieza!=p_corce) error(3,19); lexico(); // esperando ']'
 
-          test_buffer(&loc,&iloc_max,offstruct+len+((*ob).bloc.totalen+3)/4);
+          test_buffer(&loc,&iloc_max,offstruct+len+(ob->bloc.totalen+3)/4);
 
-          test_buffer(&frm,&ifrm_max,offstruct+len+((*ob).bloc.totalen+3)/4);
-          memset(&frm[offstruct+len],2,(*ob).bloc.totalen);
+          test_buffer(&frm,&ifrm_max,offstruct+len+(ob->bloc.totalen+3)/4);
+          memset(&frm[offstruct+len],2,ob->bloc.totalen);
 
           if (pieza==p_asig) {
             _iloc=iloc; iloc=offstruct+len;
             save_error(1); lexico();
             oimemptr=(byte*)&loc[iloc];
             tloc_init(2);
-            if (imemptr-oimemptr>(*ob).bloc.totalen) error(4,48); // demasiados valores para la tabla
+            if (imemptr-oimemptr>ob->bloc.totalen) error(4,48); // demasiados valores para la tabla
             iloc=_iloc;
-          } (*ob).bloc.totalen=((*ob).bloc.totalen+3)/4;
+          } ob->bloc.totalen=(ob->bloc.totalen+3)/4;
         } else {
-          (*ob).tipo=tbloc; (*ob).bloc.offset=len;
-          (*ob).bloc.len1=0;
-          (*ob).bloc.len2=-1;
-          (*ob).bloc.len3=-1;
-          (*ob).bloc.totalen=1; // 1 int
+          ob->tipo=tbloc; ob->bloc.offset=len;
+          ob->bloc.len1=0;
+          ob->bloc.len2=-1;
+          ob->bloc.len3=-1;
+          ob->bloc.totalen=1; // 1 int
 
           test_buffer(&frm,&ifrm_max,offstruct+len);
           frm[offstruct+len]=2;
@@ -2843,7 +2843,7 @@ int analiza_struct_local(int offstruct) { // tras " struct id [ <const> ] " // i
             loc[offstruct+len]=constante();
             if (loc[offstruct+len]<0 || loc[offstruct+len]>255) error(4,51); // valor byte fuera de rango
           }
-        } len+=(*ob).bloc.totalen;
+        } len+=ob->bloc.totalen;
       }
 
       if (pieza==p_coma) pieza=p_byte; else {
@@ -2871,42 +2871,42 @@ int analiza_struct_local(int offstruct) { // tras " struct id [ <const> ] " // i
       } else {
 
         if (pieza!=p_id) error(1,23); // esperando un nombre
-        ob=o; if ((*ob).tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
-        (*ob).tipo=twloc; (*ob).wloc.offset=len;
+        ob=o; if (ob->tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
+        ob->tipo=twloc; ob->wloc.offset=len;
         if (pieza==p_corab) { lexico();
-          if (((*ob).wloc.len1=constante())<0) error(4,40); // tabla de long. negativa
+          if ((ob->wloc.len1=constante())<0) error(4,40); // tabla de long. negativa
           if (pieza==p_coma) {
             lexico();
-            if (((*ob).wloc.len2=constante())<0) error(4,40); // idem
+            if ((ob->wloc.len2=constante())<0) error(4,40); // idem
             if (pieza==p_coma) {
               lexico();
-              if (((*ob).wloc.len3=constante())<0) error(4,40); // reidem
-            } else (*ob).wloc.len3=-1;
-          } else { (*ob).wloc.len2=-1; (*ob).wloc.len3=-1; }
-          (*ob).wloc.totalen=(*ob).wloc.len1+1;
-          if ((*ob).wloc.len2>-1) (*ob).wloc.totalen*=(*ob).wloc.len2+1;
-          if ((*ob).wloc.len3>-1) (*ob).wloc.totalen*=(*ob).wloc.len3+1;
+              if ((ob->wloc.len3=constante())<0) error(4,40); // reidem
+            } else ob->wloc.len3=-1;
+          } else { ob->wloc.len2=-1; ob->wloc.len3=-1; }
+          ob->wloc.totalen=ob->wloc.len1+1;
+          if (ob->wloc.len2>-1) ob->wloc.totalen*=ob->wloc.len2+1;
+          if (ob->wloc.len3>-1) ob->wloc.totalen*=ob->wloc.len3+1;
           if (pieza!=p_corce) error(3,19); lexico(); // esperando ']'
 
-          test_buffer(&loc,&iloc_max,offstruct+len+((*ob).wloc.totalen+1)/2);
+          test_buffer(&loc,&iloc_max,offstruct+len+(ob->wloc.totalen+1)/2);
 
-          test_buffer(&frm,&ifrm_max,offstruct+len+((*ob).wloc.totalen+1)/2);
-          memset(&frm[offstruct+len],1,(*ob).wloc.totalen*2);
+          test_buffer(&frm,&ifrm_max,offstruct+len+(ob->wloc.totalen+1)/2);
+          memset(&frm[offstruct+len],1,ob->wloc.totalen*2);
 
           if (pieza==p_asig) {
             _iloc=iloc; iloc=offstruct+len;
             save_error(1); lexico();
             oimemptr=(byte*)&loc[iloc];
             tloc_init(1);
-            if (imemptr-oimemptr>(*ob).wloc.totalen*2) error(4,48); // demasiados valores para la tabla
+            if (imemptr-oimemptr>ob->wloc.totalen*2) error(4,48); // demasiados valores para la tabla
             iloc=_iloc;
-          } (*ob).wloc.totalen=((*ob).wloc.totalen+1)/2;
+          } ob->wloc.totalen=(ob->wloc.totalen+1)/2;
         } else {
-          (*ob).tipo=twloc; (*ob).wloc.offset=len;
-          (*ob).wloc.len1=0;
-          (*ob).wloc.len2=-1;
-          (*ob).wloc.len3=-1;
-          (*ob).wloc.totalen=1; // 1 int
+          ob->tipo=twloc; ob->wloc.offset=len;
+          ob->wloc.len1=0;
+          ob->wloc.len2=-1;
+          ob->wloc.len3=-1;
+          ob->wloc.totalen=1; // 1 int
 
           test_buffer(&frm,&ifrm_max,offstruct+len);
           frm[offstruct+len]=1;
@@ -2918,7 +2918,7 @@ int analiza_struct_local(int offstruct) { // tras " struct id [ <const> ] " // i
             loc[offstruct+len]=constante();
             if (loc[offstruct+len]<0 || loc[offstruct+len]>65535) error(4,51); // valor word fuera de rango
           }
-        } len+=(*ob).wloc.totalen;
+        } len+=ob->wloc.totalen;
       }
 
       if (pieza==p_coma) pieza=p_word; else {
@@ -2948,34 +2948,34 @@ int analiza_struct_local(int offstruct) { // tras " struct id [ <const> ] " // i
 
       } else {
 
-        ob=o; if ((*ob).tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
+        ob=o; if (ob->tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
         if (pieza==p_corab) { lexico();    // Miembro tabla
-          (*ob).tipo=ttloc; (*ob).tloc.offset=len;
-          if (((*ob).tloc.len1=constante())<0) error(4,40); // tabla de long. negativa
+          ob->tipo=ttloc; ob->tloc.offset=len;
+          if ((ob->tloc.len1=constante())<0) error(4,40); // tabla de long. negativa
           if (pieza==p_coma) {
             lexico();
-            if (((*ob).tloc.len2=constante())<0) error(4,40); // idem
+            if ((ob->tloc.len2=constante())<0) error(4,40); // idem
             if (pieza==p_coma) {
               lexico();
-              if (((*ob).tloc.len3=constante())<0) error(4,40); // reidem
-            } else (*ob).tloc.len3=-1;
-          } else { (*ob).tloc.len2=-1; (*ob).tloc.len3=-1; }
-          (*ob).tloc.totalen=(*ob).tloc.len1+1;
-          if ((*ob).tloc.len2>-1) (*ob).tloc.totalen*=(*ob).tloc.len2+1;
-          if ((*ob).tloc.len3>-1) (*ob).tloc.totalen*=(*ob).tloc.len3+1;
+              if ((ob->tloc.len3=constante())<0) error(4,40); // reidem
+            } else ob->tloc.len3=-1;
+          } else { ob->tloc.len2=-1; ob->tloc.len3=-1; }
+          ob->tloc.totalen=ob->tloc.len1+1;
+          if (ob->tloc.len2>-1) ob->tloc.totalen*=ob->tloc.len2+1;
+          if (ob->tloc.len3>-1) ob->tloc.totalen*=ob->tloc.len3+1;
           if (pieza!=p_corce) error(3,19); lexico(); // esperando ']'
 
-          test_buffer(&loc,&iloc_max,offstruct+len+(*ob).tloc.totalen);
+          test_buffer(&loc,&iloc_max,offstruct+len+ob->tloc.totalen);
           if (pieza==p_asig) {
             _iloc=iloc; iloc=offstruct+len;
             save_error(1); lexico(); tloc_init(0);
-            if (iloc-(offstruct+len)>(*ob).tloc.totalen) error(4,48); // demasiados valores para la tabla
+            if (iloc-(offstruct+len)>ob->tloc.totalen) error(4,48); // demasiados valores para la tabla
             iloc=_iloc;
-          } len+=(*ob).tloc.totalen;
+          } len+=ob->tloc.totalen;
 
         } else {                                          // Miembro variable
 
-          (*ob).tipo=tvloc; (*ob).vloc.offset=len;
+          ob->tipo=tvloc; ob->vloc.offset=len;
           test_buffer(&loc,&iloc_max,offstruct+len);
           if (pieza==p_asig) {
             lexico(); loc[offstruct+len]=constante();
@@ -2986,7 +2986,7 @@ int analiza_struct_local(int offstruct) { // tras " struct id [ <const> ] " // i
       if (!free_sintax) if (pieza!=p_ptocoma && pieza!=p_coma) error(3,9); // esperando ';'
       while (pieza==p_ptocoma || pieza==p_coma) lexico();
     } else { error(0,39); do lexico(); while (pieza==p_ptocoma); } // esperando un elemento de la estructura
-    (*ob).bloque=bloque_lexico;
+    ob->bloque=bloque_lexico;
   } return(len);
 }
 
@@ -3012,8 +3012,8 @@ int analiza_struct_private(int offstruct) { // tras " struct id [ <const> ] " //
         old_member=member; member=NULL; lexico(); member=old_member;
         if (pieza!=p_id) error(1,27); ob=o; // esperando el nombre de la estructura
 
-        if ((*ob).tipo==tnone) error(0,28); // No se define el pointer así
-        if ((*ob).tipo!=tsglo && (*ob).tipo!=tsloc) error(0,28);
+        if (ob->tipo==tnone) error(0,28); // No se define el pointer así
+        if (ob->tipo!=tsglo && ob->tipo!=tsloc) error(0,28);
         lexico();
         puntero_a_struct:
         analiza_pointer_struct(tpslo,len,ob);
@@ -3037,41 +3037,41 @@ int analiza_struct_private(int offstruct) { // tras " struct id [ <const> ] " //
         ob=o;
 
         old_member=member; member=ob; lexico();
-        if ((*ob).tipo!=tnone) error(2,30); // el nombre no es nuevo
+        if (ob->tipo!=tnone) error(2,30); // el nombre no es nuevo
 
-        (*ob).tipo=tsloc; (*ob).sloc.offset=len;
+        ob->tipo=tsloc; ob->sloc.offset=len;
         if (pieza==p_corab) {
           member2=member; member=NULL; lexico();
-          if (((*ob).sloc.items1=constante())<0) error(4,43); // estructura de long. negativa
+          if ((ob->sloc.items1=constante())<0) error(4,43); // estructura de long. negativa
           if (pieza==p_coma) {
             lexico();
-            if (((*ob).sloc.items2=constante())<0) error(4,43); // idem
+            if ((ob->sloc.items2=constante())<0) error(4,43); // idem
             if (pieza==p_coma) {
               lexico();
-              if (((*ob).sloc.items3=constante())<0) error(4,43); // reidem
-            } else (*ob).sloc.items3=-1;
-          } else { (*ob).sloc.items2=-1; (*ob).sloc.items3=-1; }
+              if ((ob->sloc.items3=constante())<0) error(4,43); // reidem
+            } else ob->sloc.items3=-1;
+          } else { ob->sloc.items2=-1; ob->sloc.items3=-1; }
           member=member2;
-          (*ob).sloc.totalitems=(*ob).sloc.items1+1;
-          if ((*ob).sloc.items2>-1) (*ob).sloc.totalitems*=(*ob).sloc.items2+1;
-          if ((*ob).sloc.items3>-1) (*ob).sloc.totalitems*=(*ob).sloc.items3+1;
+          ob->sloc.totalitems=ob->sloc.items1+1;
+          if (ob->sloc.items2>-1) ob->sloc.totalitems*=ob->sloc.items2+1;
+          if (ob->sloc.items3>-1) ob->sloc.totalitems*=ob->sloc.items3+1;
           if (pieza!=p_corce) error(3,19); lexico(); // esperando ']'
         } else {
-          (*ob).sloc.totalitems=1;
-          (*ob).sloc.items1=0; (*ob).sloc.items2=-1; (*ob).sloc.items3=-1;
+          ob->sloc.totalitems=1;
+          ob->sloc.items1=0; ob->sloc.items2=-1; ob->sloc.items3=-1;
         }
-        if (((*ob).sloc.len_item=analiza_struct_private(offstruct+len))==0) error(0,55); // demasiados valores para la estructura
-        i=offstruct+len; dup=(*ob).sloc.totalitems+1;
+        if ((ob->sloc.len_item=analiza_struct_private(offstruct+len))==0) error(0,55); // demasiados valores para la estructura
+        i=offstruct+len; dup=ob->sloc.totalitems+1;
         if (dup>1) {
-          test_buffer(&mem,&imem_max,i+(*ob).sloc.len_item*(*ob).sloc.totalitems);
-          test_buffer(&frm,&ifrm_max,i+(*ob).sloc.len_item*(*ob).sloc.totalitems);
+          test_buffer(&mem,&imem_max,i+ob->sloc.len_item*ob->sloc.totalitems);
+          test_buffer(&frm,&ifrm_max,i+ob->sloc.len_item*ob->sloc.totalitems);
           while (--dup) {
-            memcpy(&mem[i],&mem[offstruct+len],(*ob).sloc.len_item<<2);
-            memcpy(&frm[i],&frm[offstruct+len],(*ob).sloc.len_item<<2);
-            i+=(*ob).sloc.len_item;
+            memcpy(&mem[i],&mem[offstruct+len],ob->sloc.len_item<<2);
+            memcpy(&frm[i],&frm[offstruct+len],ob->sloc.len_item<<2);
+            i+=ob->sloc.len_item;
           }
         }
-        len+=(*ob).sloc.len_item*(*ob).sloc.totalitems;
+        len+=ob->sloc.len_item*ob->sloc.totalitems;
         member=old_member; lexico();
         while (pieza==p_ptocoma) lexico();
       }
@@ -3096,20 +3096,20 @@ int analiza_struct_private(int offstruct) { // tras " struct id [ <const> ] " //
       } else {
 
         if (pieza!=p_id) error(1,23); // esperando un nombre
-        ob=o; if ((*ob).tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
-        (*ob).tipo=tcloc; (*ob).cloc.offset=len+1;
+        ob=o; if (ob->tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
+        ob->tipo=tcloc; ob->cloc.offset=len+1;
         if (pieza==p_corab) {
           lexico();
           if (pieza==p_corce) {
             lexico();
-            (*ob).cloc.totalen=255;
+            ob->cloc.totalen=255;
           } else {
-            if (((*ob).cloc.totalen=constante())<0) error(4,31); // cadena de long. negativa
-            if ((*ob).cloc.totalen>0xFFFFF) error(4,32); // cadena demasiado larga
+            if ((ob->cloc.totalen=constante())<0) error(4,31); // cadena de long. negativa
+            if (ob->cloc.totalen>0xFFFFF) error(4,32); // cadena demasiado larga
             if (pieza!=p_corce) error(3,19); // esperando ']'
             lexico();
           }
-        } else (*ob).cloc.totalen=255;
+        } else ob->cloc.totalen=255;
 
         test_buffer(&frm,&ifrm_max,offstruct+len);
         frm[offstruct+len]=0xDAD00000;
@@ -3118,20 +3118,20 @@ int analiza_struct_private(int offstruct) { // tras " struct id [ <const> ] " //
           save_error(1);
           _itxt=itxt;
           lexico();
-          if (pieza!=p_lit && !(pieza==p_id && (*o).tipo==tcons && (*o).cons.literal))
+          if (pieza!=p_lit && !(pieza==p_id && o->tipo==tcons && o->cons.literal))
             error(3,46); // se esperaba un literal
-          if (strlen((char*)&mem[pieza_num])>(*ob).cloc.totalen+1)
+          if (strlen((char*)&mem[pieza_num])>ob->cloc.totalen+1)
             error(4,49); // literal demasiado largo
           test_buffer(&mem,&imem_max,offstruct+len);
-          mem[offstruct+len]=0xDAD00000|(*ob).cloc.totalen;
+          mem[offstruct+len]=0xDAD00000|ob->cloc.totalen;
           strcpy((char*)&mem[offstruct+len+1],(char*)&mem[pieza_num]);
-          len+=1+((*ob).cloc.totalen+5)/4;
+          len+=1+(ob->cloc.totalen+5)/4;
           itxt=_itxt; // Saca la cadena del segmento de textos
           lexico();
         } else {
           test_buffer(&mem,&imem_max,offstruct+len);
-          mem[offstruct+len]=0xDAD00000|(*ob).cloc.totalen;
-          len+=1+((*ob).cloc.totalen+5)/4;
+          mem[offstruct+len]=0xDAD00000|ob->cloc.totalen;
+          len+=1+(ob->cloc.totalen+5)/4;
         }
       }
 
@@ -3160,41 +3160,41 @@ int analiza_struct_private(int offstruct) { // tras " struct id [ <const> ] " //
       } else {
 
         if (pieza!=p_id) error(1,23); // esperando un nombre
-        ob=o; if ((*ob).tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
-        (*ob).tipo=tbloc; (*ob).bloc.offset=len;
+        ob=o; if (ob->tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
+        ob->tipo=tbloc; ob->bloc.offset=len;
         if (pieza==p_corab) { lexico();
-          if (((*ob).bloc.len1=constante())<0) error(4,40); // tabla de long. negativa
+          if ((ob->bloc.len1=constante())<0) error(4,40); // tabla de long. negativa
           if (pieza==p_coma) {
             lexico();
-            if (((*ob).bloc.len2=constante())<0) error(4,40); // idem
+            if ((ob->bloc.len2=constante())<0) error(4,40); // idem
             if (pieza==p_coma) {
               lexico();
-              if (((*ob).bloc.len3=constante())<0) error(4,40); // reidem
-            } else (*ob).bloc.len3=-1;
-          } else { (*ob).bloc.len2=-1; (*ob).bloc.len3=-1; }
-          (*ob).bloc.totalen=(*ob).bloc.len1+1;
-          if ((*ob).bloc.len2>-1) (*ob).bloc.totalen*=(*ob).bloc.len2+1;
-          if ((*ob).bloc.len3>-1) (*ob).bloc.totalen*=(*ob).bloc.len3+1;
+              if ((ob->bloc.len3=constante())<0) error(4,40); // reidem
+            } else ob->bloc.len3=-1;
+          } else { ob->bloc.len2=-1; ob->bloc.len3=-1; }
+          ob->bloc.totalen=ob->bloc.len1+1;
+          if (ob->bloc.len2>-1) ob->bloc.totalen*=ob->bloc.len2+1;
+          if (ob->bloc.len3>-1) ob->bloc.totalen*=ob->bloc.len3+1;
           if (pieza!=p_corce) error(3,19); lexico(); // esperando ']'
-          test_buffer(&mem,&imem_max,offstruct+len+((*ob).bloc.totalen+3)/4);
+          test_buffer(&mem,&imem_max,offstruct+len+(ob->bloc.totalen+3)/4);
 
-          test_buffer(&frm,&ifrm_max,offstruct+len+((*ob).bloc.totalen+3)/4);
-          memset(&frm[offstruct+len],2,(*ob).bloc.totalen);
+          test_buffer(&frm,&ifrm_max,offstruct+len+(ob->bloc.totalen+3)/4);
+          memset(&frm[offstruct+len],2,ob->bloc.totalen);
 
           if (pieza==p_asig) {
             _imem=imem; imem=offstruct+len;
             save_error(1); lexico();
             oimemptr=(byte*)&mem[imem];
             tglo_init(2);
-            if (imemptr-oimemptr>(*ob).bloc.totalen) error(4,48); // demasiados valores para la tabla
+            if (imemptr-oimemptr>ob->bloc.totalen) error(4,48); // demasiados valores para la tabla
             imem=_imem;
-          } (*ob).bloc.totalen=((*ob).bloc.totalen+3)/4;
+          } ob->bloc.totalen=(ob->bloc.totalen+3)/4;
         } else {
-          (*ob).tipo=tbloc; (*ob).bloc.offset=len;
-          (*ob).bloc.len1=0;
-          (*ob).bloc.len2=-1;
-          (*ob).bloc.len3=-1;
-          (*ob).bloc.totalen=1; // 1 int
+          ob->tipo=tbloc; ob->bloc.offset=len;
+          ob->bloc.len1=0;
+          ob->bloc.len2=-1;
+          ob->bloc.len3=-1;
+          ob->bloc.totalen=1; // 1 int
 
           test_buffer(&frm,&ifrm_max,offstruct+len);
           frm[offstruct+len]=2;
@@ -3206,7 +3206,7 @@ int analiza_struct_private(int offstruct) { // tras " struct id [ <const> ] " //
             mem[offstruct+len]=constante();
             if (mem[offstruct+len]<0 || mem[offstruct+len]>255) error(4,50); // valor byte fuera de rango
           }
-        } len+=(*ob).bloc.totalen;
+        } len+=ob->bloc.totalen;
       }
 
       if (pieza==p_coma) pieza=p_byte; else {
@@ -3234,41 +3234,41 @@ int analiza_struct_private(int offstruct) { // tras " struct id [ <const> ] " //
       } else {
 
         if (pieza!=p_id) error(1,23); // esperando un nombre
-        ob=o; if ((*ob).tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
-        (*ob).tipo=twloc; (*ob).wloc.offset=len;
+        ob=o; if (ob->tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
+        ob->tipo=twloc; ob->wloc.offset=len;
         if (pieza==p_corab) { lexico();
-          if (((*ob).wloc.len1=constante())<0) error(4,40); // tabla de long. negativa
+          if ((ob->wloc.len1=constante())<0) error(4,40); // tabla de long. negativa
           if (pieza==p_coma) {
             lexico();
-            if (((*ob).wloc.len2=constante())<0) error(4,40); // idem
+            if ((ob->wloc.len2=constante())<0) error(4,40); // idem
             if (pieza==p_coma) {
               lexico();
-              if (((*ob).wloc.len3=constante())<0) error(4,40); // reidem
-            } else (*ob).wloc.len3=-1;
-          } else { (*ob).wloc.len2=-1; (*ob).wloc.len3=-1; }
-          (*ob).wloc.totalen=(*ob).wloc.len1+1;
-          if ((*ob).wloc.len2>-1) (*ob).wloc.totalen*=(*ob).wloc.len2+1;
-          if ((*ob).wloc.len3>-1) (*ob).wloc.totalen*=(*ob).wloc.len3+1;
+              if ((ob->wloc.len3=constante())<0) error(4,40); // reidem
+            } else ob->wloc.len3=-1;
+          } else { ob->wloc.len2=-1; ob->wloc.len3=-1; }
+          ob->wloc.totalen=ob->wloc.len1+1;
+          if (ob->wloc.len2>-1) ob->wloc.totalen*=ob->wloc.len2+1;
+          if (ob->wloc.len3>-1) ob->wloc.totalen*=ob->wloc.len3+1;
           if (pieza!=p_corce) error(3,19); lexico(); // esperando ']'
-          test_buffer(&mem,&imem_max,offstruct+len+((*ob).wloc.totalen+1)/2);
+          test_buffer(&mem,&imem_max,offstruct+len+(ob->wloc.totalen+1)/2);
 
-          test_buffer(&frm,&ifrm_max,offstruct+len+((*ob).wloc.totalen+1)/2);
-          memset(&frm[offstruct+len],1,(*ob).wloc.totalen*2);
+          test_buffer(&frm,&ifrm_max,offstruct+len+(ob->wloc.totalen+1)/2);
+          memset(&frm[offstruct+len],1,ob->wloc.totalen*2);
 
           if (pieza==p_asig) {
             _imem=imem; imem=offstruct+len;
             save_error(1); lexico();
             oimemptr=(byte*)&mem[imem];
             tglo_init(1);
-            if (imemptr-oimemptr>(*ob).wloc.totalen*2) error(4,48); // demasiados valores para la tabla
+            if (imemptr-oimemptr>ob->wloc.totalen*2) error(4,48); // demasiados valores para la tabla
             imem=_imem;
-          } (*ob).wloc.totalen=((*ob).wloc.totalen+1)/2;
+          } ob->wloc.totalen=(ob->wloc.totalen+1)/2;
         } else {
-          (*ob).tipo=twloc; (*ob).wloc.offset=len;
-          (*ob).wloc.len1=0;
-          (*ob).wloc.len2=-1;
-          (*ob).wloc.len3=-1;
-          (*ob).wloc.totalen=1; // 1 int
+          ob->tipo=twloc; ob->wloc.offset=len;
+          ob->wloc.len1=0;
+          ob->wloc.len2=-1;
+          ob->wloc.len3=-1;
+          ob->wloc.totalen=1; // 1 int
 
           test_buffer(&frm,&ifrm_max,offstruct+len);
           frm[offstruct+len]=1;
@@ -3280,7 +3280,7 @@ int analiza_struct_private(int offstruct) { // tras " struct id [ <const> ] " //
             mem[offstruct+len]=constante();
             if (mem[offstruct+len]<0 || mem[offstruct+len]>65535) error(4,51); // valor word fuera de rango
           }
-        } len+=(*ob).wloc.totalen;
+        } len+=ob->wloc.totalen;
       }
 
       if (pieza==p_coma) pieza=p_word; else {
@@ -3310,34 +3310,34 @@ int analiza_struct_private(int offstruct) { // tras " struct id [ <const> ] " //
 
       } else {
 
-        ob=o; if ((*ob).tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
+        ob=o; if (ob->tipo!=tnone) error(0,30); lexico(); // el nombre no es nuevo
         if (pieza==p_corab) { lexico();    // Miembro tabla
-          (*ob).tipo=ttloc; (*ob).tloc.offset=len;
-          if (((*ob).tloc.len1=constante())<0) error(4,40); // tabla de long. negativa
+          ob->tipo=ttloc; ob->tloc.offset=len;
+          if ((ob->tloc.len1=constante())<0) error(4,40); // tabla de long. negativa
           if (pieza==p_coma) {
             lexico();
-            if (((*ob).tloc.len2=constante())<0) error(4,40); // idem
+            if ((ob->tloc.len2=constante())<0) error(4,40); // idem
             if (pieza==p_coma) {
               lexico();
-              if (((*ob).tloc.len3=constante())<0) error(4,40); // reidem
-            } else (*ob).tloc.len3=-1;
-          } else { (*ob).tloc.len2=-1; (*ob).tloc.len3=-1; }
-          (*ob).tloc.totalen=(*ob).tloc.len1+1;
-          if ((*ob).tloc.len2>-1) (*ob).tloc.totalen*=(*ob).tloc.len2+1;
-          if ((*ob).tloc.len3>-1) (*ob).tloc.totalen*=(*ob).tloc.len3+1;
+              if ((ob->tloc.len3=constante())<0) error(4,40); // reidem
+            } else ob->tloc.len3=-1;
+          } else { ob->tloc.len2=-1; ob->tloc.len3=-1; }
+          ob->tloc.totalen=ob->tloc.len1+1;
+          if (ob->tloc.len2>-1) ob->tloc.totalen*=ob->tloc.len2+1;
+          if (ob->tloc.len3>-1) ob->tloc.totalen*=ob->tloc.len3+1;
           if (pieza!=p_corce) error(3,19); lexico(); // esperando ']'
 
-          test_buffer(&mem,&imem_max,offstruct+len+(*ob).tloc.totalen);
+          test_buffer(&mem,&imem_max,offstruct+len+ob->tloc.totalen);
           if (pieza==p_asig) {
             _imem=imem; imem=offstruct+len;
             save_error(1); lexico(); tglo_init(0);
-            if (imem-(offstruct+len)>(*ob).tloc.totalen) error(4,48); // demasiados valores para la tabla
+            if (imem-(offstruct+len)>ob->tloc.totalen) error(4,48); // demasiados valores para la tabla
             imem=_imem;
-          } len+=(*ob).tloc.totalen;
+          } len+=ob->tloc.totalen;
 
         } else {                                          // Miembro variable
 
-          (*ob).tipo=tvloc; (*ob).vloc.offset=len;
+          ob->tipo=tvloc; ob->vloc.offset=len;
 
           test_buffer(&mem,&imem_max,offstruct+len);
           if (pieza==p_asig) {
@@ -3351,7 +3351,7 @@ int analiza_struct_private(int offstruct) { // tras " struct id [ <const> ] " //
       while (pieza==p_ptocoma || pieza==p_coma) lexico();
 
     } else { error(0,39); do lexico(); while (pieza==p_ptocoma); } // esperando un elemento de la estructura
-    (*ob).bloque=bloque_lexico;
+    ob->bloque=bloque_lexico;
   } return(len);
 }
 
@@ -3364,9 +3364,9 @@ int analiza_pointer_struct(int tipo, int offset, struct objeto * estructura)
   int items1,items2,items3;
 
   if (pieza!=p_id) error(1,23); // esperando un nombre
-  ob=o; if ((*ob).tipo!=tnone) {
-    if (parametros==-1 && (*ob).param==1 && (*ob).bloque==bloque_actual) {
-      if ((*ob).tipo==tipo) { // Se repite un pointer parámetro como private
+  ob=o; if (ob->tipo!=tnone) {
+    if (parametros==-1 && ob->param==1 && ob->bloque==bloque_actual) {
+      if (ob->tipo==tipo) { // Se repite un pointer parámetro como private
         save_error(0); lexico();
         items1=-1; items2=-1; items3=-1;
         if (pieza==p_corab) { lexico();
@@ -3380,37 +3380,37 @@ int analiza_pointer_struct(int tipo, int offset, struct objeto * estructura)
             }
           } if (pieza!=p_corce) error(3,19); lexico(); // esperando ']'
         }
-        if (items1!=(*ob).psgl.items1 || items2!=(*ob).psgl.items2 || items3!=(*ob).psgl.items3)  error(4,41); // la longitud no coincide con la declaración anterior
+        if (items1!=ob->psgl.items1 || items2!=ob->psgl.items2 || items3!=ob->psgl.items3)  error(4,41); // la longitud no coincide con la declaración anterior
         else if (pieza==p_asig) error(0,42); // no se puede inicializar un parámetro
         else {
-          (*ob).param++; return(0); // No permite volver a redeclararlo
+          ob->param++; return(0); // No permite volver a redeclararlo
         }
       } else error(0,30); // el nombre no es nuevo
     } else error(0,30);
   } else lexico();
-  if (parametros==-1) (*ob).bloque=bloque_actual;
-  (*ob).psgl.items1=-1; (*ob).psgl.items2=-1; (*ob).psgl.items3=-1;
+  if (parametros==-1) ob->bloque=bloque_actual;
+  ob->psgl.items1=-1; ob->psgl.items2=-1; ob->psgl.items3=-1;
   if (pieza==p_corab) { lexico();
-    if (((*ob).psgl.items1=constante())<0) error(4,43); // estructura de longitud negativa
+    if ((ob->psgl.items1=constante())<0) error(4,43); // estructura de longitud negativa
     if (pieza==p_coma) {
       lexico();
-      if (((*ob).psgl.items2=constante())<0) error(4,43); // estructura de longitud negativa
+      if ((ob->psgl.items2=constante())<0) error(4,43); // estructura de longitud negativa
       if (pieza==p_coma) {
         lexico();
-        if (((*ob).psgl.items3=constante())<0) error(4,43); // estructura de longitud negativa
+        if ((ob->psgl.items3=constante())<0) error(4,43); // estructura de longitud negativa
       }
     }
     if (pieza!=p_corce) error(3,19); lexico(); // esperando ']'
-  } (*ob).psgl.totalitems=0;
-  if ((*ob).psgl.items1>-1) (*ob).psgl.totalitems=(*ob).psgl.items1+1;
-  if ((*ob).psgl.items2>-1) (*ob).psgl.totalitems*=(*ob).psgl.items2+1;
-  if ((*ob).psgl.items3>-1) (*ob).psgl.totalitems*=(*ob).psgl.items3+1;
+  } ob->psgl.totalitems=0;
+  if (ob->psgl.items1>-1) ob->psgl.totalitems=ob->psgl.items1+1;
+  if (ob->psgl.items2>-1) ob->psgl.totalitems*=ob->psgl.items2+1;
+  if (ob->psgl.items3>-1) ob->psgl.totalitems*=ob->psgl.items3+1;
 
-  (*ob).tipo=tipo;                // tpsgl o tpslo
-  (*ob).psgl.offset=offset;       // del pointer
-  (*ob).psgl.ostruct=estructura;  // struct original
+  ob->tipo=tipo;                // tpsgl o tpslo
+  ob->psgl.offset=offset;       // del pointer
+  ob->psgl.ostruct=estructura;  // struct original
 
-  // (*ob).psgl.len_item ð (*((*ob).psgl.ostruct)).len_item;
+  // ob->psgl.len_item ð (*(ob->psgl.ostruct)).len_item;
 
   return(1);
 }
@@ -3503,7 +3503,7 @@ void tglo_init2(int tipo) {
       dup=2; lexico();
       if (pieza!=p_abrir) error(3,22); // esperando '('
 
-    } else if (pieza==p_lit || (pieza==p_id && (*o).tipo==tcons && (*o).cons.literal)) {
+    } else if (pieza==p_lit || (pieza==p_id && o->tipo==tcons && o->cons.literal)) {
 
       valor=pieza_num; lexico();
       if (pieza==p_abrir || pieza==p_dup) error(2,52); // no se puede duplicar 0 o menos veces (se ha indicado un literal como número de veces)
diff --git a/ediv/src/ediv/parser.h b/ediv/src/ediv/parser.h
index 818a755..e676322 100644
--- a/ediv/src/ediv/parser.h
+++ b/ediv/src/ediv/parser.h
@@ -442,4 +442,4 @@ void tglo_init(int tipo);
 void tloc_init(int tipo);
 void tglo_init2(int tipo);
 
-#endif /* __EDIV_PARSER_H_ */
\ No newline at end of file
+#endif /* __EDIV_PARSER_H_ */
diff --git a/ediv/src/shared/dll_load.h b/ediv/src/shared/dll_load.h
index 78721fc..24e4999 100644
--- a/ediv/src/shared/dll_load.h
+++ b/ediv/src/shared/dll_load.h
@@ -61,4 +61,4 @@ void CheckWindowsVersion(void);
 
 
 
-#endif // __DLL_LOAD_H__
\ No newline at end of file
+#endif // __DLL_LOAD_H__
diff --git a/ediv/src/shared/edivfont.h b/ediv/src/shared/edivfont.h
index 619f159..d5605ac 100644
--- a/ediv/src/shared/edivfont.h
+++ b/ediv/src/shared/edivfont.h
@@ -42,4 +42,4 @@ struct _fuente_control_s{
 	SDL_Surface *imagen ;
 };
 
-#endif
\ No newline at end of file
+#endif
diff --git a/ediv/src/shared/extern.h b/ediv/src/shared/extern.h
index 3733e8d..ee90e7e 100644
--- a/ediv/src/shared/extern.h
+++ b/ediv/src/shared/extern.h
@@ -305,4 +305,4 @@ int n_dlls;				/* Número de DLLs requeridas por el programa */
 int n_externs;			/* Número de funciones importadas */
 int n_entrypoints;		/* Número de entrypoints declarados */
 
-#endif // __EXTERN_H
\ No newline at end of file
+#endif // __EXTERN_H
diff --git a/ediv/src/shared/shared.h b/ediv/src/shared/shared.h
index e375daa..8ee7366 100644
--- a/ediv/src/shared/shared.h
+++ b/ediv/src/shared/shared.h
@@ -42,4 +42,4 @@
 
 #define long_header 9 /* Longitud de la cabecera al inicio de los programas */
 
-#endif /* __EDIV_SHARED_H_ */
\ No newline at end of file
+#endif /* __EDIV_SHARED_H_ */
diff --git a/ediv/src/shared/utils.h b/ediv/src/shared/utils.h
index a9e86aa..3a4cd79 100644
--- a/ediv/src/shared/utils.h
+++ b/ediv/src/shared/utils.h
@@ -10,4 +10,4 @@ int strncasecmp2(const char *s1, const char *s2, int n);
 char *strlwr(char *str);
 #endif
 
-#endif /* __UTILS_H */ 
\ No newline at end of file
+#endif /* __UTILS_H */ 
diff --git a/ediv/src/shared/varindex.h b/ediv/src/shared/varindex.h
index 636598f..8567409 100644
--- a/ediv/src/shared/varindex.h
+++ b/ediv/src/shared/varindex.h
@@ -55,4 +55,4 @@ varindex_t* varindex;
 #define localptr(nombre) GetVarOffset(v_local,nombre)
 
 
-#endif // __VARINDEX_H
\ No newline at end of file
+#endif // __VARINDEX_H
diff --git a/ediv/src/stub/dll.h b/ediv/src/stub/dll.h
index 954c9f4..58f25cc 100644
--- a/ediv/src/stub/dll.h
+++ b/ediv/src/stub/dll.h
@@ -23,4 +23,4 @@
 
 int carga_dll(char* nombre);
 
-#endif /* __DLL_H */
\ No newline at end of file
+#endif /* __DLL_H */
diff --git a/ediv/src/stub/dll_load.h b/ediv/src/stub/dll_load.h
index b2e7b52..9831d91 100644
--- a/ediv/src/stub/dll_load.h
+++ b/ediv/src/stub/dll_load.h
@@ -58,4 +58,4 @@ void CheckWindowsVersion(void);
 
 
 
-//#endif
\ No newline at end of file
+//#endif
diff --git a/ediv/src/stub/ediv_export.c b/ediv/src/stub/ediv_export.c
index 122fa98..f97d299 100644
--- a/ediv/src/stub/ediv_export.c
+++ b/ediv/src/stub/ediv_export.c
@@ -68,13 +68,13 @@ int offset;
 		return 2;		// genera un error "el nombre no es nuevo"
 	} else {
         *ptr=_ivnom; ptr_o=(void*)(_ivnom+4); *ptr_o=o=iobj++; // id nuevo
-        (*o).name=(byte*)_ivnom+8;
-        (*o).member=member;
+        o->name=(byte*)_ivnom+8;
+        o->member=member;
         if (num_obj++==max_obj) return 3;	// error "demasiados objetos"
 	}
 	
-	(*o).dll=numdlls;
-//	(*o).usado_dll=0;
+	o->dll=numdlls;
+//	o->usado_dll=0;
 	
 	return 0;
 }*/
@@ -129,14 +129,14 @@ int EDIV_Export(char* cadena, int nparam, void* hfuncion)
 
 	ob=o;
 
-	if ((*ob).tipo!=tnone) {
+	if (ob->tipo!=tnone) {
 		dll_error(5,cadena);
 		return 0;
 	}
 
-    (*ob).tipo=tfext;
-    (*ob).fext.codigo=n_externs;
-    (*ob).fext.num_par=nparam; // es necesario?*/
+    ob->tipo=tfext;
+    ob->fext.codigo=n_externs;
+    ob->fext.num_par=nparam; // es necesario?*/
 
 	extfuncs[n_externs]=hfuncion;
 	extparms[n_externs]=nparam;
@@ -203,14 +203,14 @@ int EDIV_Export_Const(char* cadena, int valor)
 
 	ob=o;
 
-	if ((*ob).tipo!=tnone) {
+	if (ob->tipo!=tnone) {
 		dll_error(5,cadena);
 		return 0;
 	}
 
-	(*ob).tipo=tcons;
-	(*ob).cons.valor=valor;
-	(*ob).cons.literal=0;
+	ob->tipo=tcons;
+	ob->cons.valor=valor;
+	ob->cons.literal=0;
 */
 	return 1;
 }
@@ -239,13 +239,13 @@ int EDIV_Export_Global(char* cadena, int valor)
 
 	ob=o;
 
-	if ((*ob).tipo!=tnone) {
+	if (ob->tipo!=tnone) {
 		dll_error(5,cadena);
 		return 0;
 	}
 
-	(*ob).tipo=tvglo;
-	(*ob).vglo.offset=imem;
+	ob->tipo=tvglo;
+	ob->vglo.offset=imem;
 	mem[imem]=valor;
 */
 	return dimem++;
@@ -275,17 +275,17 @@ int EDIV_Export_Global_Tab(char* cadena, int numregs)
 
 	ob=o;
 
-	if ((*ob).tipo!=tnone) {
+	if (ob->tipo!=tnone) {
 		dll_error(5,cadena);
 		return 0;
 	}
 
-	(*ob).tipo=ttglo;
-	(*ob).tglo.offset=imem;
-	(*ob).tglo.len1=len=numregs;
-	(*ob).tglo.len2=-1;
-	(*ob).tglo.len3=-1;
-	(*ob).tglo.totalen=len+1;
+	ob->tipo=ttglo;
+	ob->tglo.offset=imem;
+	ob->tglo.len1=len=numregs;
+	ob->tglo.len2=-1;
+	ob->tglo.len3=-1;
+	ob->tglo.totalen=len+1;
 
 	// Inicializamos la tabla a 0
 	do {
@@ -324,19 +324,19 @@ int EDIV_Export_Global_Struct(char* cadena, int numregs)
 
 	ob=o;
 
-	if ((*ob).tipo!=tnone) {
+	if (ob->tipo!=tnone) {
 		dll_error(5,cadena);
 		return 0;
 	}
 
 	decl_struct=1;
 
-	(*ob).tipo=tsglo;
-	(*ob).sglo.offset=imem;
-	(*ob).sglo.items1=numregs;
-	(*ob).sglo.items2=(*ob).sglo.items3=-1;
-	(*ob).sglo.totalitems=numregs+1;
-	(*ob).sglo.len_item=0;
+	ob->tipo=tsglo;
+	ob->sglo.offset=imem;
+	ob->sglo.items1=numregs;
+	ob->sglo.items2=ob->sglo.items3=-1;
+	ob->sglo.totalitems=numregs+1;
+	ob->sglo.len_item=0;
 	member=ob;
 	len=0;
 */
@@ -374,18 +374,18 @@ int EDIV_Export_Member_Int(char* cadena, int valor)
 		return 0;
 	}
 
-	if((*ob).tipo==tsglo) {			// int miembro de struct global
+	if(ob->tipo==tsglo) {			// int miembro de struct global
 		(*ob2).tipo=tvglo;
 		(*ob2).vglo.offset=len++;
 		mem[imem]=valor;
-		(*ob).sglo.len_item++;
+		ob->sglo.len_item++;
 		return imem++;
 	}
 	else {							// int miembro de struct local
         (*ob2).tipo=tvloc;
         (*ob2).vloc.offset=len++;
         loc[iloc]=valor;
-        (*ob).sloc.len_item++;
+        ob->sloc.len_item++;
         return iloc++;
 	}
 	*/
@@ -422,7 +422,7 @@ int EDIV_Export_Member_Str(char* cadena, int tamano)
 		return 0;
 	}
 
-	if((*ob).tipo==tsglo) {			// string miembro de struct global
+	if(ob->tipo==tsglo) {			// string miembro de struct global
 
 		(*ob2).tipo=tcglo;
 		(*ob2).cglo.offset=len+1;
@@ -440,7 +440,7 @@ int EDIV_Export_Member_Str(char* cadena, int tamano)
 		len+=1+((*ob2).cglo.totalen+5)/4;
 		mem[imem+1]=0;
 		imem+=1+((*ob2).cglo.totalen+5)/4;
-		(*ob).sglo.len_item+=1+((*ob2).cglo.totalen+5)/4;
+		ob->sglo.len_item+=1+((*ob2).cglo.totalen+5)/4;
 		
 		return (*ob2).cglo.offset;
 	}
@@ -462,7 +462,7 @@ int EDIV_Export_Member_Str(char* cadena, int tamano)
 		len+=1+((*ob2).cloc.totalen+5)/4;
 		loc[iloc+1]=0;
 		iloc+=1+((*ob2).cloc.totalen+5)/4;
-		(*ob).sloc.len_item+=1+((*ob2).cloc.totalen+5)/4;
+		ob->sloc.len_item+=1+((*ob2).cloc.totalen+5)/4;
 		
 		return (*ob2).cloc.offset;
 	}*/
@@ -503,7 +503,7 @@ int EDIV_Export_Member_Tab(char* cadena, int numregs)
 		return 0;
 	}
 
-	if((*ob).tipo==tsglo) {			// array miembro de struct global
+	if(ob->tipo==tsglo) {			// array miembro de struct global
 		(*ob2).tipo=ttglo;
 		(*ob2).tglo.offset=len;
 		(*ob2).tglo.len1=numregs;
@@ -513,7 +513,7 @@ int EDIV_Export_Member_Tab(char* cadena, int numregs)
 		len+=numregs+1;
 		memset(&mem[imem],0,(numregs+1)*4);
 		imem+=numregs+1;
-		(*ob).sglo.len_item+=numregs+1;
+		ob->sglo.len_item+=numregs+1;
 		
 		return (*ob2).tglo.offset;
 	}
@@ -527,7 +527,7 @@ int EDIV_Export_Member_Tab(char* cadena, int numregs)
 		len+=numregs+1;
 		memset(&loc[iloc],0,(numregs+1)*4);
 		iloc+=numregs+1;
-		(*ob).sloc.len_item+=numregs+1;
+		ob->sloc.len_item+=numregs+1;
 		
 		return (*ob2).tloc.offset;
 	}*/
@@ -551,32 +551,32 @@ int EDIV_Export_EndStruct()
 
 	member=NULL;
 
-	if((*ob).tipo==tsglo) {			// cierra estructura global
-		if ((*ob).sglo.len_item==0) {
+	if(ob->tipo==tsglo) {			// cierra estructura global
+		if (ob->sglo.len_item==0) {
 			dll_error(10);
 			return 0;
 		}
-		if ((*ob).sglo.totalitems>1) {
-			len=((*ob).sglo.totalitems-1)*(*ob).sglo.len_item-1;
+		if (ob->sglo.totalitems>1) {
+			len=(ob->sglo.totalitems-1)*ob->sglo.len_item-1;
 			do {
-				mem[imem]=mem[imem-(*ob).sglo.len_item];
+				mem[imem]=mem[imem-ob->sglo.len_item];
 				imem++;
 			} while (len--);
 		}
 	}
 	else {							// cierra estructura local
-		if ((*ob).sloc.len_item==0) {
+		if (ob->sloc.len_item==0) {
 			dll_error(10);
 			return 0;
 		}
-		if ((*ob).sloc.totalitems>1) {
-			len=((*ob).sloc.totalitems-1)*(*ob).sloc.len_item-1;
+		if (ob->sloc.totalitems>1) {
+			len=(ob->sloc.totalitems-1)*ob->sloc.len_item-1;
 			do {
-				loc[iloc]=loc[iloc-(*ob).sloc.len_item];
+				loc[iloc]=loc[iloc-ob->sloc.len_item];
 				iloc++;
 			} while (len--);
 		}
-//        iloc+=(*ob).sloc.totalitems*(*ob).sloc.len_item;
+//        iloc+=ob->sloc.totalitems*ob->sloc.len_item;
 	}
 */
 	if(len==0) dll_error(10);
@@ -613,13 +613,13 @@ int EDIV_Export_Local(char* cadena, int valor)
 
 	ob=o;
 
-	if ((*ob).tipo!=tnone) {
+	if (ob->tipo!=tnone) {
 		dll_error(5,cadena);
 		return 0;
 	}
 
-    (*ob).tipo=tvloc;
-    (*ob).vloc.offset=iloc;
+    ob->tipo=tvloc;
+    ob->vloc.offset=iloc;
     loc[iloc]=valor;
 */
     return diloc++;
@@ -649,24 +649,24 @@ int EDIV_Export_Local_Tab(char* cadena, int numregs)
 
 	ob=o;
 
-	if ((*ob).tipo!=tnone) {
+	if (ob->tipo!=tnone) {
 		dll_error(5,cadena);
 		return 0;
 	}
 
-	(*ob).tipo=ttloc;
-	(*ob).tloc.offset=iloc;
-	(*ob).tloc.len1=len=numregs;
-	(*ob).tloc.len2=-1;
-	(*ob).tloc.len3=-1;
-	(*ob).tloc.totalen=len+1;
+	ob->tipo=ttloc;
+	ob->tloc.offset=iloc;
+	ob->tloc.len1=len=numregs;
+	ob->tloc.len2=-1;
+	ob->tloc.len3=-1;
+	ob->tloc.totalen=len+1;
 
 	// Inicializamos la tabla a 0
 	do {
 		loc[iloc++]=0;
 	} while (len--);
 
-	return (*ob).tloc.offset;*/
+	return ob->tloc.offset;*/
 
 	offset=diloc;
 	diloc+=numregs;
@@ -700,19 +700,19 @@ int EDIV_Export_Local_Struct(char* cadena, int numregs)
 
 	ob=o;
 
-	if ((*ob).tipo!=tnone) {
+	if (ob->tipo!=tnone) {
 		dll_error(5,cadena);
 		return 0;
 	}
 
 	decl_struct=1;
 
-	(*ob).tipo=tsloc;
-	(*ob).sloc.offset=iloc;
-	(*ob).sloc.items1=numregs;
-	(*ob).sloc.items2=(*ob).sloc.items3=-1;
-	(*ob).sloc.totalitems=numregs+1;
-	(*ob).sloc.len_item=0;
+	ob->tipo=tsloc;
+	ob->sloc.offset=iloc;
+	ob->sloc.items1=numregs;
+	ob->sloc.items2=ob->sloc.items3=-1;
+	ob->sloc.totalitems=numregs+1;
+	ob->sloc.len_item=0;
 	member=ob;
 	len=0;
 */
diff --git a/ediv/src/stub/main.h b/ediv/src/stub/main.h
index b6ff90b..b3733c2 100644
--- a/ediv/src/stub/main.h
+++ b/ediv/src/stub/main.h
@@ -106,4 +106,4 @@ void custom_error(tipoerror tipo, char* mensaje); /* Errores personalizados de l
 void stub_quit(int n);				// Salir del stub
 void* e_malloc(size_t size);	// identico a malloc pero con errormsg utomático
 
-#endif /* __MAIN_H */
\ No newline at end of file
+#endif /* __MAIN_H */