Proyecto 1. Analizador léxico y sintáctico

a) Requerimientos del lenguaje de programación

El lenguaje de programación “Sixty”, planteado como una alternativa de propósito general, deberá cumplir con los siguientes requerimientos para su primera versión:

• Funcionales:

• Deberá ser de tipado estático, definiendo el tipo de cada variable/objeto de una sola manera.
• Scope (alcance o ámbito) delimitado por una llave “{“ de apertura y “}” de cierre.
• Cada sentencia deberá ser terminada con “;”.
• Las cadenas (string) presentes en el código deberán ser delimitadas con “ `` “ ó “ “” “. Pueden o no ser multilínea.
• Los caracteres (char) presentes en el código deberán ser delimitados con “ ''  “.
• Los template strings presentes en el código deberán ser delimitados con “ `` “ y se declaran con “$“.
• Las definiciones de tipo de dato deberán hacerse con “:” entre el tipo de dato y la variable.
• Las comparaciones deberán hacerse con “==”.
• Las comparaciones de tipo deberán hacerse con “===”.
• Para expresar el operador lógico “OR” deberá hacerse con “|”.
• Para expresar el operador lógico “AND” deberá hacerse con “&”.
• Para expresar el operador lógico “NOT” deberá hacerse con “!”.
• Deberá utilizarse la palabra “function” para declarar una función, “(“ de apertura y “)” de cierre para contener parámetros y; “{“ de apertura y “}” de cierre para indicar el inicio y fin de la función
• El tipo de dato de una función deberá mostrarse con “->”.
• Para realizar comentarios de una sola línea deberán usarse “//” al inicio de la linea a comentar.
• Para realizar comentarios multilínea deberán usarse “*/” de apertura y “*/” de cierre para indicar el inicio y fin del comentario.
• Las operaciones aritméticas  de suma, resta, multiplicación, división y potencia deberán ser expresadas con su símbolo correspondiente. Para suma “+”, para resta “-”, para multiplicación “*”, para división “/” y para potencia “^”.

• No funcionales:

• Sixty deberá ser escrito en Java.
• Deberá ofrecer las herramientas necesarias para considerarse “de propósito general”.
• Deberá ser un subconjunto estricto de Java.
• Deberá compilar a Bytecode.
• La extensión de un “archivo Sixty” deberá ser “.l60”.
• Deberá permitir la ejecución de programas en consola.

b) Tipos de palabras y puntuación que proporcionará el lenguaje

Palabras reservadas.

• bool
• int
• chr
• str
• flt
• if
• else
• elif
• whl
• for
• true
• false
• func
• null
• brk
• ret
• write
• read

Identificadores.

• El primer símbolo del identificador será un carácter alfabético (a, …, z, A, …, Z, ‘_’, ‘$’) pero no un dígito. Después del primer carácter, será posible poner caracteres alfanuméricos (a, …, z) y (0, 1, …, 9), signos de peso ‘$’ o guiones de subrayado ‘_’.
• Los identificadores no pueden coincidir con las palabras reservadas.
• Las mayúsculas y las minúsculas se consideran diferentes.
• El signo de peso y el guió de subrayado se interpretan como una letra más.

Literales.

• Especificación de un valor concreto de un tipo de dato.

• Números enteros.

• 21(int).

• Números reales.

• 3.14f(float).

• Valores booleanos

• true (verdadero), false (falso).

• Caracteres.

• ‘p’

• Cadenas de caracteres.

• “mensaje”, “”(cadena vacía).

Operadores.

Igual que en matemáticas, realizan una acción específica:

• Suelen estar definidos en el núcleo del compilador (aunque también pueden estar definidos en bibliotecas externas).
• Suelen representarse con tokens formados por símbolos.
• Suelen utilizar notación fija.
• Pueden aplicarse a uno o varios operandos (argumentos).
• Suelen devolver un valor.

Operadores en Sixty, por orden de precedencia

.     [     ]     (     )

++     –

!

*     /     %

+     -

< >     <=     >=     ==     !=     ===

&     |

Delimitadores.

Símbolos utilizados como separadores de las distintas construcciones de un lenguaje de programación(esto es, los signos de puntuación de un lenguaje de programación).

