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

Fix bugs 

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-06-22 23:18:53 -03:00
parent 598d7b1d49
commit 7e07b851ab
12 changed files with 6 additions and 489 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
README.md
View File

@ -33,6 +33,7 @@ Se recomienda usar `pip` para instalar `SymPy`:
```bash
pip install --user sympy==1.5.1
export PATH="$PATH:$HOME/.local/bin"
```
Luego, debe instalar `symbolic` en octave corriendo:

81
main.c
View File

@ -1,81 +0,0 @@
#include <math.h>
#include <stdio.h>
long fact(int n) {
if (n == 0) {
return 1;
} else {
return n * fact(n-1);
}
}
double Differentiate(double f(double x), double x, double h, int grade) {
double sum = 0;
for (int i = 0; i <= grade; i++) {
printf("%g %d %g %g\n", h, grade, pow(h, 4), pow(h, grade));
// printf("%d %f %f %f %g\n", i, sum, fact(grade) / (fact(i) * fact(grade - i)), f(x + (double) i * h), pow(h, grade));
sum += pow(-1, grade - i) * (fact(grade) / (fact(i) * fact(grade - i))) * f(x + (double) i * h) / pow(h, grade);
}
return sum;
}
double f(double x) {
return x*x*x*x*x - x/(2-x*x);
}
double SimpsonsRule(double f(double x), double a, double b, int errGrade) {
int res = 0;
double der4;
double c, cmax;
for (c = a; c <= b; c += 0.1) {
der4 = Differentiate(f, c, sqrt(__DBL_EPSILON__), 4);
if (res < der4) {
res = der4;
cmax = c;
}
}
printf("%f\n", cmax);
double limit = pow(10, -errGrade), n = 1;
double h = fabs(b-a) / n;
double err = (b-a) * pow(h, 4) * res / 180;
while (err > limit) {
printf("%g %g\n", err, limit);
n++;
h = fabs(b-a) / n;
err = (b-a) * pow(h, 4) * res / (double) 180;
}
printf("%d", n);
// function s=simpson(f,a,b,n)
// h=(b-a)/n;
// y=[];for x=a:h:b;y=[y f(x)];end
// E=y(1)+y(end);
// P=sum(y(3:2:end-2)); Im=sum(y(2:2:end-1));
// s=(h/3)*(E+2*P+4*Im);
// end
double x, sum = 0;
int i = 0; // de 2 a n-1
while (i < n) {
x = a + i * h;
if (i % 2 == 0) {
sum += 2 * f(x);
} else {
sum += 4 * f(x);
}
i++;
}
return (h/3) * (f(a) + f(b) + sum);
}
double g(double x) {
return 1/(x*x*x) + x*x;
}
int main(void) {
// printf("%f", )
// printf("der %f\n", Differentiate(g, 1, pow(10, -1), 4));
// printf("der %f\n", );
// printf("culo %g", SimpsonsRule(g, 1, 8, 5));
}

294
src/backend/free-tree/free-tree.c
View File

