Sie sind auf Seite 1von 20

Captulo 5.

Anlisis semntico
Se compone de un conjunto de rutinas independientes, llamadas por los analizadores morfolgico y sintctico. El anlisis semntico utiliza como entrada el rbol sintctico detectado por el anlisis sintctico para comprobar restricciones de tipo y otras limitaciones semnticas y preparar la generacin de cdigo. En compiladores de un solo paso, las llamadas a las rutinas semnticas se realizan directamente desde el analizador sintctico y son dichas rutinas las que llaman al generador de cdigo. El instrumento ms utilizado para conseguirlo es la gramtica de atributos. En compiladores de dos o ms pasos, el anlisis semntico se realiza independientemente de la generacin de cdigo, pasndose informacin a travs de un archivo intermedio, que normalmente contiene informacin sobre el rbol sintctico en forma linealizada (para facilitar su manejo y hacer posible su almacenamiento en memoria auxiliar). En cualquier caso, las rutinas semnticas suelen hacer uso de una pila (la pila semntica) que contiene la informacin semntica asociada a los operandos (y a veces a los operadores) en forma de registros semnticos.

Propagacin de atributos
Sea la expresin
int a,b,c; a/(b+c^2)

El rbol sintctico es:


/ --------| | a + --------| | b ^ --------| | c 2

De la instruccin declarativa, la tabla de smbolos y el analizador morfolgico obtenemos los atributos de los operandos:
/ --------| | a + int --------| | b ^ int --------| | c 2 int int

Propagando los atributos obtenemos:


/ int --------| | a + int int --------| | b ^ int int --------| | c 2 int int

Si la expresin hubiera sido


a/(b+c^-2)

El rbol sintctico sera el mismo, sustituyendo 2 por -2. Sin embargo, la propagacin de atributos sera diferente:
/ real --------| | a + real int --------| | b ^ real int --------| | c -2 int int

En algn caso podra llegar a producirse error (p.e. si / representara slo la divisin entera).

Si la expresin hubiera sido


int a,b,c,d; a/(b+c^d)

El rbol sintctico sera el mismo, sustituyendo 2 por d. Sin embargo, la propagacin de atributos sera incompleta:
/ {int,real} --------| | a + {int,real} int --------| | b ^ {int,real} int --------| | c d int int

El analizador semntico podra reducir los tipos inseguros al tipo mximo (real) o utilizar un tipo interno nuevo (ej. arit={int,real}, una unin). Lo anterior es un ejemplo de propagacin bottom-up. La propagacin top-down tambin es posible: lo que se transmite son las restricciones y los tipos de las hojas sirven de comprobacin. Por ejemplo, si la divisin slo puede ser entera, transmitimos hacia abajo la restriccin de que sus operandos slo pueden ser enteros. Al llegar a d, esa restriccin se convierte en que d debe ser positiva. Si no lo es, error. La implantacin de todos los casos posibles de operacin con tipos mixtos podra ser excesivamente cara. En su lugar, se parte de operaciones relativamente simples (ej. int+int, real+real) y no se implementan las restantes (ej. int+real, real+int), aadiendo en su lugar operaciones mondicas de cambio de tipo (ej. int->real). Esta decisin puede introducir ambigedades. Por ejemplo, sea el programa
real a; int b,c; a:=b+c

El rbol sintctico es:


:= --------| | a +

real

--------| | b c int int

Existen dos conversiones posibles:


:= real --------| | a + real real --------| | b c int int := real --------| | a + int real --------| | b c int int

El problema es que no tenemos garanta de que los dos procedimientos sean equivalentes. El segundo puede dar overflow, el primero prdida de precisin. La definicin del lenguaje debe especificar estos casos. Las transformaciones posibles se pueden representar mediante un grafo cuyos nodos son los tipos de datos y cada arco indica una transformacin. Dado un operando de tipo A que se desea convertir al tipo B, se trata de encontrar una cadena de arcos que pase de A a B en el grafo anterior. Podra haber varios grafos, cada uno de los cuales se aplicar en diferentes condiciones, por ejemplo, uno para las asignaciones, otro para las expresiones, etc.