• ( ) Paréntesis: Listas de parámetros en la definición y llamada a métodos, precedencia en expresiones, expresiones para control de flujo y conversiones de tipo.
• { } Llaves: Bloques de código, métodos y ámbitos locales.
• ; Punto y coma: Separador de sentencias.
• , Coma: Identificadores consecutivos en una declaración de variables y sentencias encadenadas dentro de una sentencia for.
• . Punto: Separador entre variables y métodos/miembros.

Comentarios.

Aclaración que el programador incluye en el texto del programa para mejorar su inteligibilidad.

En Sixty  habrá 2 tipos de comentarios:

• // Comentario de una sola línea.
• /* Comentario de una o más líneas. */

c) Especificación del tipo de flujo de control

IF-ELSE

if(expresión){

     bloque de código

} else {

     bloque de código

}

WHILE

whl(expresión){

     bloque de código

}

FOR

for(int variable = x; expresión; incremento ó decremento){

     bloque de código

}

ELIF

if(expresión){

     bloque de código

} elif (expresión {

     bloque de código

}

d) Tipos de datos a admitir

BOOLEAN

Sirve para definir tipos de datos booleanos. Aquellos que tienen valor de “true” o “false”. Ocupan 1 bit de información.

CHAR

Es un tipo de dato que representa a un carácter Unicode sencillo de 16 bits.

STRING

Objetos de Sixty que representan cadenas de caracteres. Los caracteres se codifican usando Unicode.

INT

Es un tipo de dato de 32 bits con un signo para almacenar valores numéricos. Cuyo valor mínimo es -2^31 y valor máximo 2^31-1.

FLOAT

Es un tipo de dato para almacenar números en coma flotante con precisión simple de 32 bits.

e) Estructura general del lenguaje de programación

Para comenzar a escribir un programa en Sixty deberá declararse la función principal, a partir de la cual comenzará la ejecución de manera secuencial de cada sentencia. Para ilustrar de una mejor manera, el siguiente código sería el necesario para realizar el famoso “Hola mundo” en este lenguaje.

func main(): int{

     write(“Hola mundo”);

     ret 0;

}

f) Lexemas, categorías léxicas y tokens

g) Expresiones regulares

identificador: id=([a-zA-Z_][a-zA-Z0-9]*)