@ -1,4 +1,3 @@
#include "../support/logger.h"
#include "free-tree.h"
MallocTable * table;
@ -25,296 +24,3 @@ void FreeMallocTable() {
free(table->elements);
free(table);
}
// void FreeDerivative(Derivative * derivative) {
// free(derivative->function);
// free(derivative->grade);
// FreeExpression(derivative->value);
// free(derivative);
// }
// void FreeIntegrate(Integrate * integrate) {
// free(integrate->function);
// FreeExpression(integrate->lvalue);
// FreeExpression(integrate->rvalue);
// if (integrate->error != NULL)
// free(integrate->error);
// free(integrate);
// }
// void FreeEvaluate(Evaluate * evaluate) {
// free(evaluate->function);
// FreeExpression(evaluate->value);
// free(evaluate);
// }
// void FreeExpression(Expression * expression) {
// switch (expression->type) {
// case DERIVATIVE_EXPRESSION:
// FreeDerivative(expression->derivative);
// break;
// case INTEGRATE_EXPRESSION:
// FreeIntegrate(expression->integrate);
// break;
// case EVALUATE_EXPRESSION:
// FreeEvaluate(expression->evaluate);
// break;
// case NEGATIVE_EXPRESSION:
// case PARENTHESIS_EXPRESSION:
// FreeExpression(expression->leftExpression);
// break;
// case NUMBER_EXPRESSION:
// break;
// case ADD_EXPRESSION:
// case SUB_EXPRESSION:
// case MUL_EXPRESSION:
// case DIV_EXPRESSION:
// case POW_EXPRESSION:
// FreeExpression(expression->leftExpression);
// FreeExpression(expression->rightExpression);
// break;
// case ID_EXPRESSION:
// free(expression->id);
// break;
// default:
// abort();
// }
// free(expression);
// }
// void FreeDomain(Domain * domain) {
// switch (domain->type) {
// case GREATER_DOMAIN:
// case GREATER_EQUAL_DOMAIN:
// case LESSER_EQUAL_DOMAIN:
// case LESSER_DOMAIN:
// case EQUAL_DOMAIN:
// case NOT_EQUAL_DOMAIN:
// FreeExpression(domain->left);
// FreeExpression(domain->right);
// break;
// case LESSER_LESSER_DOMAIN:
// case LESSER_LESSER_EQUAL_DOMAIN:
// case LESSER_EQUAL_LESSER_EQUAL_DOMAIN:
// case LESSER_EQUAL_LESSER_DOMAIN:
// // FreeExpression(domain->left);
// // FreeExpression(domain->mid);
// // FreeExpression(domain->right);
// break;
// default:
// abort();
// break;
// }
// free(domain);
// }
// void FreeDomainForFunction(Domain * domain) {
// switch (domain->type) {
// case GREATER_DOMAIN:
// case GREATER_EQUAL_DOMAIN:
// case LESSER_EQUAL_DOMAIN:
// case LESSER_DOMAIN:
// case EQUAL_DOMAIN:
// case NOT_EQUAL_DOMAIN:
// FreeExpression(domain->left);
// FreeExpression(domain->right);
// break;
// case LESSER_LESSER_DOMAIN:
// case LESSER_LESSER_EQUAL_DOMAIN:
// case LESSER_EQUAL_LESSER_EQUAL_DOMAIN:
// case LESSER_EQUAL_LESSER_DOMAIN:
// FreeExpression(domain->left);
// FreeExpression(domain->mid);
// FreeExpression(domain->right);
// break;
// }
// free(domain);
// }
// void FreeBoolean(Boolean * boolean) {
// switch (boolean->type) {
// case DOMAIN_BOOLEAN:
// FreeDomain(boolean->domain);
// break;
// case OR_BOOLEAN:
// case AND_BOOLEAN:
// FreeBoolean(boolean->left);
// FreeBoolean(boolean->right);
// break;
// case NOT_BOOLEAN:
// case BOOLEAN:
// FreeBoolean(boolean->left);
// break;
// default:
// abort();
// }
// free(boolean);
// }
// void FreeIf(If * if_st) {
// FreeBoolean(if_st->boolean);
// FreeBlock(if_st->block);
// if (if_st->else_block != NULL) {
// FreeBlock(if_st->else_block);
// }
// free(if_st);
// }
// void FreeFor(For * for_st) {
// if (for_st->init_variable != NULL)
// FreeDeclareVariable(for_st->init_variable);
// FreeBoolean(for_st->boolean);
// FreeAssignVariable(for_st->action_variable);
// FreeBlock(for_st->block);
// free(for_st);
// }
// void FreeBlock(Block * block) {
// Statement * statement = block->statement, * aux;
// while (statement != NULL) {
// aux = statement;
// statement = statement->next;
// FreeStatement(aux);
// }
// free(block);
// }
// void FreeDeclareVariable(Variable * variable) {
// free(variable->name);
// if (variable->value != NULL) {
// FreeExpression(variable->value);
// }
// free(variable);
// }
// void FreeAssignVariable(AssignVariable * variable) {
// switch (variable->type) {
// case INCREMENT_EXPRESSION:
// case DECREMENT_EXPRESSION:
// break;
// case ADD_ASSIGN_EXPRESSION:
// case SUB_ASSIGN_EXPRESSION:
// case MUL_ASSIGN_EXPRESSION:
// case DIV_ASSIGN_EXPRESSION:
// case ASSIGN_EXPRESSION:
// FreeExpression(variable->expression);
// break;
// default:
// abort();
// }
// free(variable->id);
// free(variable);
// }
// void FreePrint(Print * print_st) {
// switch (print_st->type) {
// case STRING_PRINT:
// free(print_st->string);
// break;
// case EXPRESSION_PRINT:
// FreeExpression(print_st->expression);
// break;
// default:
// abort();
// }
// free(print_st);
// }
// void FreeWhile(While * while_st) {
// FreeBoolean(while_st->boolean);
// FreeBlock(while_st->block);
// free(while_st);
// }
// void FreeCompositeFunction(Composite * composite) {
// switch (composite->type) {
// case ID_COMPOSITE:
// free(composite->inner_func);;
// break;
// case COMPOSITE_COMPOSITE:
// FreeCompositeFunction(composite->inner_comp);
// break;
// default:
// LogError("Invalid composite function");
// abort();
// }
// free(composite->outter_func);
// free(composite);
// }
// void FreeDeclareFunction(Function * function) {
// Function * currFunc = function;
// free(function->name);
// Function * aux;
// while (currFunc != NULL) {
// switch (currFunc->type) {
// case EXPRESSION_FUNCTION:
// FreeExpression(currFunc->expression);
// break;
// case EXPRESSION_DOMAIN_FUNCTION:
// FreeExpression(currFunc->expression);
// FreeDomainForFunction(currFunc->domain);
// break;
// case COMPOSITE_FUNCTION:
// FreeCompositeFunction(currFunc->composite);
// break;
// default:
// LogError("Incorrect function definition");
// abort();
// }
// aux = currFunc;
// currFunc = currFunc->next;
// free(aux);
// }
// }
// void FreeStatement(Statement * statement) {
// switch (statement->type) {
// case WHILE_STATEMENT:
// FreeWhile(statement->while_st);
// break;
// case FOR_STATEMENT:
// FreeFor(statement->for_st);
// break;
// case IF_STATEMENT:
// FreeIf(statement->if_st);
// break;
// case PRINT_STATEMENT:
// FreePrint(statement->print);
// break;
// case INTEGRATE_STATEMENT:
// FreeIntegrate(statement->integrate);
// break;
// case DERIVATIVE_STATEMENT:
// FreeDerivative(statement->derivative);
// break;
// case EVALUATE_STATEMENT:
// FreeEvaluate(statement->evaluate);
// break;
// case DECLARE_VARIABLE_STATEMENT:
// FreeDeclareVariable(statement->declareVariable);
// break;
// case ASSIGN_VARIABLE_STATEMENT:
// FreeAssignVariable(statement->assignVariable);
// break;
// case DECLARE_FUNCTION_STATEMENT:
// FreeDeclareFunction(statement->declareFunction);
// break;
// default:
// LogError("Invalid statement");
// abort();
// }
// free(statement);
// }
// void FreeTree(Program * program) {
// if (program == NULL)
// return;
// Statement * currStatement = program->statement, * aux;
// while (currStatement != NULL) {
// aux = currStatement;
// currStatement = currStatement->next;
// FreeStatement(aux);
// }
// }