Gramtica de atributos
Es una extensin de la notacin de Backus que consiste en introducir en las reglas sintcticas ciertos smbolos adicionales no sintcticos (smbolos de accin) que, en definitiva, se reducen a llamadas implcitas o explcitas a rutinas semnticas. Por ejemplo: sea la gramtica simplificada que analiza las instrucciones de asignacin:
<AsSt> ::= id #PId := <Exp> #RAs <Exp> ::= <Exp> + <T> #RS | <T> <T> ::= id #PId | Ct #PCt

Se observar que hemos hecho uso de cuatro smbolos de accin:


#PId: PUSH a la pila semntica el registro asociado al identificador. #PCt: PUSH a la pila semntica el registro asociado a la constante.

#RS: Realizar suma: POP los dos registros superiores de la pila; comprobar que es posible sumarlos; realizar la suma (mediante una llamada al generador de cdigo) o generar representacin intermedia (si es una compilacin en dos o ms pasos); PUSH registro semntico del resultado en la pila semntica. #RAs: Realizar asignacin: POP los dos registros superiores de la pila; comprobar que es posible realizar la asignacin; realizarla (mediante una llamada al generador de cdigo) o generar representacin intermedia (si es una compilacin en dos o ms pasos).

En los analizadores sintcticos top-down basados en gramticas LL(1), la introduccin de los smbolos de accin en las rutinas correspondientes es trivial. En los analizadores bottom-up basados en gramticas SLR(1) es ms delicado, pues los estados del anlisis se mueven simultneamente sobre varias reglas. Slo en el momento de realizar una reduccin sabemos exactamente dnde estamos. Por ello, se suele introducir la restriccin de que los smbolos de accin deben estar situados nicamente al final de una regla. Cuando no se cumple esto (como en el ejemplo anterior) es trivial conseguirlo, introduciendo smbolos no terminales adicionales. Algunos generadores de analizadores sintcticos (como YACC) lo realizan automticamente. En nuestro ejemplo, quedara:
<AsSt> <ASPI> <Exp> <T> ::= ::= ::= ::= <ASPI> := <Exp> #RAs id #PId <Exp> + <T> #RS | <T> id #PId | Ct #PCt

Poner un ejemplo del anlisis sintctico-semntico bottom-up de la instruccin A := B + 1. Otro ejemplo: instrucciones condicionales con las reglas
<Instr> ::= If <Expr> #S2 then <Instr> #S1 | If <Expr> #S2 then <Instr> else #S3 <Instr> #S1

Ms adelante se ver cules son las tres acciones semnticas. Para que todas queden al final de una regla, basta cambiar estas reglas por:
<Instr> ::= If <Expr1> then <Instr> #S1 | If <Expr1> then <Instr> <Else> <Instr> #S1 <Expr1> ::= <Expr> #S2 <Else> ::= else #S3

Generacin de representaciones intermedias


Existen dos representaciones intermedias principales:

Notacin sufija Cudruplas

Los operadores didicos (o binarios) pueden especificarse mediante tres notaciones principales:

Prefija: el operador didico es analizado antes que sus operandos. Infija: el operador didico es analizado entre sus operandos. Sufija: el operador didico es analizado despus que sus operandos.

En los lenguajes de programacin clsicos, los operadores didicos se representan usualmente en notacin infija. La notacin prefija permite al operador influir sobre la manera en que se procesan sus operandos, pero a cambio suele exigir mucha ms memoria. La sufija no permite esa influencia, pero es ptima en proceso de memoria y permite eliminar el procesado de los parntesis. Los operadores mondicos slo pueden presentarse en notacin prefija o sufija. Adems, un rbol sintctico puede representarse en forma de tuplas de n elementos, de la forma (operador, operando-1, ..., operando-k, nombre). Las tuplas pueden tener longitud variable o fija (con operandos nulos). Las ms tpicas son las cudruplas, aunque stas pueden representarse tambin en forma de tripletes.

Notacin sufija
Llamada tambin postfija o polaca inversa, se usa para representar expresiones sin necesidad de parntesis. Ejemplos:
a*b a*(b+c/d) a*b+c*d ab* abcd/+* ab*cd*+

Los identificadores aparecen en el mismo orden. Los operadores en el de evaluacin (de izquierda a derecha). Problema: operadores mondicos (unarios). O bien se transforman en didicos (binarios) o se cambia el smbolo. Ejemplo: -a se convierte en 0-a o en @a

a*(-b+c/d)

ab@cd/+*

Existen dos problemas principales:


Construir la notacin sufija a partir de la infija. Analizar la notacin sufija en el segundo paso de la compilacin.

