slococo-uni
/
bfbcompiler
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Convert tabs to spaces 

Co-authored-by: Ezequiel Bellver <ebellver@itba.edu.ar>
Co-authored-by: Juan Barmasch <jbarmasch@itba.edu.ar>
This commit is contained in:
Santiago Lo Coco 2022-04-19 07:25:53 -03:00
parent ac68ed4224
commit b01b910188
10 changed files with 323 additions and 336 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
CMakeLists.txt
View File

@ -6,55 +6,55 @@ project(Compiler C)
# Compilar el parser con Bison: # Compilar el parser con Bison:
add_custom_command( add_custom_command(
OUTPUT ../src/frontend/syntactic-analysis/bison-parser.c ../src/frontend/syntactic-analysis/bison-parser.h OUTPUT ../src/frontend/syntactic-analysis/bison-parser.c ../src/frontend/syntactic-analysis/bison-parser.h
COMMAND bison -d ../src/frontend/syntactic-analysis/bison-grammar.y -o ../src/frontend/syntactic-analysis/bison-parser.c) # COMMAND bison -d ../src/frontend/syntactic-analysis/bison-grammar.y -o ../src/frontend/syntactic-analysis/bison-parser.c)
# COMMAND bison -Wcounterexamples -d ../src/frontend/syntactic-analysis/bison-grammar.y -o ../src/frontend/syntactic-analysis/bison-parser.c) COMMAND bison -Wcounterexamples -d ../src/frontend/syntactic-analysis/bison-grammar.y -o ../src/frontend/syntactic-analysis/bison-parser.c)
# COMMAND bison -t -d ../src/frontend/syntactic-analysis/bison-grammar.y -o ../src/frontend/syntactic-analysis/bison-parser.c) # COMMAND bison -t -d ../src/frontend/syntactic-analysis/bison-grammar.y -o ../src/frontend/syntactic-analysis/bison-parser.c)
# Seleccionar estrategia según el compilador de C disponible en el sistema: # Seleccionar estrategia según el compilador de C disponible en el sistema:
if (CMAKE_C_COMPILER_ID STREQUAL "GNU") if (CMAKE_C_COMPILER_ID STREQUAL "GNU")
message(NOTICE "El compilador de C es GCC.") message(NOTICE "El compilador de C es GCC.")
# Opciones para GCC: # Opciones para GCC:
add_compile_options(-static-libgcc) add_compile_options(-static-libgcc)
add_compile_options(-std=gnu99) add_compile_options(-std=gnu99)
add_compile_options(-O3) add_compile_options(-O3)
# Compilar el scanner con Flex: # Compilar el scanner con Flex:
add_custom_command( add_custom_command(
OUTPUT ../src/frontend/lexical-analysis/flex-scanner.c OUTPUT ../src/frontend/lexical-analysis/flex-scanner.c
COMMAND flex -o ../src/frontend/lexical-analysis/flex-scanner.c ../src/frontend/lexical-analysis/flex-patterns.l COMMAND flex -o ../src/frontend/lexical-analysis/flex-scanner.c ../src/frontend/lexical-analysis/flex-patterns.l
DEPENDS ../src/frontend/syntactic-analysis/bison-parser.c ../src/frontend/syntactic-analysis/bison-parser.h) DEPENDS ../src/frontend/syntactic-analysis/bison-parser.c ../src/frontend/syntactic-analysis/bison-parser.h)
# COMMAND flex --debug -o ../src/frontend/lexical-analysis/flex-scanner.c ../src/frontend/lexical-analysis/flex-patterns.l # COMMAND flex --debug -o ../src/frontend/lexical-analysis/flex-scanner.c ../src/frontend/lexical-analysis/flex-patterns.l
elseif (CMAKE_C_COMPILER_ID STREQUAL "MSVC") elseif (CMAKE_C_COMPILER_ID STREQUAL "MSVC")
message(NOTICE "El compilador de C es Microsoft Visual Studio.") message(NOTICE "El compilador de C es Microsoft Visual Studio.")
# Opciones para MSVC: # Opciones para MSVC:
# add_compile_options(...) # add_compile_options(...)
# Compilar el scanner con Flex, usando compatibilidad con Microsoft Windows: # Compilar el scanner con Flex, usando compatibilidad con Microsoft Windows:
add_custom_command( add_custom_command(
OUTPUT ../src/frontend/lexical-analysis/flex-scanner.c OUTPUT ../src/frontend/lexical-analysis/flex-scanner.c
COMMAND flex --wincompat -o ../src/frontend/lexical-analysis/flex-scanner.c ../src/frontend/lexical-analysis/flex-patterns.l COMMAND flex --wincompat -o ../src/frontend/lexical-analysis/flex-scanner.c ../src/frontend/lexical-analysis/flex-patterns.l
DEPENDS ../src/frontend/syntactic-analysis/bison-parser.c ../src/frontend/syntactic-analysis/bison-parser.h) DEPENDS ../src/frontend/syntactic-analysis/bison-parser.c ../src/frontend/syntactic-analysis/bison-parser.h)
else () else ()
message(NOTICE "El compilador de C es desconocido.") message(NOTICE "El compilador de C es desconocido.")
message(NOTICE "No se generará el scanner con Flex.") message(NOTICE "No se generará el scanner con Flex.")
endif () endif ()
# Especificar punto de entrada del proyecto y códigos fuente (extensión *.c): # Especificar punto de entrada del proyecto y códigos fuente (extensión *.c):
add_executable(Compiler add_executable(Compiler
src/main.c src/main.c
src/backend/code-generation/generator.c src/backend/code-generation/generator.c
src/backend/domain-specific/calculator.c src/backend/domain-specific/calculator.c
src/backend/support/logger.c src/backend/support/logger.c
src/frontend/lexical-analysis/flex-actions.c src/frontend/lexical-analysis/flex-actions.c
src/frontend/lexical-analysis/flex-scanner.c src/frontend/lexical-analysis/flex-scanner.c
src/frontend/syntactic-analysis/bison-actions.c src/frontend/syntactic-analysis/bison-actions.c
src/frontend/syntactic-analysis/bison-parser.c) src/frontend/syntactic-analysis/bison-parser.c)
# Linkear el proyecto y sus librerías: # Linkear el proyecto y sus librerías:
target_link_libraries(Compiler) target_link_libraries(Compiler)

2
src/backend/code-generation/generator.c
View File

@ -6,5 +6,5 @@
*/ */
void Generator(int result) { void Generator(int result) {
LogInfo("El resultado de la expresion computada es: '%d'.", result); LogInfo("El resultado de la expresion computada es: '%d'.", result);
} }

8
src/backend/domain-specific/calculator.c
View File

@ -5,17 +5,17 @@
*/ */
int Add(const int leftAddend, const int rightAddend) { int Add(const int leftAddend, const int rightAddend) {
return leftAddend + rightAddend; return leftAddend + rightAddend;
} }
int Subtract(const int minuend, const int subtract) { int Subtract(const int minuend, const int subtract) {
return minuend - subtract; return minuend - subtract;
} }
int Multiply(const int multiplicand, const int multiplier) { int Multiply(const int multiplicand, const int multiplier) {
return multiplicand * multiplier; return multiplicand * multiplier;
} }
int Divide(const int dividend, const int divisor) { int Divide(const int dividend, const int divisor) {
return dividend / divisor; return dividend / divisor;
} }

38
src/backend/support/logger.c
View File

@ -7,35 +7,35 @@
*/ */
void Log(FILE * const stream, const char * prefix, const char * const format, const char * suffix, va_list arguments) { void Log(FILE * const stream, const char * prefix, const char * const format, const char * suffix, va_list arguments) {
fprintf(stream, "%s", prefix); fprintf(stream, "%s", prefix);
vfprintf(stream, format, arguments); vfprintf(stream, format, arguments);
fprintf(stream, "%s", suffix); fprintf(stream, "%s", suffix);
} }
void LogDebug(const char * const format, ...) { void LogDebug(const char * const format, ...) {
va_list arguments; va_list arguments;
va_start(arguments, format); va_start(arguments, format);
Log(stdout, "[DEBUG] ", format, "\n", arguments); Log(stdout, "[DEBUG] ", format, "\n", arguments);
va_end(arguments); va_end(arguments);
} }
void LogError(const char * const format, ...) { void LogError(const char * const format, ...) {
va_list arguments; va_list arguments;
va_start(arguments, format); va_start(arguments, format);
Log(stderr, "[ERROR] ", format, "\n", arguments); Log(stderr, "[ERROR] ", format, "\n", arguments);
va_end(arguments); va_end(arguments);
} }
void LogErrorRaw(const char * const format, ...) { void LogErrorRaw(const char * const format, ...) {
va_list arguments; va_list arguments;
va_start(arguments, format); va_start(arguments, format);
Log(stderr, "", format, "", arguments); Log(stderr, "", format, "", arguments);
va_end(arguments); va_end(arguments);
} }
void LogInfo(const char * const format, ...) { void LogInfo(const char * const format, ...) {
va_list arguments; va_list arguments;
va_start(arguments, format); va_start(arguments, format);
Log(stdout, "[INFO ] ", format, "\n", arguments); Log(stdout, "[INFO ] ", format, "\n", arguments);
va_end(arguments); va_end(arguments);
} }

20
src/backend/support/shared.h
View File

@ -29,23 +29,23 @@ extern int yyparse(void);
// Emular tipo "boolean". // Emular tipo "boolean".
typedef enum { typedef enum {
false = 0, false = 0,
true = 1 true = 1
} boolean; } boolean;
// Estado global de toda la aplicación. // Estado global de toda la aplicación.
typedef struct { typedef struct {
// Indica si la compilación tuvo problemas hasta el momento: // Indica si la compilación tuvo problemas hasta el momento:
boolean succeed; boolean succeed;
// Indica el resultado de la compilación: // Indica el resultado de la compilación:
int result; int result;
// Agregar una pila para almacenar tokens/nodos. // Agregar una pila para almacenar tokens/nodos.
// Agregar un nodo hacia la raíz del árbol de sintaxis abstracta. // Agregar un nodo hacia la raíz del árbol de sintaxis abstracta.
// Agregar una tabla de símbolos. // Agregar una tabla de símbolos.
// ... // ...
} CompilerState; } CompilerState;

26
src/frontend/lexical-analysis/flex-actions.c
View File

@ -7,32 +7,32 @@
*/ */
TokenID IntegerPatternAction(const char * lexeme) { TokenID IntegerPatternAction(const char * lexeme) {
// LogDebug("IntegerPatternAction: '%s'.", lexeme); // LogDebug("IntegerPatternAction: '%s'.", lexeme);
yylval = atoi(lexeme); yylval = atoi(lexeme);
return INTEGER; return INTEGER;
} }
TokenID DoublePatternAction(const char * lexeme) { TokenID DoublePatternAction(const char * lexeme) {
// LogDebug("DoublePatternAction: '%s'.", lexeme); // LogDebug("DoublePatternAction: '%s'.", lexeme);
yylval = atof(lexeme); yylval = atof(lexeme);
return DOUBLE; return DOUBLE;
} }
TokenID StringPatternAction(const char * lexeme) { TokenID StringPatternAction(const char * lexeme) {
// LogDebug("StringPatternAction: '%s'.", lexeme); // LogDebug("StringPatternAction: '%s'.", lexeme);
return STRING; return STRING;
} }
TokenID EscapeStringPatternAction(const char * lexeme) { TokenID EscapeStringPatternAction(const char * lexeme) {
// LogDebug("EscapeStringPatternAction: '%s'.", lexeme); // LogDebug("EscapeStringPatternAction: '%s'.", lexeme);
return ESCAPESTRING; return ESCAPESTRING;
} }
void IgnoredPatternAction(const char * lexeme) { void IgnoredPatternAction(const char * lexeme) {
// LogDebug("IgnoredPatternAction: '%s'.", lexeme); // LogDebug("IgnoredPatternAction: '%s'.", lexeme);
} }
TokenID UnknownPatternAction(const char * lexeme) { TokenID UnknownPatternAction(const char * lexeme) {
LogDebug("UnknownPatternAction: '%s'.", lexeme); LogDebug("UnknownPatternAction: '%s'.", lexeme);
return YYUNDEF; return YYUNDEF;
} }

122
src/frontend/lexical-analysis/flex-actions.h
View File

@ -8,69 +8,69 @@
*/ */
typedef enum TokenID { typedef enum TokenID {
// Por defecto, el valor "0" hace fallar el analizador sintáctico. // Por defecto, el valor "0" hace fallar el analizador sintáctico.
UNKNOWN = 0, UNKNOWN = 0,
// Código de error de Bison, que permite abortar el escaneo de lexemas cuando // Código de error de Bison, que permite abortar el escaneo de lexemas cuando
// se presente un patrón desconocido. El número "257" coincide con el valor // se presente un patrón desconocido. El número "257" coincide con el valor
// que Bison le otorga por defecto, pero además permite que el resto de // que Bison le otorga por defecto, pero además permite que el resto de
// tokens continúen desde el valor "258" lo que permite proteger los IDs // tokens continúen desde el valor "258" lo que permite proteger los IDs
// internos que Bison reserva para crear "tokens literales": // internos que Bison reserva para crear "tokens literales":
YYUNDEF = 257, YYUNDEF = 257,
ADD, ADD,
SUB, SUB,
MUL, MUL,
DIV, DIV,
POW, POW,
FUNCTION, FUNCTION,
IF, IF,
ELSE, ELSE,
FOR, FOR,
WHILE, WHILE,
PRINT, PRINT,
SEMICOLON, SEMICOLON,
COMPOSITE, COMPOSITE,
SQUOTE, SQUOTE,
DERIVATIVE, DERIVATIVE,
INTEGRATE, INTEGRATE,
BETWEEN, BETWEEN,
AND_INT, AND_INT,
EVALUATE, EVALUATE,
IN, IN,
OPEN_BRACES, OPEN_BRACES,
OPEN_BRACKETS, OPEN_BRACKETS,
CLOSE_BRACES, CLOSE_BRACES,
CLOSE_BRACKETS, CLOSE_BRACKETS,
OPEN_PARENTHESIS, OPEN_PARENTHESIS,
CLOSE_PARENTHESIS, CLOSE_PARENTHESIS,
ASSIGN, ASSIGN,
EQUAL, EQUAL,
AND, AND,
OR, OR,
NOT, NOT,
ADD_ASSIGN, ADD_ASSIGN,
INCREMENT, INCREMENT,
SUB_ASSIGN, SUB_ASSIGN,
DECREMENT, DECREMENT,
MUL_ASSIGN, MUL_ASSIGN,
DIV_ASSIGN, DIV_ASSIGN,
DQUOTE, DQUOTE,
COMMA, COMMA,
COLON, COLON,
LESSER, LESSER,
LESSER_EQUAL, LESSER_EQUAL,
GREATER, GREATER,
GREATER_EQUAL, GREATER_EQUAL,
NOT_EQUAL, NOT_EQUAL,
VAR, VAR,
ERR, ERR,
TAYLOR, TAYLOR,
ESCAPESTRING, ESCAPESTRING,
PRINTCSV, PRINTCSV,
DOUBLE, DOUBLE,
INTEGER, INTEGER,
STRING STRING
} TokenID; } TokenID;
/** /**

56
src/frontend/syntactic-analysis/bison-actions.c
View File

@ -9,59 +9,59 @@
*/ */
void yyerror(const char * string) { void yyerror(const char * string) {
LogError("Mensaje: '%s' debido a '%s' (linea %d).", string, yytext, yylineno); LogError("Mensaje: '%s' debido a '%s' (linea %d).", string, yytext, yylineno);
// LogError("En ASCII es:"); // LogError("En ASCII es:");
// LogErrorRaw("\t"); // LogErrorRaw("\t");
// const int length = strlen(yytext); // const int length = strlen(yytext);
// for (int i = 0; i < length; ++i) { // for (int i = 0; i < length; ++i) {
// LogErrorRaw("[%d]", yytext[i]); // LogErrorRaw("[%d]", yytext[i]);
// } // }
// LogErrorRaw("\n\n"); // LogErrorRaw("\n\n");
} }
int ProgramGrammarAction(const int value) { int ProgramGrammarAction(const int value) {
// LogDebug("ProgramGrammarAction(%d)", value); // LogDebug("ProgramGrammarAction(%d)", value);
state.succeed = true; state.succeed = true;
state.result = value; state.result = value;
return value; return value;
} }
int AdditionExpressionGrammarAction(const int leftValue, const int rightValue) { int AdditionExpressionGrammarAction(const int leftValue, const int rightValue) {
LogDebug("AdditionExpressionGrammarAction(%d, %d)", leftValue, rightValue); LogDebug("AdditionExpressionGrammarAction(%d, %d)", leftValue, rightValue);
return Add(leftValue, rightValue); return Add(leftValue, rightValue);
} }
int SubtractionExpressionGrammarAction(const int leftValue, const int rightValue) { int SubtractionExpressionGrammarAction(const int leftValue, const int rightValue) {
LogDebug("SubtractionExpressionGrammarAction(%d, %d)", leftValue, rightValue); LogDebug("SubtractionExpressionGrammarAction(%d, %d)", leftValue, rightValue);
return Subtract(leftValue, rightValue); return Subtract(leftValue, rightValue);
} }
int MultiplicationExpressionGrammarAction(const int leftValue, const int rightValue) { int MultiplicationExpressionGrammarAction(const int leftValue, const int rightValue) {
LogDebug("MultiplicationExpressionGrammarAction(%d, %d)", leftValue, rightValue); LogDebug("MultiplicationExpressionGrammarAction(%d, %d)", leftValue, rightValue);
return Multiply(leftValue, rightValue); return Multiply(leftValue, rightValue);
} }
int DivisionExpressionGrammarAction(const int leftValue, const int rightValue) { int DivisionExpressionGrammarAction(const int leftValue, const int rightValue) {
LogDebug("DivisionExpressionGrammarAction(%d, %d)", leftValue, rightValue); LogDebug("DivisionExpressionGrammarAction(%d, %d)", leftValue, rightValue);
return Divide(leftValue, rightValue); return Divide(leftValue, rightValue);
} }
int FactorExpressionGrammarAction(const int value) { int FactorExpressionGrammarAction(const int value) {
LogDebug("FactorExpressionGrammarAction(%d)", value); LogDebug("FactorExpressionGrammarAction(%d)", value);
return value; return value;
} }
int ExpressionFactorGrammarAction(const int value) { int ExpressionFactorGrammarAction(const int value) {
LogDebug("ExpressionFactorGrammarAction(%d)", value); LogDebug("ExpressionFactorGrammarAction(%d)", value);
return value; return value;
} }
int ConstantFactorGrammarAction(const int value) { int ConstantFactorGrammarAction(const int value) {
LogDebug("ConstantFactorGrammarAction(%d)", value); LogDebug("ConstantFactorGrammarAction(%d)", value);
return value; return value;
} }
int IntegerConstantGrammarAction(const int value) { int IntegerConstantGrammarAction(const int value) {
LogDebug("IntegerConstantGrammarAction(%d)", value); LogDebug("IntegerConstantGrammarAction(%d)", value);
return value; return value;
} }

245
src/frontend/syntactic-analysis/bison-grammar.y
View File

@ -69,198 +69,185 @@
%% %%
program: statements { $$ = ProgramGrammarAction($1); } program: statements { $$ = ProgramGrammarAction($1); }
; ;
statement: evaluate SEMICOLON statement: evaluate SEMICOLON
| integrate SEMICOLON | integrate SEMICOLON
| derivative SEMICOLON | derivative SEMICOLON
| declare_function SEMICOLON | declare_function SEMICOLON
| if_statement | if_statement
| ifelse_statement | ifelse_statement
| for_statement | for_statement
| while_statement | while_statement
| printCSV SEMICOLON | printCSV SEMICOLON
| print SEMICOLON | print SEMICOLON
| declare_variable SEMICOLON | declare_variable SEMICOLON
| assign_variable SEMICOLON | assign_variable SEMICOLON
; ;
expression: positive_constant expression: positive_constant
| evaluate | evaluate
| integrate | integrate
| derivative | derivative
| STRING | STRING
| expression ADD expression | expression ADD expression
| expression SUB expression | expression SUB expression
| expression MUL expression | expression MUL expression
| expression DIV expression | expression DIV expression
| expression POW expression | expression POW expression
| OPEN_PARENTHESIS expression CLOSE_PARENTHESIS | OPEN_PARENTHESIS expression CLOSE_PARENTHESIS
| SUB expression | SUB expression
; ;
domain: expression LESSER expression domain: expression LESSER expression
| expression LESSER_EQUAL expression | expression LESSER_EQUAL expression
| expression GREATER expression | expression GREATER expression
| expression GREATER_EQUAL expression | expression GREATER_EQUAL expression
| expression EQUAL expression | expression EQUAL expression
| expression NOT_EQUAL expression | expression NOT_EQUAL expression
| expression LESSER expression LESSER expression | expression LESSER expression LESSER expression
| expression LESSER_EQUAL expression LESSER expression | expression LESSER_EQUAL expression LESSER expression
| expression LESSER expression LESSER_EQUAL expression | expression LESSER expression LESSER_EQUAL expression
| expression LESSER_EQUAL expression LESSER_EQUAL expression | expression LESSER_EQUAL expression LESSER_EQUAL expression
; ;
boolean: expression LESSER expression boolean: expression LESSER expression
| expression LESSER_EQUAL expression | expression LESSER_EQUAL expression
| expression GREATER expression | expression GREATER expression
| expression GREATER_EQUAL expression | expression GREATER_EQUAL expression
| expression EQUAL expression | expression EQUAL expression
| expression NOT_EQUAL expression | expression NOT_EQUAL expression
| boolean OR boolean | boolean OR boolean
| boolean AND boolean | boolean AND boolean
| OPEN_PARENTHESIS boolean CLOSE_PARENTHESIS | OPEN_PARENTHESIS boolean CLOSE_PARENTHESIS
| NOT boolean | NOT boolean
; ;
positive_constant: DOUBLE positive_constant: DOUBLE
| INTEGER | INTEGER
; ;
declare_function: FUNCTION STRING ASSIGN function declare_function: FUNCTION STRING ASSIGN function
| FUNCTION STRING ASSIGN OPEN_BRACES functions CLOSE_BRACES | FUNCTION STRING ASSIGN OPEN_BRACES functions CLOSE_BRACES
; ;
function: expression function: expression
| expression COLON domain | expression COLON domain
| composite | composite
| taylor | taylor
; ;
functions: function functions: function
| function COMMA functions | function COMMA functions
; ;
composite: STRING COMPOSITE STRING composite: STRING COMPOSITE STRING
| composite COMPOSITE STRING | composite COMPOSITE STRING
; ;
expressions: expression expressions: expression
| expression COMMA expressions | expression COMMA expressions
; ;
strings: STRING strings: STRING
| STRING COMMA strings | STRING COMMA strings
; ;
numArray: OPEN_BRACKETS expressions CLOSE_BRACKETS numArray: OPEN_BRACKETS expressions CLOSE_BRACKETS
; ;
numArrays: numArray numArrays: numArray
| numArray COMMA numArrays | numArray COMMA numArrays
; ;
arrayNumArray: OPEN_BRACKETS numArrays CLOSE_BRACKETS arrayNumArray: OPEN_BRACKETS numArrays CLOSE_BRACKETS
; ;
stringArray: OPEN_BRACKETS strings CLOSE_BRACKETS stringArray: OPEN_BRACKETS strings CLOSE_BRACKETS
; ;
escapeString: ESCAPESTRING escapeString: ESCAPESTRING
| ESCAPESTRING ADD escapeString | ESCAPESTRING ADD escapeString
; ;
escapeStrings: escapeString escapeStrings: escapeString
| escapeString COMMA escapeStrings | escapeString COMMA escapeStrings
; ;
escapeStringArray: OPEN_BRACKETS escapeStrings CLOSE_BRACKETS escapeStringArray: OPEN_BRACKETS escapeStrings CLOSE_BRACKETS
; ;
evaluate: EVALUATE STRING IN OPEN_PARENTHESIS expression CLOSE_PARENTHESIS evaluate: EVALUATE STRING IN OPEN_PARENTHESIS expression CLOSE_PARENTHESIS
| EVALUATE STRING IN numArray | EVALUATE STRING IN numArray
| STRING OPEN_PARENTHESIS expression CLOSE_PARENTHESIS | STRING OPEN_PARENTHESIS expression CLOSE_PARENTHESIS
| EVALUATE stringArray IN OPEN_PARENTHESIS expression CLOSE_PARENTHESIS | EVALUATE stringArray IN OPEN_PARENTHESIS expression CLOSE_PARENTHESIS
| EVALUATE stringArray IN numArray | EVALUATE stringArray IN numArray
| stringArray OPEN_PARENTHESIS expression CLOSE_PARENTHESIS | stringArray OPEN_PARENTHESIS expression CLOSE_PARENTHESIS
; ;
integrate: INTEGRATE STRING BETWEEN OPEN_PARENTHESIS expression AND_INT expression CLOSE_PARENTHESIS integrate: INTEGRATE STRING BETWEEN OPEN_PARENTHESIS expression AND_INT expression CLOSE_PARENTHESIS
| INTEGRATE STRING OPEN_PARENTHESIS expression AND_INT expression CLOSE_PARENTHESIS | INTEGRATE STRING OPEN_PARENTHESIS expression AND_INT expression CLOSE_PARENTHESIS
| INTEGRATE stringArray BETWEEN OPEN_PARENTHESIS expression AND_INT expression CLOSE_PARENTHESIS | INTEGRATE stringArray BETWEEN OPEN_PARENTHESIS expression AND_INT expression CLOSE_PARENTHESIS
| INTEGRATE stringArray OPEN_PARENTHESIS expression AND_INT expression CLOSE_PARENTHESIS | INTEGRATE stringArray OPEN_PARENTHESIS expression AND_INT expression CLOSE_PARENTHESIS
| integrate ERR positive_constant | integrate ERR positive_constant
; ;
squotes: SQUOTE squotes: SQUOTE
| SQUOTE squotes | SQUOTE squotes
; ;
print: PRINT OPEN_PARENTHESIS expression CLOSE_PARENTHESIS print: PRINT OPEN_PARENTHESIS expression CLOSE_PARENTHESIS
| PRINT OPEN_PARENTHESIS escapeString CLOSE_PARENTHESIS | PRINT OPEN_PARENTHESIS escapeString CLOSE_PARENTHESIS
; ;
statements: statement statements: statement
| statement statements | statement statements
; ;
derivative: DERIVATIVE STRING IN OPEN_PARENTHESIS expression CLOSE_PARENTHESIS derivative: DERIVATIVE STRING IN OPEN_PARENTHESIS expression CLOSE_PARENTHESIS
| DERIVATIVE INTEGER STRING IN OPEN_PARENTHESIS expression CLOSE_PARENTHESIS | DERIVATIVE INTEGER STRING IN OPEN_PARENTHESIS expression CLOSE_PARENTHESIS
| STRING squotes OPEN_PARENTHESIS expression CLOSE_PARENTHESIS | STRING squotes OPEN_PARENTHESIS expression CLOSE_PARENTHESIS
| DERIVATIVE stringArray IN OPEN_PARENTHESIS expression CLOSE_PARENTHESIS | DERIVATIVE stringArray IN OPEN_PARENTHESIS expression CLOSE_PARENTHESIS
| DERIVATIVE INTEGER stringArray IN OPEN_PARENTHESIS expression CLOSE_PARENTHESIS | DERIVATIVE INTEGER stringArray IN OPEN_PARENTHESIS expression CLOSE_PARENTHESIS
| stringArray squotes OPEN_PARENTHESIS expression CLOSE_PARENTHESIS | stringArray squotes OPEN_PARENTHESIS expression CLOSE_PARENTHESIS
| derivative ERR positive_constant | derivative ERR positive_constant
; ;
if_statement: IF OPEN_PARENTHESIS boolean CLOSE_PARENTHESIS OPEN_BRACKETS statements CLOSE_BRACKETS if_statement: IF OPEN_PARENTHESIS boolean CLOSE_PARENTHESIS OPEN_BRACKETS statements CLOSE_BRACKETS
| IF OPEN_PARENTHESIS boolean CLOSE_PARENTHESIS statement | IF OPEN_PARENTHESIS boolean CLOSE_PARENTHESIS statement
; ;
ifelse_statement: if_statement ELSE OPEN_BRACKETS statements CLOSE_BRACKETS ifelse_statement: if_statement ELSE OPEN_BRACKETS statements CLOSE_BRACKETS
| ELSE statement | ELSE statement
; ;
for_statement: FOR OPEN_PARENTHESIS declare_variable SEMICOLON boolean SEMICOLON assign_variable CLOSE_PARENTHESIS OPEN_BRACKETS statements CLOSE_BRACKETS for_statement: FOR OPEN_PARENTHESIS declare_variable SEMICOLON boolean SEMICOLON assign_variable CLOSE_PARENTHESIS OPEN_BRACKETS statements CLOSE_BRACKETS
| FOR OPEN_PARENTHESIS SEMICOLON boolean SEMICOLON assign_variable CLOSE_PARENTHESIS OPEN_BRACKETS statements CLOSE_BRACKETS | FOR OPEN_PARENTHESIS SEMICOLON boolean SEMICOLON assign_variable CLOSE_PARENTHESIS OPEN_BRACKETS statements CLOSE_BRACKETS
| FOR OPEN_PARENTHESIS declare_variable SEMICOLON boolean SEMICOLON assign_variable CLOSE_PARENTHESIS statement | FOR OPEN_PARENTHESIS declare_variable SEMICOLON boolean SEMICOLON assign_variable CLOSE_PARENTHESIS statement
| FOR OPEN_PARENTHESIS SEMICOLON boolean SEMICOLON assign_variable CLOSE_PARENTHESIS statement | FOR OPEN_PARENTHESIS SEMICOLON boolean SEMICOLON assign_variable CLOSE_PARENTHESIS statement
; ;
taylor: TAYLOR INTEGER STRING taylor: TAYLOR INTEGER STRING
; ;
while_statement: WHILE OPEN_PARENTHESIS boolean CLOSE_PARENTHESIS OPEN_BRACKETS statements CLOSE_BRACKETS while_statement: WHILE OPEN_PARENTHESIS boolean CLOSE_PARENTHESIS OPEN_BRACKETS statements CLOSE_BRACKETS
| WHILE OPEN_PARENTHESIS boolean CLOSE_PARENTHESIS statement | WHILE OPEN_PARENTHESIS boolean CLOSE_PARENTHESIS statement
; ;
declare_variable: VAR STRING declare_variable: VAR STRING
| declare_variable ASSIGN expression | declare_variable ASSIGN expression
; ;
printCSV: PRINTCSV OPEN_PARENTHESIS escapeStringArray COMMA arrayNumArray COMMA escapeString CLOSE_PARENTHESIS printCSV: PRINTCSV OPEN_PARENTHESIS escapeStringArray COMMA arrayNumArray COMMA escapeString CLOSE_PARENTHESIS
; ;
/* expression: positive_constant
| evaluate
| integrate
| derivative
| expression ADD expression
| expression DIV expression
| expression SUB expression
| expression POW expression
| expression MUL expression
| SUB expression
| OPEN_PARENTHESIS expression CLOSE_PARENTHESIS
; */
assign_variable: STRING ADD_ASSIGN expression assign_variable: STRING ADD_ASSIGN expression
| STRING SUB_ASSIGN expression | STRING SUB_ASSIGN expression
| STRING MUL_ASSIGN expression | STRING MUL_ASSIGN expression
| STRING DIV_ASSIGN expression | STRING DIV_ASSIGN expression
| STRING INCREMENT | STRING INCREMENT
| STRING DECREMENT | STRING DECREMENT
| STRING ASSIGN expression | STRING ASSIGN expression
; ;
%% %%

70
src/main.c
View File

@ -10,42 +10,42 @@ CompilerState state;
// Punto de entrada principal del compilador. // Punto de entrada principal del compilador.
const int main(const int argumentCount, const char ** arguments) { const int main(const int argumentCount, const char ** arguments) {
// #ifdef YYDEBUG // #ifdef YYDEBUG
// yydebug = 1; // yydebug = 1;
// #endif // #endif
// Inicializar estado de la aplicación. // Inicializar estado de la aplicación.
state.result = 0; state.result = 0;
state.succeed = false; state.succeed = false;
// Mostrar parámetros recibidos por consola. // Mostrar parámetros recibidos por consola.
for (int i = 0; i < argumentCount; ++i) { for (int i = 0; i < argumentCount; ++i) {
LogInfo("Argumento %d: '%s'", i, arguments[i]); LogInfo("Argumento %d: '%s'", i, arguments[i]);
} }
// Compilar el programa de entrada. // Compilar el programa de entrada.
LogInfo("Compilando...\n"); LogInfo("Compilando...\n");
const int result = yyparse(); const int result = yyparse();
switch (result) { switch (result) {
case 0: case 0:
if (state.succeed) { if (state.succeed) {
LogInfo("La compilacion fue exitosa."); LogInfo("La compilacion fue exitosa.");
// Generator(state.result); // Generator(state.result);
} }
else { else {
LogError("Se produjo un error en la aplicacion."); LogError("Se produjo un error en la aplicacion.");
return -1; return -1;
} }
break; break;
case 1: case 1:
LogError("Bison finalizo debido a un error de sintaxis."); LogError("Bison finalizo debido a un error de sintaxis.");
break; break;
case 2: case 2:
LogError("Bison finalizo abruptamente debido a que ya no hay memoria disponible."); LogError("Bison finalizo abruptamente debido a que ya no hay memoria disponible.");
break; break;
default: default:
LogError("Error desconocido mientras se ejecutaba el analizador Bison (codigo %d).", result); LogError("Error desconocido mientras se ejecutaba el analizador Bison (codigo %d).", result);
} }
LogInfo("Fin."); LogInfo("Fin.");
return result; return result;
} }