15
src/backend/free-tree/free-tree.h
View File

@ -3,19 +3,6 @@
#include "../support/nodes.h"
void FreeTree(Program * program);
void FreeExpression(Expression * expression);
void FreeDomain(Domain * domain);
void FreeBoolean(Boolean * boolean);
void FreeIf(If * if_st);
void FreeDeclareVariable(Variable * variable);
void FreeAssignVariable(AssignVariable * variable);
void FreePrint(Print * print_st);
void FreeWhile(While * while_st);
void FreeStatement(Statement * statement);
void FreeBlock(Block * block);
#define DEFAULT_TABLE_SIZE 500
typedef struct MallocTable {
@ -28,4 +15,4 @@ void InitializeMallocTable();
void AddMalloc(void * pointer);
void FreeMallocTable();
#endif
#endif

2
src/backend/semantic-analysis/analyzer.h
View File

@ -6,4 +6,4 @@
bool Analyze(Program * program);
#endif
#endif

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

@ -2,10 +2,6 @@
#include <stdarg.h>
#include <stdio.h>
/**
* Implementación de "logger.h".
*/
void Log(FILE * const stream, const char * prefix, const char * const format, const char * suffix, va_list arguments) {
fprintf(stream, "%s", prefix);
vfprintf(stream, format, arguments);

11
src/backend/support/nodes.h
View File

@ -68,7 +68,6 @@ typedef struct Expression {
struct Expression * leftExpression;
struct Expression * rightExpression;
// struct Variable * variable;
struct Derivative * derivative;
struct Integrate * integrate;
struct Evaluate * evaluate;
@ -168,7 +167,6 @@ typedef struct Derivative {
char * function;
Expression * value;
int * grade;
double * error;
} Derivative;
typedef struct Evaluate {
@ -197,13 +195,6 @@ typedef struct Composite {
char * inner_func;
} Composite;
// typedef struct NumArray {
// Expression * expressions;
// size_t size;
// struct NumArray * next;
// } NumArray;
typedef enum {
ADD_ASSIGN_EXPRESSION,
SUB_ASSIGN_EXPRESSION,
@ -220,4 +211,4 @@ typedef struct AssignVariable {
Expression * expression;
} AssignVariable;
#endif
#endif

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

@ -13,20 +13,9 @@ extern void yyerror(const char * string);
extern int yylex(void);
extern int yyparse(void);
// typedef enum {
// false = 0,
// true = 1
// } boolean;
typedef struct {
bool succeed;
// Agregar una pila para almacenar tokens/nodos.
// Agregar un nodo hacia la raíz del árbol de sintaxis abstracta.
// Agregar una tabla de símbolos.
// ...
Program * program;
} CompilerState;
extern CompilerState state;

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

@ -4,62 +4,6 @@
#include "../../backend/support/shared.h"
#include "../syntactic-analysis/bison-parser.h"
// typedef enum TokenID {
// UNKNOWN = 0,
// YYUNDEF = 257,
// ADD,
// SUB,
// MUL,
// DIV,
// POW,
// FUNCTION,
// IF,
// ELSE,
// FOR,
// WHILE,
// PRINT,
// SEMICOLON,
// COMPOSITE,
// SQUOTE,
// DERIVATIVE,
// INTEGRATE,
// BETWEEN,
// AND_INT,
// EVALUATE,
// IN,
// OPEN_BRACES,
// OPEN_BRACKETS,
// CLOSE_BRACES,
// CLOSE_BRACKETS,
// OPEN_PARENTHESIS,
// CLOSE_PARENTHESIS,
// ASSIGN,
// EQUAL,
// AND,
// OR,
// NOT,
// ADD_ASSIGN,
// INCREMENT,
// SUB_ASSIGN,
// DECREMENT,
// MUL_ASSIGN,
// DIV_ASSIGN,
// DQUOTE,
// COMMA,
// COLON,
// LESSER,
// LESSER_EQUAL,
// GREATER,
// GREATER_EQUAL,
// NOT_EQUAL,
// VAR,
// ERR,
// ESCAPESTRING,
// DOUBLE,
// INTEGER,
// ID
// } TokenID;
int IntegerPatternAction(const char * lexeme);
int DoublePatternAction(const char * lexeme);
void IgnoredPatternAction();

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

@ -552,7 +552,6 @@ Print * PrintStringGrammarAction(char * string) {
print->type = STRING_PRINT;
print->string = malloc(strlen(string) + 1);
strcpy(print->string, string);
// free(string);
print->expression = NULL;
AddMalloc(print->string);
AddMalloc(print);
@ -653,17 +652,6 @@ Derivative * GradedDerivativeGrammarAction(int grade, char * id, Expression * ex
return derivative;
}
Derivative * ErroredDerivativeGrammarAction(Derivative * derivative, double error) {
if (derivative->error != 0) {
yyerror("ERR operand appears more than once");
abort();
}
derivative->error = malloc(sizeof(double));
AddMalloc(derivative->error);
*derivative->error = error;
return derivative;
}
// INTEGRATE
Integrate * IntegrateGrammarAction(char * id, Expression * lExp, Expression * rExp) {
@ -681,7 +669,8 @@ Integrate * IntegrateGrammarAction(char * id, Expression * lExp, Expression * rE
Integrate * ErroredIntegrateGrammarAction(Integrate * integrate, double error) {
if (integrate->error != 0) {
yyerror("ERR operand appears more than once");
abort();
FreeMallocTable();
exit(EXIT_FAILURE);
}
integrate->error = malloc(sizeof(double));
AddMalloc(integrate->error);
@ -809,7 +798,6 @@ char * EscapedStringGrammarAction(char * str) {
char * string = malloc(strlen(str) + 1);
AddMalloc(string);
strcpy(string, str);
// free(str);
return string;
}
@ -819,7 +807,5 @@ char * EscapedStringsGrammarAction(char * str1, char * str2) {
string[0] = 0;
strcat(string, str1);
strcat(string, str2);
// free(str1);
// free(str2);
return string;
}

1
src/frontend/syntactic-analysis/bison-actions.h
View File

@ -60,7 +60,6 @@ For * ForBlockNoVarGrammarAction(Boolean * boolean, AssignVariable * action_vari
Block * BlockGrammarAction(Statement * statement);
Derivative * SimpleDerivativeGrammarAction(char * id, Expression * expression);
Derivative * GradedDerivativeGrammarAction(int grade, char * id, Expression * expression);
Derivative * ErroredDerivativeGrammarAction(Derivative * derivative, double error);
Integrate * IntegrateGrammarAction(char * id, Expression * lExp, Expression * rExp);
Integrate * ErroredIntegrateGrammarAction(Integrate * integrate, double error);
Evaluate * EvaluateGrammarAction(char * id, Expression * expression);

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

@ -204,7 +204,6 @@ statements: statement
derivative: DERIVATIVE ID IN OPEN_PARENTHESIS expression CLOSE_PARENTHESIS { $$ = SimpleDerivativeGrammarAction($2, $5); }
| DERIVATIVE INTEGER ID IN OPEN_PARENTHESIS expression CLOSE_PARENTHESIS { $$ = GradedDerivativeGrammarAction($2, $3, $6); }
| derivative ERR positive_constant { $$ = ErroredDerivativeGrammarAction($1, $3); }
;
block: OPEN_BRACES statements CLOSE_BRACES { $$ = BlockGrammarAction($2); }