Rutina semntica para transformar de infijo a sufijo Si el analizador sintctico es bottom-up, hacemos la siguiente suposicin: "Cuando aparece un no terminal V en el asidero, la cadena polaca correspondiente a la subcadena que se redujo a V ya ha sido generada". Se utiliza una pila donde se genera la salida, inicialmente vaca. Las acciones semnticas asociadas a las reglas son:
E E E T T T F F F ::= ::= ::= ::= ::= ::= ::= ::= ::= E + E T T * T / F i (E) - F T T F F Push + Push Push * Push / Push i Push @

Anlisis de la notacin sufija La gramtica completa que permite analizar la notacin sufija es:
<Operando> ::= id | cte | <Operando> <Operando> <Operador didico> | <Operando> <Operador mondico> <Operador didico> ::= + | - | * | / | ... <Operador mondico> ::= @ | ...

Algoritmo de evaluacin de una expresin en notacin sufija que utiliza una pila:

Si el prximo smbolo es un identificador, se pasa a la pila. Corresponde a la aplicacin de la regla


<Operando> ::= id

Si el prximo smbolo es una constante, se pasa a la pila. Corresponde a la aplicacin de la regla


<Operando> ::= cte

Si el prximo smbolo es un operador didico, se aplica el operador a los dos operandos situados en lo alto de la pila y se sustituyen stos por el resultado de la operacin. Corresponde a la aplicacin de la regla
<Operando> ::= <Operando> <Operando> <Operador didico>

Si el prximo smbolo es un operador mondico, se aplica el operador al operando situado en lo alto de la pila y se sustituye ste por el resultado de la operacin. Corresponde a la aplicacin de la regla
<Operando> ::= <Operando> <Operador mondico>

Ejemplo: calcular ab@cd/+*. Extensin de la notacin sufija a otros operadores

La asignacin, teniendo en cuenta que podemos no querer valor resultante. Adems, no interesa tener en la pila el valor del identificador izquierdo, sino su direccin.
a:=b*c+d GOTO L abc*d+:= L TR

La transferencia (GOTO). La instruccin condicional


if p then inst1 else inst2

se convierte en
p L1 TRZ inst1 L2 TR inst2 L1: L2:

Subndices:
a[exp1; exp2; ...; expn]

se convierte en
a exp1 exp2 ... expn SUBIN-n

Cudruplas
Una operacin didica se puede representar mediante la cudrupla
(<Operador>, <Operando1>, <Operando2>, <Resultado>)

Ejemplo:
(*,A,B,T)

Una expresin se puede representar mediante un conjunto de cudruplas. Ejemplo: la expresin a*b+c*d equivale a:
(*,a,b,t1) (*,c,d,t2) (+,t1,t2,t3)

Ejemplo: la expresin c:=a[i;b[j]] equivale a:


(*,i,d1,t1) (+,t1,b[j],t2) (:=,a[t2],,c)

Tripletes No se pone el resultado, se sustituye por referencias a tripletes. Por ejemplo: la expresin a*b+c*d equivale a:
(1) (*,a,b) (2) (*,c,d) (3) (+,(1),(2))

mientras que a*b+1 equivale a:


(1) (*,a,b) (2) (*,(1),1)

Tripletes indirectos: se numeran arbitrariamente los tripletes y se da el orden de ejecucin. Ejemplo, sean las instrucciones:
a := b*c b := b*c

Equivalen a los tripletes


(1) (*,b,c) (2) (:=,(1),a) (3) (:=,(1),b)

y el orden de ejecucin es (1),(2),(1),(3). Esta forma es til para preparar la optimizacin de cdigo. Si hay que alterar el orden de las operaciones o eliminar alguna, es ms fcil hacerlo ah. Generacin automtica de cudruplas En un anlisis bottom-up, asociamos a cada smbolo no terminal una informacin semntica, y a cada regla de produccin una accin semntica. Ejemplo, sea la gramtica
E E E T ::= ::= ::= ::= E + T E - T T T * F

T T F F F

::= ::= ::= ::= ::=

T / F F i (E) -F