comentario multilínea: "/*"([^*]|"*"+[^/*])*"*"+"/"

comentario: "//".*\r?\n

espacio en blanco: [ \t\r\f]+

línea en blanco: \n

break: brk

else: else

false

for

if

else if: elif

null

function: func

return: ret

character: chr

string: str

boolean: bool

integer: int

float: flt

true

void

while: whl

(

)

[

]

{

}

;

:

!

*

/

//

%

+

-

<

\^

<=

>

>=

==

!=

&

|

=

+=

-=

,

.

integer: [0-9]+

float: [0-9]*"."[0-9]*([eE][+-]?[0-9]+)?

([0-9]+)([eE][+-]?([0-9]+))

\"([^\"]|(\\.))*\"

'([^']|(\\.))*'

.

h) Código fuente en JFlex

%%

%int

id=([a-zA-Z_][a-zA-Z0-9]*)

%%

"/*"([^*]|"*"+[^/*])*"*"+"/" { sixty.comment(); }

"//".*\r?\n                  { sixty.comment(); }

[ \t\r\f]+                   { sixty.whitespace(); }

\n                           { sixty.newline(); }

"brk"                { return sixty.scan(parser.BREAK); }

"else"                 { return sixty.scan(parser.ELSE); }

"false"                { return sixty.scan(parser.BOOLLIT); }

"for"                  { return sixty.scan(parser.FOR); }

"if"                   { return sixty.scan(parser.IF); }

"elif"                   { return sixty.scan(parser.ELIF); }

"null"                 { return sixty.scan(parser.NULLVAL); }

"func"             { return sixty.scan(parser.FUNCTION); }

"ret"               { return sixty.scan(parser.RETURN); }

"chr"                  { return sixty.scan(parser.CHAR); }

"str"               { return sixty.scan(parser.STRING); }

"bool"              { return sixty.scan(parser.BOOL); }

"int"                  { return sixty.scan(parser.INT); }

"flt"               { return sixty.scan(parser.FLOAT); }

"true"                 { return sixty.scan(parser.BOOLLIT); }

"void"                 { return sixty.scan(parser.VOID); }

"whl"                { return sixty.scan(parser.WHILE); }

"("                    { return sixty.scan(sixty.ord("("));}

")"                    { return sixty.scan(sixty.ord(")"));}

"["                    { return sixty.scan(sixty.ord("["));}

"]"                    { return sixty.scan(sixty.ord("]"));}

"{"                    { return sixty.scan(sixty.ord("{"));}

"}"                    { return sixty.scan(sixty.ord("}"));}

";"                    { return sixty.scan(sixty.ord(";"));}

":"                    { return sixty.scan(sixty.ord(":"));}

"!"                    { return sixty.scan(sixty.ord("!"));}

"*"                    { return sixty.scan(sixty.ord("*"));}

"/"                    { return sixty.scan(sixty.ord("/"));}

"//"                    { return sixty.scan(sixty.ord("//"));}

"%"                    { return sixty.scan(sixty.ord("%"));}

"+"                    { return sixty.scan(sixty.ord("+"));}

"-"                    { return sixty.scan(sixty.ord("-"));}

"<"                    { return sixty.scan(sixty.ord("<"));}

"\^"                    { return sixty.scan(sixty.ord("^"));}

"<="                   { return sixty.scan(parser.LESSTHANOREQUAL);}

">"                    { return sixty.scan(sixty.ord(">"));}

">="                   { return sixty.scan(parser.GREATERTHANOREQUAL);}

"=="                   { return sixty.scan(parser.ISEQUALTO);}

"!="                   { return sixty.scan(parser.NOTEQUALTO);}

"&"                   { return sixty.scan(parser.LOGICALAND);}

"|"                   { return sixty.scan(parser.LOGICALOR);}

"="                    { return sixty.scan(sixty.ord("=")); }

"+="                   { return sixty.scan(parser.INCREMENT); }

"-="                   { return sixty.scan(parser.DECREMENT); }

","                    { return sixty.scan(sixty.ord(",")); }

"."                    { return sixty.scan(sixty.ord(".")); }

{id}                   { return sixty.scan(parser.IDENTIFIER); }

[0-9]+                 { return sixty.scan(parser.INTLIT); }

[0-9]*"."[0-9]*([eE][+-]?[0-9]+)? { return sixty.scan(parser.FLOATLIT); }

([0-9]+)([eE][+-]?([0-9]+))  { return sixty.scan(parser.FLOATLIT); }

\"([^\"]|(\\.))*\"    { return sixty.scan(parser.STRINGLIT); }

'([^']|(\\.))*'    { return sixty.scan(parser.CHARLIT); }

.                      { sixty.lexErr("unrecognized character"); }

i) Gramáticas libres de contexto

FieldDecl: VarDecls  :  Type  ;  

Type: INT | FLOAT | BOOL | STRING | CHAR | Name

Name: IDENTIFIER | QualifiedName

QualifiedName: Name  .  IDENTIFIER

VarDecls: VarDeclarator | VarDecls  ,  VarDeclarator

VarDeclarator: IDENTIFIER | VarDeclarator  [   ]  

MethodReturnVal : Type | VOID

MethodDecl: MethodHeader Block

MethodHeader: FUNCTION MethodDeclarator  :  MethodReturnVal

MethodDeclarator: IDENTIFIER  (  FormalParmListOpt  )  

FormalParmListOpt: FormalParmList  

FormalParmList: FormalParm | FormalParmList  ,  FormalParm

FormalParm: VarDeclarator  :  Type

ArgListOpt:  ArgList

Block:  {  BlockStmtsOpt  }  

BlockStmtsOpt: BlockStmts

BlockStmts:  BlockStmt | BlockStmts BlockStmt

BlockStmt:   LocalVarDeclStmt | Stmt

LocalVarDeclStmt: LocalVarDecl  ;  

LocalVarDecl: VarDecls  :  Type

Stmt: Block |  ;  | ExprStmt | BreakStmt | ReturnStmt |

      | IfThenStmt | IfThenElseStmt | IfThenElseIfStmt

      | WhileStmt | ForStmt

ExprStmt: StmtExpr  ;  

StmtExpr: Assignment | MethodCall | InstantiationExpr

IfThenStmt: IF  (  Expr  )  Block

IfThenElseStmt: IF  (  Expr  )  Block ELSE Block

IfThenElseIfStmt: IF  (  Expr  )  Block ElseIfSequence

       |  IF  (  Expr  )  Block ElseIfSequence ELSE Block

ElseIfSequence: ElseIfStmt | ElseIfSequence ElseIfStmt

ElseIfStmt: ELIF  (  Expr  )  Block | ELSE IfThenStmt

WhileStmt: WHILE  (  Expr  )  Stmt

ForStmt: FOR  (  ForInit  ;  ExprOpt  ;  ForUpdate  )  Block

ForInit: StmtExprList | LocalVarDecl

ExprOpt: Expr

ForUpdate: StmtExprList

StmtExprList: StmtExpr | StmtExprList  ,  StmtExpr

BreakStmt: BREAK  ;  | BREAK IDENTIFIER  ;  

ReturnStmt: RETURN ExprOpt  ;  

Primary:  Literal |  (  Expr  )  | FieldAccess | MethodCall

Literal: INTLIT | FLOATLIT | BOOLLIT | STRINGLIT | CHARLIT | NULLVAL

InstantiationExpr: Name  (  ArgListOpt  )  

ArgList: Expr | ArgList  ,  Expr

FieldAccess: Primary  .  IDENTIFIER

MethodCall: Name  (  ArgListOpt  )

    | Name  {  ArgListOpt  }

    | Primary  .  IDENTIFIER  (  ArgListOpt  )

    | Primary  .  IDENTIFIER  {  ArgListOpt  }  

PostFixExpr: Primary | Name

UnaryExpr:   -  UnaryExpr |  !  UnaryExpr | PostFixExpr

MulExpr: UnaryExpr | MulExpr  *  UnaryExpr

    | MulExpr  /  UnaryExpr | MulExpr  %  UnaryExpr

AddExpr: MulExpr | AddExpr  +  MulExpr | AddExpr  -  MulExpr

RelOp: LESSTHANOREQUAL | GREATERTHANOREQUAL |  <  |  >  

RelExpr: AddExpr | RelExpr RelOp AddExpr

EqExpr: RelExpr | EqExpr ISEQUALTO RelExpr | EqExpr NOTEQUALTO RelExpr

CondAndExpr: EqExpr | CondAndExpr LOGICALAND EqExpr

CondOrExpr: CondAndExpr | CondOrExpr LOGICALOR CondAndExpr

Expr: CondOrExpr | Assignment

Assignment: LeftHandSide AssignOp Expr

LeftHandSide: Name | FieldAccess

AssignOp:  =  | INCREMENT | DECREMENT

j) Código fuente en Yacc

%token BREAK ELSE FOR IF INT RETURN VOID WHILE FLOAT ELIF

%token IDENTIFIER FUNCTION CHAR STRING BOOL

%token INTLIT CHARLIT STRINGLIT  BOOLLIT NULLVAL FLOATLIT

%token LESSTHANOREQUAL GREATERTHANOREQUAL

%token ISEQUALTO NOTEQUALTO LOGICALAND LOGICALOR

%token INCREMENT DECREMENT

%%

FieldDecl: VarDecls ':' Type ';' ;

Type: INT | FLOAT | BOOL | STRING | CHAR | Name ;

Name: IDENTIFIER | QualifiedName ;

QualifiedName: Name '.' IDENTIFIER ;

VarDecls: VarDeclarator | VarDecls ',' VarDeclarator ;

VarDeclarator: IDENTIFIER | VarDeclarator '[' ']' ;

MethodReturnVal : Type | VOID ;

MethodDecl: MethodHeader Block ;

MethodHeader: FUNCTION MethodDeclarator ':' MethodReturnVal ;

MethodDeclarator: IDENTIFIER '(' FormalParmListOpt ')' ;

FormalParmListOpt: FormalParmList | '';

FormalParmList: FormalParm | FormalParmList ',' FormalParm ;

FormalParm: VarDeclarator ':' Type ;

ArgListOpt:  ArgList | ;

Block: '{' BlockStmtsOpt '}' ;

BlockStmtsOpt: BlockStmts | ;

BlockStmts:  BlockStmt | BlockStmts BlockStmt ;

BlockStmt:   LocalVarDeclStmt | Stmt ;

LocalVarDeclStmt: LocalVarDecl ';' ;

LocalVarDecl: VarDecls ':' Type;

Stmt: Block | ';' | ExprStmt | BreakStmt | ReturnStmt |

      | IfThenStmt | IfThenElseStmt | IfThenElseIfStmt

      | WhileStmt | ForStmt ;

StmtWithoutTrailingSubstatement: ;

ExprStmt: StmtExpr ';' ;

StmtExpr: Assignment | MethodCall | InstantiationExpr ;

IfThenStmt: IF '(' Expr ')' Block ;

IfThenElseStmt: IF '(' Expr ')' Block ELSE Block ;

IfThenElseIfStmt: IF '(' Expr ')' Block ElseIfSequence

       |  IF '(' Expr ')' Block ElseIfSequence ELSE Block ;

ElseIfSequence: ElseIfStmt | ElseIfSequence ElseIfStmt ;

ElseIfStmt: ELIF '(' Expr ')' Block | ELSE IfThenStmt ;

WhileStmt: WHILE '(' Expr ')' Stmt ;

ForStmt: FOR '(' ForInit ';' ExprOpt ';' ForUpdate ')' Block ;

ForInit: StmtExprList | LocalVarDecl | ;

ExprOpt: Expr |  ;

ForUpdate: StmtExprList | ;

StmtExprList: StmtExpr | StmtExprList ',' StmtExpr ;

BreakStmt: BREAK ';' | BREAK IDENTIFIER ';' ;

ReturnStmt: RETURN ExprOpt ';' ;

Primary:  Literal | '(' Expr ')' | FieldAccess | MethodCall ;

Literal: INTLIT | FLOATLIT | BOOLLIT | STRINGLIT | CHARLIT | NULLVAL ;

InstantiationExpr: Name '(' ArgListOpt ')' ;

ArgList: Expr | ArgList ',' Expr ;

FieldAccess: Primary '.' IDENTIFIER ;

MethodCall: Name '(' ArgListOpt ')'

    | Name '{' ArgListOpt '}'

    | Primary '.' IDENTIFIER '(' ArgListOpt ')'

    | Primary '.' IDENTIFIER '{' ArgListOpt '}' ;

PostFixExpr: Primary | Name ;

UnaryExpr:  '-' UnaryExpr | '!' UnaryExpr | PostFixExpr ;

MulExpr: UnaryExpr | MulExpr '*' UnaryExpr

    | MulExpr '/' UnaryExpr | MulExpr '%' UnaryExpr ;

AddExpr: MulExpr | AddExpr '+' MulExpr | AddExpr '-' MulExpr ;

RelOp: LESSTHANOREQUAL | GREATERTHANOREQUAL | '<' | '>' ;

RelExpr: AddExpr | RelExpr RelOp AddExpr ;

EqExpr: RelExpr | EqExpr ISEQUALTO RelExpr | EqExpr NOTEQUALTO RelExpr ;

CondAndExpr: EqExpr | CondAndExpr LOGICALAND EqExpr ;

CondOrExpr: CondAndExpr | CondOrExpr LOGICALOR CondAndExpr ;

Expr: CondOrExpr | Assignment ;

Assignment: LeftHandSide AssignOp Expr ;

LeftHandSide: Name | FieldAccess ;

AssignOp: '=' | INCREMENT | DECREMENT ;

k) Conclusiones

Con la culminación de este reporte el cual contiene información sobre cómo se elaboró un compilador para un lenguaje llamado Sixty, se puede concluir que se ha realizado un trabajo exhaustivo y detallado. El equipo encargado del desarrollo ha mostrado habilidades técnicas y una comprensión profunda de los principios fundamentales de los compiladores y la programación.

El software Sixty ha sido diseñado para procesar programas escritos en este lenguaje y convertirlos en un código ejecutable. El reporte describe con precisión el proceso de diseño e implementación del compilador, incluyendo la definición del lenguaje, el análisis léxico, sintáctico,  semántico y la generación de código.

Se puede observar que el equipo ha prestado atención a aspectos importantes como la eficacia y la eficiencia del compilador, la generación de mensajes de error claros y precisos, la compatibilidad con diferentes plataformas y la facilidad de uso.

En general, el reporte demuestra que se ha realizado un trabajo serio y bien planificado en el desarrollo del compilador Sixty. Este compilador tiene el potencial de ser una herramienta valiosa para los programadores que trabajan con este lenguaje, ya que facilitará el proceso de creación y depuración de programas en Sixty.

g) Bibliografía

P. (s. f.). GitHub - PacktPublishing/Build-Your-Own-Programming-Language: Build Your Own Programming Language, published by Packt. GitHub. https://github.com/PacktPublishing/Build-Your-Own-Programming-Language