µ-C: Definición del lenguaje Micro-C

Manual de referencia Micro-C
Compiladores
Universidad Tecnológica Centroamericana
µ-C: Manual de referencia del
lenguaje Micro-C
Introducción
Este manual de referencia describe en detalle el lenguaje Micro-C, para ser
implementado como proyecto de los cursos de Compíladores I y II en la Universidad
Tecnológica Centroamericana (UNITEC), campus Tegucigalpa.
Debe notarse que la definición contiene algunas imprecisiones, ambigüedades o errores
que el implementador (alumno) debe resolver.
Preguntas y observaciones pueden ser dirigidas al Prof. Egdares Futch al correo efutch
arroba yahoo punto com.
Convenciones léxicas
Micro-C es case sensitive, es decir que las letras mayúsculas y minúsculas se tratan
como caracteres diferentes.
Comentarios y caracteres ignorados
Comentario son secuencia de carácter incluido dentro par de secuencias de /*... */
pareados. Los comentarios pueden extender sobre varias líneas, pero los comentarios
anidadados no se reconocen, es decir que el primer encontrado */ dentro de un
comentario lo cierra. Los comentarios son ignorados.
Otros caracteres ignorados incluyen el newline, la tabulación horizontal, el CR, y el
espacio blanco.
Tokens
Las secuencias de caracteres encerrados dentro de dos apóstrofes (') son símbolos
terminales. Cualquier otra secuencia de caracteres denota el nombre de una clase léxica,
p.e. letra (véase abajo).
En secciones posteriores utilizaremos las definiciones léxicas siguientes:
•
letra = ' _ ' | ' a ' | ' b ' |... | ' z ' | ' A ' | ' B ' |... | ' Z '
•
dígito = ' 0 ' | ' 1 ' |... | ' 9 '
Observe que el carácter del underscore (_) está tratado como una letra.
1
Manual de referencia Micro-C
Compiladores
Universidad Tecnológica Centroamericana
Identificadores
Un identificador es una secuencia finita de letras y de dígitos que comienza con una
letra. Los identificadores pueden ser de cualquier longitud, sin embargo, los
identificadores sin diferencia en sus primeros 8 caracteres correspondientes se
consideran iguales.
•
identificador = (letra) (letra | dígito) *.
Constantes numéricas
Un integer_constant es una secuencia de dígitos (no debe comenzar con un 0, a menos
que sea el número 0).
•
integer_constant = digit+
Una constante numérica se debe separar de un identificador o de una palabra clave.
Constantes de caracter
Un char_constant se define como una comilla simple de apertura (“’”), un carácter
ASCII extendido imprimible y una comilla simple de cierre.
Strings constantes
Una constante de string es una secuencia de los caracteres incluidos dentro de dos
comillas dobles ("). Una constante de string puede incluir la secuencia \ " que representa
un carácter de comilla doble en la secuencia en la cual ocurre, tal que no termina el
string. La secuencia \n representa el carácter del NEWLINE, mientras que la secuencia
\ \ representa el carácter del backslash y se puede incluir en un string también. Una
secuencia consistente de un backslash seguido por cualquier caracter a excepción de 'n',
' \ ', o ' " ' es ilegal. Por consiguiente, un string constante no debe extenderse más allá del
extremo de la línea. Un par de /*... */dentro de un string constante no se trata como
comentario.
Operadores
•
add_op = ' + ' | ' - '
•
mul_op = ' * ' | '/'
•
eq_op = ' = = ' | '! = '
•
rel_op = ' < ' | ' < = ' | ' > = ' | ' > '
Otros símbolos
2
Manual de referencia Micro-C
Compiladores
Universidad Tecnológica Centroamericana
Otro símbolos que aparecen en la gramática abajo se denotan dentro de comillas dobles.
Las palabras reservadas están además marcadas en negrita. Los tokens que fueron
definidos arriba se imprime en negrilla.
Gramática de Micro-C
translation_unit
->
external-declaration ->
function_definition
function_def_header
return_type
parameters_def
parameter_def_list
->
->
->
->
->
function_body
declarations
declaration
->
->
->
variable_declaration
function_declaration
parameters_decl
parameter_decl_list
->
->
->
->
parameter_decl_spec ->
->
statement_list
->
statement
expression
->
equality_expression ->
relational_expression ->
simple_expression
->
external-declaration |
translation_unit external-declaration
function-definition |
declaration
function_def_header function_body
return_type identifier "(" parameters _def ")"
type | "void"
parameter_def_list | "void"
type identifier |
parameter_def_list "," type identifier
"{" declarations statement_list "}"
declarations declaration | λ
variable_declaration |
function_declaration
type identifier_list ";"
return_type identifier "(" parameters _decl ")" ";"
parameter_decl_list | parameter_decl_list "," "..." | "void"
parameter_decl_spec |
parameter_decl_list "," parameter_decl_spec
type identifier | "char" "*" identifier
statement_list statement | statement
expression ";" |
"return" ";" |
"return" expression ";" |
"while" "(" expression ")" statement |
"if" "(" expression ")" statement |
"if" "(" expression ")" statement "else"statement |
"{" statement_list "}"
equality_expression "=" equality_expression |
equality_expression
relational_expression eq_op relational_expression |
relational_expression
simple_expression rel_op simple_expression |
simple_expression
simple_expression add_op term |
term
3
Manual de referencia Micro-C
Compiladores
Universidad Tecnológica Centroamericana
term
factor
->
->
constant
numeric_constant
expression_list
identifier_list
type
->
->
->
->
->
term mul_op factor | factor
constant | identifier | "(" expression ")" |
add_op factor | identifier "(" expression_list ")" |
identifier "(" ")"
string_constant | numeric_constant | char_constant
integer_constant | floating_constant
expression | expression_list "," expression
identifier | identifier_list "," identifier
"int" | "char"
Detalles de implementación
El lenguaje µ-C es un subconjunto pequeño del lenguaje de programación C. Cualquier
programa correcto escrito en µ-C debe compilar correctamente con un compilador de
ANSI C.
Tipos de datos
el µ-C ofrece dos tipos de datos del estándar (predefinido): integer y char
Bloques
El µ-C sigue las reglas usuales de scoping. Las funciones pueden ser recursivas.
Cada identificador de variable o de función se debe declarar antes de su uso.
Expresiones
Hay cuatro operadores de aritmética binaria: +, -, *,/. + y - tienen precedencia más baja
que *, y/. además, + y - pueden ser utilizados como operadores unarios.
Con argumentos de tipo entero, cada operación devuelve resultado entero.
Hay seis operadores relacionales binarios: <, < =, ==,! =, > =, >. Los tipos se manejan
como arriba. Los operadores de igualdad (= = y! =) tienen precedencia más baja que los
otros operadores relacionales.
Las expresiones de asignación se hacen por medio del operador de asignación (=) que es
de una precedencia más baja que los operadores relacionales.
Statements
El µ-C tiene cinco diferentes statements: expresión, retorno, while, if, y bloque. La
semántica de cada statement es igual que en C. todos los parámetros son pasados a las
funciones por valor.
4
Manual de referencia Micro-C
Compiladores
Universidad Tecnológica Centroamericana
Biblioteca de runtime para I/O
El µ-C proporciona versiones simples de dos funciones de I/O de la biblioteca estándar
de C: printf y scanf .
scanf requiere un parámetro, el cual es una secuencia de formato (una constante de
string) que puede ser " %d" o " %c" solamente. La función retorna el entero o char
leído del stdin.
printf acepta uno o dos parámetros. Esta función se utiliza para escribir el valor de una
expresión (entera o char) o de una constante de string. El primer parámetro es una
secuencia de formato (una constante de string) que puede contener una sola conversión
“%d” o “%c” (para imprimir un % se escribe %%). El segundo parámetro (si existe) se
imprime de acuerdo a lo especificado por el directivo de conversión especificado en el
primer parámetro.
Ejemplos
Cálculo de una expresión simple
/*
* a sample program #1
*/
int scanf( char *fmt, ... );
int printf( char *fmt, ... );
int
main( void )
{
int i, j;
}
i = scanf("%d");
/* lea i */
j = 9 + i * 8;
/* evalue j */
printf( "Resultado es %d\n", j );
/* imprima j */
Llamada simple a función
/*
* a sample program #2
*/
int scanf( char *fmt, ... );
int printf( char *fmt, ... );
int count( int n );
int
main( void )
{
int i, sum;
5
Manual de referencia Micro-C
Compiladores
Universidad Tecnológica Centroamericana
}
i = scanf( "%d", &i);
sum = count(i);
printf( "%d\n", sum );
/* lea i */
/* llame a count */
/* imprima resultados */
int
count( int n )
{
int i, sum;
}
i = 1;
sum = 0;
while ( i <= n ) {
sum = sum + i;
i = i + 1;
}
return sum;
Una función recursiva simple
/*
* recursive factorial calculation
*/
int scanf( char *fmt, ... );
int printf( char *fmt, ... );
int factorial( int n );
int
main( void )
{
int n, fact;
}
printf( "Ingrese un entero: " );
n = scanf( "%d");
/* lea i */
fact = factorial( n );
/* llame a factorial */
printf( "Factorial de %d ", n );
printf( "es %d\n", fact );
int
factorial( int n )
{
if ( n <= 1 )
return 1;
else
return n * factorial( n - 1 );
}
6