La regla F::=i asocia a F como informacin semntica el identificador concreto. La regla F::=(E) asocia a F como informacin semntica la informacin semntica asociada a E. La regla U::=V asocia a U como informacin semntica la informacin semntica asociada a V. La regla U::=VoW analiza la compatibilidad de los operandos, crea la cudrupla (o,Sem(V),Sem(W),Ti) y asocia a U la informacin semntica Ti. La regla U::=oV crea la cudrupla (o,Sem(V),,Ti) y asocia a U la informacin semntica Ti. La informacin semntica se suele almacenar en otra pila paralela. Ejemplo: anlisis de a*(b+c)
Pila ----------| |a |F(a) |T(a) |T(a)* |T(a)*( |T(a)*(b |T(a)*(F(b) |T(a)*(T(b) |T(a)*(E(b) |T(a)*(E(b)+ |T(a)*(E(b)+c |T(a)*(E(b)+F(c) |T(a)*(E(b)+T(c) |T(a)*(E(b)+T(c) |T(a)*(E(T1) |T(a)*(E(T1)) |T(a)*F(T1) |T(T2) |E(T2) Entrada ------------a*(b+c)| *(b+c)| *(b+c)| *(b+c)| (b+c)| b+c)| +c)| +c)| +c)| +c)| c)| )| )| )| )| )| | | | | Regla Cudrupla ------------ --------F::=i T::=F

F::=i T::=F E::=T F::=i T::=F E::=E+T E::=E+T F::=(E) T::=T*F E::=T

(+,b,c,T1) (*,a,T1,T2)

Ejemplo de generacin de cudruplas en anlisis top-down


unsigned int E (char *cadena, unsigned int i)

{ if (i<0) return i; switch (cadena[i]) { case 'i': push (id); i++; i = V (cadena, i); break; case '(': i++; i = E (cadena, i); i = C (cadena, i); i = V (cadena, i); break; default: return -1; } return i; } unsigned int V (char *cadena, unsigned int i) { unsigned int j; if (i<0) return i; switch (cadena[i]) { case '*': case '/': j = i; i++; i = T (cadena, i); cuad (cadena[j], pop(), pop(), gen(Ti)); push (Ti); i = X (cadena, i); break; case '+': case '-': j = i; i++; i = E (cadena, i); cuad (cadena[j], pop(), pop(), gen(Ti)); push (Ti); break; } return i; } unsigned int X (char *cadena, unsigned int i) { unsigned int j; if (i<0) return i; switch (cadena[i]) { case '+': case '-': j = i; i++; i = E (cadena, i); cuad (cadena[j], pop(), pop(), gen(Ti)); push (Ti);

break; } return i; } unsigned int T (char *cadena, unsigned int i) { if (i<0) return i; switch (cadena[i]) { case 'i': push (id); i++; i = U (cadena, i); break; case '(': i++; i = E (cadena, i); i = C (cadena, i); i = U (cadena, i); break; default: return -2; } return i; } unsigned int U (char *cadena, unsigned int i) { if (i<0) return i; unsigned int j; switch (cadena[i]) { case '*': case '/': j = i; i++; i = T (cadena, i); cuad (cadena[j], pop(), pop(), gen(Ti)); push (Ti); break; } return i; } unsigned int F (char *cadena, unsigned int i) { if (i<0) return i; switch (cadena[i]) { case 'i': push (id); i++; break; case '(': i++; i = E (cadena, i); i = C (cadena, i); break; default: return -3; }

return i; } unsigned int C (char *cadena, unsigned int i) { if (i<0) return i; switch (cadena[i]) { case ')': i++; break; default: return -4; } return i; }

Semntica de instrucciones condicionales Sean las reglas


<Instr> ::= If <Expr> S2 then <Instr> S1 | If <Expr> S2 then <Instr> else S3 <Instr> S1

Una secuencia de cudruplas equivalente a "If E1 then I1 else I2"


(p-1) (p) (q) (q+1) (r) (?,?,?,t1) (TRZ,(q+1),t1,) ... (TR,(r),,) ... Anlisis de E1 S2: Crear cudrupla Anlisis de I1 S3: Crear cudrupla Poner (cl.sig.) Push (q) Anlisis de I2 S1: Poner (cl.sig.) (p) | Push p (q) en top | Pop en top | Pop

Una secuencia de cudruplas equivalente a "If E1 then I1"


(p-1) (p) (r) (?,?,?,t1) (TRZ,(r),t1,) ... Anlisis de E1 S2: Crear cudrupla (p) | Push p Anlisis de I1 S1: Poner (cl.sig.) en top | Pop

