Semantica de ASPLE

ASPLE – explicaciones de la semántica
1
1.1
Identificadores:
Unicidad
Todos los identificadores deberı́an ser únicos en la parte de declaraciones. No
pueden haber nombres de procedimientos e identificadores iguales.
1.2
Existencia
Todos los identificadores de variables que se utilizan en <stm train>, tienen
que estar declarados en <decl train>. Se considera como error semántico
la falta de declaración de una variable. No existe tal restricción para los
nombres de procedimientos.
Pregunta: ¿Por qué a los nombres de procedimientos no se puede aplicar
la misma lógica?
2
2.1
Comprobación Tipos:
Excepción
La semántica de asignación de tipo id := id se considera en apartado especial.
2.2
Expresiones
Las variables hereden el tipo básico de su declaración. El tipo básico de
una constante <int constant> es int. El tipo base de una constante <bool
constant> es bool. Todos los números se consideran números con signo de 4
bytes. El booleano puede tener dos valores true y f alse. La correspondencia
entre true, f alse y sus valores numéricos los asigna cada alumno.
Las operaciones binarias son semánticamente validas solo si son entre
operandos del mismo tipo y tienen los siguientes tipos:
1
Oper- Operan Resul- Equivalenca C
ador dos
tado
----------------------------------------------------------------+
int
int
+
int
int
*
int
int
*
+
bool
bool
exp1,exp2,(exp1 || exp2)
bool
bool
exp1,exp2,(exp1 && !exp2) || (!exp1 && exp2)
*
bool
bool
exp1,exp2,(exp1 && exp2)
<
int
bool
<
>=
int
bool
>=
=
int
bool
==
El menos unario se permite solo para tipo int y significa lo mismo que en
C. Todas las demás combinaciones se consideran como error.
2.3
Estructuras de control
Las expresiones exp en <cond stm> (if) y <loop stm> (while,repeat) son de
tipo bool. La expresión exp en <case stm> es int.
3
Control de flujo
Enumeramos todas las sentencias de control con un numero único ## para
cada sentencia. La semántica puede darse en términos de equivalencia con
otro lenguaje, preferiblemente a mas bajo nivel.
La semántica es:
2
ASPLE
C
---------------------------------------------------------------------if exp then stms_1 else stms_2 fi
if (exp==false) goto A_##;
{ C(stms_1); }
goto B_##;
A_##:
{ C(stms_2); }
B_##:
if exp then stms_1 fi
if (exp==false) goto A_##;
{ C(stms_1); }
A_##:
while exp do stms end
W_##:
if (exp==false) goto E_##;
{ C(stms); }
goto W_##;
E_##:
repeat stms until exp
R_##:
{ C(stms); }
if (exp==false) goto R_##;
case (<exp>)
<const1>: stms1
TMP_##=<exp>;
if (TMP_##!=const1)
goto L<const1>_##;
{ stms1; }
goto CE_##;
L<const1>_##:
if (TMP_##!=const2)
goto L<const2>_##;
{ stms2; }
goto CE_##;
L<const2>_##:
...
CE_##:
<const2>: stms2
...
esac
3
4
Entrada/Salida:
La librerı́a de entrada/salida la escribirá cada alumno en C. Ejemplo:
void output_int(int a) { printf("%d\n",a); }
4.1
input A
Si A esta declarada como refn A; , la sentencia input A es equivalente a la
sentencia de C: {int tmp; scanf("%d",&tmp);} seguida de la sentencia de
ASPLE A:=tmp+0.
Si A esta declarada como refn A; , la sentencia input A es equivalente a
la sentencia de C: {int tmp; scanf("%d",&tmp);} seguida de la sentencia
de ASPLE A:= (tmp=0)-true; .
4.2
output exp
Si exp es un int, la semántica es igual a la correspondiente sentencia de C:
printf("%d\n",exp);.
Si exp es un bool, la acción es imprimir “1” para true y “0” para f alse,
seguidos de salto de linea.
5
5.1
Punteros
Declaración:
El puntero de ASPLE tiene la siguiente semántica:
Declaración:
(ref )n int A; en ASPLE es análogo a int ∗n A;.
(ref )n bool A; en ASPLE es análogo a int ∗n A; en C.
El compilador debe de guardar el identificador con el tipo correspondiente
en la tabla de sı́mbolos.
5.2
Expresiones:
5.2.1
Caso general
Denominamos Rvalue todo lo que puede aparecer en la parte derecha de una
asignación. Distinguimos entre los siguientes casos:
4
1. Rvalue esta compuesto solo de un identificador.
2. Cualquier otra expresión. En este caso A en ASPLE es lo mismo como
∗n A en C.
3. Expresión fuera de asignación: La misma interpretación que en el
punto 2.
5.2.2
id := id
Si tenemos asignación del tipo idL := idR , se trata de un caso especial. Según
las referencias Ref (A), Ref (B) de A y B tendrá la siguiente correspondencia
en C:
-------------------------------------Caso
ASPLE
C
-------------------------------------Ref(A)==Ref(B)
A:=B
A=B
Ref(A)<Ref(B)
A:=B
A=*..*B
Ref(A)=Ref(B)+1
A:=B
A = &B
Ref(A)>Ref(B)+1
A:=B
*..*A=B
-------------------------------------El numero de * es igual a la deferencia entre las referencias de A y B.
Ejemplos:
ASPLE
C
--------------------------------int A,X;
int
A, X;
ref int B,Y;
int *B, *Y;
ref ref int C,Z;
int **C,**Z;
A:=X;
A:=B;
A:=C;
B:=A;
B:=Y;
B:=C;
C:=A;
C:=B;
C:=Z;
Z:= B+C;
A
A
A
B
B
B
**C
C
C
**Z
=
X;
= *B;
= **C;
= &A;
=
Y;
= *C;
=
A;
= &B;
=
Z;
= *B + **C;
5
El valor por defecto de un identificador es 0 (NULL). El programa casca
por “segmentation fault” en los mismos casos que en C.
6
Translación a ensamblador
La mayorı́a de las construcciones deben ser conocidas de ETC 2. En NASM
se utilizan las instrucciones de 386, que tiene ventajas, por ejemplo: multiplicación con registros explı́citos; asignación de bandera a registros de uso
general sin utilización de saltos; saltos mas largos etc. Hay que consultar la
bibliografı́a correspondiente o analizar código, generando plantillas a partir
de C con la opción de gcc que genera código ensamblador (método valido
para toda maquina). Se construye un emulador de una maquina de pila.
NOTAR:
1. Los comandos de asignación de banderas tienen que funcionar con los
flags para números con signo – E G y L, y NO para las banderas de números
sin signo – E A B.
2. Lo mismo para la multiplicación. Hay que utilizar la multiplicación
con signo IMUL y NO la de sin signo MUL.
3. Programa mı́nimo de NASM:
http://www.ii.uam.es/~
kostadin/compil/pasty/misca/minprog.s
4. Cambio del ámbito de nombres: normalmente con prefijos que no se
pueden dar en el lenguaje () .
5. Conjunto mı́nimo de comandos de NASM para la realización del compilador:
; declaracion de memoria
id DD
0
; asignacion de
MOV
LEA
MOV
MOV
MOV
MOV
MOV
datos
EAX,[id]
EDX,[id]
EAX,[EDX]
EDX,[EDX]
[EDX],EAX
id,EAX
id,EDX
;
;
;
;
;
EAX
EDX
EAX
EDX
*EDX
6
=
id
= & id
= * EDX
= * EDX
=
EAX
; pila
PUSH
POP
POP
PUSH
EAX
EAX
EDX
DWORD constant
; operaciones aritmeticas
ADD EAX,EDX
SUB EAX,EDX
IMUL EDX
OR
EAX,EDX
AND EAX,EDX
XOR EAX,EDX
NEG EAX
;
; comparaciones
CMP
EAX,EDX ;
SETE AL
;
SETL AL
;
SETGE AL
;
MOVZX EAX,AL ;
; control de flujo
OR
EAX,EAX
JZ
label
JNZ
label
JMP
label
;
;
;
;
EAX -> -EAX
comparar
poner flag Z -> AL
condicion L -> AL
condicion GE -> AL
AL-> EAX
compara EAX con 0.
salto si 0.
salto si no 0.
salto sin condicion.
; llamada procedimientos
CALL subroutine
RET
7
Otras
Ejemplos de programas de ASPLE correctos:
http://www.ii.uam.es/~
alfonsec/asple-p.htm
Descripción de ASPLE de año 1998:
http://www.ii.uam.es/~
alfonsec/asple.htm
7