Al generar la cudrupla (p) no conocemos el valor de (q). Guardamos en una pila el nmero de la cudrupla asociada y lo rellenamos ms tarde, como indican los ejemplos. Semntica de etiquetas y GOTO Suponemos que las etiquetas aparecen en la tabla de smbolos con tres valores asociados: (tipo=etiqueta, bit=declarada/no declarada, nmero de cudrupla). Sea la regla

<Instr> ::= id : <Instr>

Semntica asociada:
{ Buscar id en la tabla de smbolos; if (no est) Insertar id,valor=(etiqueta, declarada, cudrupla siguiente); else { if (tipo==etiqueta && bit==no declarada) { i=nmero de cudrupla; while (i) { j=cudrupla[i][2]; cudrupla[i][2]=cudrupla siguiente; i=j; } Cambiar valor a (etiqueta, declarada, cudrupla siguiente); } else error(); } }

Sea la regla
<Instr> ::= GOTO id

Semntica asociada:
{ Buscar id en la tabla de smbolos; if (no est) { Insertar id,valor=(etiqueta, no declarada, cudr.siguiente); Generar cudrupla (TR,,,); } else { if (tipo==etiqueta) { if (bit==declarada) Generar cudrupla (TR,nmero de cudrupla,,); else if (bit==no declarada) { i=nmero de cudrupla; Cambiar valor a (etiqueta, no declarada, cudr.siguiente); Generar cudrupla (TR,i,,); } } else error(); } }

Si se permiten etiquetas locales a bloques, podemos encontrar el siguiente caso:


L: ... { ... GOTO L;

...

Tenemos ambigedad: GOTO L puede ir a la etiqueta externa (ya definida o no) o a una etiqueta local al bloque posterior a la instruccin. Tenemos tres posibilidades:

Un compilador en dos pasos. Forzar declaraciones de etiquetas. Tratar L en el bloque como si fuera local. Si al final del bloque descubrimos que no ha sido declarada, tratarla como si fuera global. La lista de referencias debera fundirse con la de L global (si L global no ha sido definida an) o rellenarse con el valor de L (si ya ha sido definida). Si L global no existe, debe crearse, y pasarle la lista de referencias de L local.

Semntica de bloques Sean las reglas


<Instr> ::= do <id> := <Expr> S1 , <Expr> S2 <CD1> <LInstr> end S5 <CD1> ::= , <Expr> S3 | ^ S4

Semntica asociada al anlisis de "do x:=n1,n2,n3; I1; I2; end":


S1:
Generar cudruplas asociadas a instruccin de asignacin x:=n1. Guardar i=nmero de cudrupla siguiente.

S2:
Guardar j=nmero de cudrupla siguiente. Generar cudrupla (TRG,,x,(n2)). Generar cudrupla (TR,,,).

S3:
Generar cudrupla (+,x,(n3),x). Generar cudrupla (TR,(i),,). Hacer cudrupla[j+1][2]=cudrupla siguiente.

S5:
Generar cudrupla (TR,(j+2),,). Hacer cudrupla[j][2]=cudrupla siguiente.

Adems, S4:
Generar cudrupla (:=,x,1,x). Generar cudrupla (TR,(i),,). Hacer cudrupla[j+1][2]=cudrupla siguiente.

Evaluacin ptima de las expresiones booleanas


Las operaciones booleanas usualmente se definen as:
O | T F --|----T | T T F | T F Y | T F --|----T | T F F | F F NO| T F --|----| F T

y la sintaxis adecuada para que la precedencia sea: NO, Y, O. Sin embargo, es posible simplificarlas considerablemente. Basta fijarse en la expresin
a Y (b O NO c)

Si a es falso, no hace falta calcular el parntesis, sabemos que el resultado es falso. Por tanto, redefiniremos la sintaxis y la semntica as:
<ZB> <EB> <TB> <FB> ::= ::= ::= ::= <EB> <TB> O <EB> | <TB> <FB> Y <TB> | <FB> i | ( <EB> ) | NO <FB>

a O b <=> if (a) TRUE else b; a Y b <=> if (a) b else FALSE; NO a <=> if (a) FALSE else TRUE;

Anlisis top-down El programa queda:


void ZB (char *cadena) { int FL=0, TL=0, i; cuad (":=", "T", NULL, x); i = EB (cadena, 0, &FL, &TL); FILL (FL); cuad (":=", "F", 0, x); FILL (TL); } unsigned int EB (char *cadena, unsigned int i, int *FL, int *TL) { int tl=0; i = TB (cadena, i, FL, &tl); MERGE (TL, tl); if (i<strlen(cadena)) switch (cadena[i]) { case 'O': i++; FILL (*FL); *FL = 0; i = EB (cadena, i, FL, TL); break; default: break;

} return i; } unsigned int TB (char *cadena, unsigned int i, int *FL, int *TL) { int fl=0; i = FB (cadena, i, &fl, TL); MERGE (FL, fl); if (i<strlen(cadena)) switch (cadena[i]) { case 'Y': i++; FILL (*TL); *TL = 0; i = TB (cadena, i, FL, TL); break; default: break; } return i; } unsigned int FB (char *cadena, unsigned int i, int *FL, int *TL) { if (i<strlen(cadena)) switch (cadena[i]) { case 'i': i++; *TL = cudrupla siguiente; *FL = - cudrupla siguiente; cuad (TRB, id, 0, 0); break; case '(': i++; i = EB (cadena, i, FL, TL); i = C (cadena, i); break; case 'NO': i++; i = FB (cadena, i, FL, TL); *FL <-> *TL break; default: error (cadena, i); } else error (cadena, i); return i; } unsigned int C (char *cadena, unsigned int i) { if (i<strlen(cadena)) switch (cadena[i]) { case ')': i++; break; default: error (cadena, i); } else error (cadena, i); return i;

} void FILL (int lista) { int i,j,n; n = lista; while (n) { if (n>0) i=2; else i=3; j = abs (n); n = cuad[j][i]; cuad[j][i] = cudrupla siguiente; } } void MERGE (int *uno, int dos) { int i,k; if (*uno==0) *uno = dos; else { k = *uno; for (;;) { if (k>0) i=2; else i=3; k = abs (k); if (cuad[k][i]==0) break; k = quad[k][i]; } cuad[k][i] = dos; } }

Analicemos "a O b O NO c"


ZB ("a O b O NO c") cuad (":=", "T", NULL, "X"); i = EB ("a O b O NO c", 0, &FL, &TL); i = TB ("a O b O NO c", 0, FL, &tl); i = FB ("a O b O NO c", 0, &fl, TL); case id: i=1; *TL = 1; fl = -1; cuad (TRB, a, 0, 0); MERGE (FL, fl); FL = -1; MERGE (TL, tl); TL = 1; case 'O': i=2; FILL (FL); n = -1; while (n) { i = 3; j = 1; (abs(FL)) n = 0; (cuad[1][3]) cuad[1][3] = 2; }

FL = 0; i = EB ("a O b O NO c", 2, FL, TL); i = TB ("a O b O NO c", 2, FL, &tl); i = FB ("a O b O NO c", 2, &fl, TL); case 'i': i=3; *TL = 2; *fl = -2; cuad (TRB, b, 0, 0); MERGE (FL, fl); FL = -2; MERGE (TL, tl); k = 1; for (;;) { i = 2; k = 1; } cuad[1][2] = 2; case 'O': i=4; FILL (FL); n = -2; while (n) { i = 3; j = 2; (abs (n)) n = 0; (cuad[2][3]) cuad[2][3] = 3; } FL = 0; i = EB ("a O b O NO c", 4, FL, TL); i = TB ("a O b O NO c", 4, FL, &tl); i = FB ("a O b O NO c", 4, &fl, TL); case 'NO': i=5; i = FB ("a O b O NO c", 5, FL, TL); case 'i': i=6; *TL = 3; *FL = -3; cuad (TRB, c, 0, 0); FL <-> TL MERGE (FL, fl); FL = 3; MERGE (TL, tl); k = 1; for (;;) { i = 2; k = 1; (abs (k)) k = 2; (cuad[1][2]) } cuad[2][2] = -3; FILL (FL); cuad[3][2] = 4; cuad (":=", "F", 0, "X"); FILL (TL); cuad[1][2] = 5; cuad[2][2] = 5;

cuad[3][3] = 5;

Cudruplas obtenidas:
0: 1: 2: 3: 4: 5: (":=", "T",, x); ("TRB", a, 5, 2); ("TRB", b, 5, 3); ("TRB", c, 4, 5); (":=", "F",, x);