ast *nodo_nuevo_entero(long i) {
ast *a = (ast*)lat_asignar_memoria(sizeof(ast));
a->tipo = NODO_ENTERO;
nodo_valor *val = (nodo_valor*)lat_asignar_memoria(sizeof(nodo_valor));
val->t = VALOR_ENTERO;
val->v.i = i;
a->valor = val;
return a;
}
ast *nodo_nuevo_decimal(double d) {
ast *a = (ast*)lat_asignar_memoria(sizeof(ast));
a->tipo = NODO_DECIMAL;
nodo_valor *val = (nodo_valor*)lat_asignar_memoria(sizeof(nodo_valor));
val->t = VALOR_DECIMAL;
val->v.d = d;
a->valor = val;
return a;
}
ast *nodo_nuevo_cadena(const char *s) {
ast *a = (ast*)lat_asignar_memoria(sizeof(ast));
a->tipo = NODO_CADENA;
nodo_valor *val = (nodo_valor*)lat_asignar_memoria(sizeof(nodo_valor));
val->t = VALOR_CADENA;
val->v.s = parse_string(s, strlen(s));
a->valor = val;
return a;
}
ast *nodo_nuevo_logico(int b) {
ast *a = (ast*)lat_asignar_memoria(sizeof(ast));
a->tipo = NODO_LOGICO;
nodo_valor *val = (nodo_valor*)lat_asignar_memoria(sizeof(nodo_valor));
val->t = VALOR_LOGICO;
val->v.b = b;
a->valor = val;
return a;
}
ast *nodo_nuevo_literal(char *c) {
ast *a = (ast*)lat_asignar_memoria(sizeof(ast));
a->tipo = NODO_LITERAL;
nodo_valor *val = (nodo_valor*)lat_asignar_memoria(sizeof(nodo_valor));
val->t = VALOR_LITERAL;
a->valor = val;
//TODO: Pendiente de manipular literal
a->valor->v.c = parse_string(c, strlen(c));
return a;
}
ast *nodo_nuevo_identificador(const char *s) {
ast *a = (ast*)lat_asignar_memoria(sizeof(ast));
a->tipo = NODO_IDENTIFICADOR;
nodo_valor *val = (nodo_valor*)lat_asignar_memoria(sizeof(nodo_valor));
val->t = VALOR_CADENA;
val->v.s = strdup0(s);
a->valor = val;
a->valor->es_constante = false;
return a;
}
ast *nodo_nuevo_constante(char *s, int num_linea, int num_columna) {
ast *a = (ast*)lat_asignar_memoria(sizeof(ast));
a->tipo = NODO_IDENTIFICADOR;
nodo_valor *val = (nodo_valor*)lat_asignar_memoria(sizeof(nodo_valor));
val->t = VALOR_CADENA;
val->v.s = strdup0(s);
a->valor = val;
a->valor->es_constante = true;
a->valor->num_linea = num_linea;
a->valor->num_columna = num_columna;
return a;
}
list_node* lat_crear_lista()
{
list_node* start = (list_node*)lat_asignar_memoria(sizeof(list_node));
list_node* end = (list_node*)lat_asignar_memoria(sizeof(list_node));
start->prev = NULL;
start->next = end;
start->data = NULL;
end->prev = start;
end->next = NULL;
end->data = NULL;
return start;
}
ast *nodo_nuevo_cadena(const char *s, int num_linea, int num_columna)
{
ast *a = (ast*)lat_asignar_memoria(sizeof(ast));
a->tipo = NODO_CADENA;
nodo_valor *val = (nodo_valor*)lat_asignar_memoria(sizeof(nodo_valor));
val->t = VALOR_CADENA;
val->v.s = parse_string(s, strlen(s));
a->valor = val;
a->valor->es_constante = false;
a->valor->num_linea = num_linea;
a->valor->num_columna = num_columna;
return a;
}
ast *nodo_nuevo_literal(char *c, int num_linea, int num_columna)
{
ast *a = (ast*)lat_asignar_memoria(sizeof(ast));
a->tipo = NODO_LITERAL;
nodo_valor *val = (nodo_valor*)lat_asignar_memoria(sizeof(nodo_valor));
val->t = VALOR_LITERAL;
a->valor = val;
a->valor->v.c = parse_string(c, strlen(c));
a->valor->es_constante = false;
a->valor->num_linea = num_linea;
a->valor->num_columna = num_columna;
return a;
}
ast *nodo_nuevo_logico(int b, int num_linea, int num_columna)
{
ast *a = (ast*)lat_asignar_memoria(sizeof(ast));
a->tipo = NODO_LOGICO;
nodo_valor *val = (nodo_valor*)lat_asignar_memoria(sizeof(nodo_valor));
val->t = VALOR_LOGICO;
val->v.b = b;
a->valor = val;
a->valor->es_constante = false;
a->valor->num_linea = num_linea;
a->valor->num_columna = num_columna;
return a;
}
ast *nodo_nuevo_entero(long i, int num_linea, int num_columna)
{
ast *a = (ast*)lat_asignar_memoria(sizeof(ast));
a->tipo = NODO_ENTERO;
nodo_valor *val = (nodo_valor*)lat_asignar_memoria(sizeof(nodo_valor));
val->t = VALOR_ENTERO;
val->v.i = i;
a->valor = val;
a->valor->es_constante = false;
a->valor->num_linea = num_linea;
a->valor->num_columna = num_columna;
return a;
}
ast *nodo_nuevo_decimal(double d, int num_linea, int num_columna)
{
ast *a = (ast*)lat_asignar_memoria(sizeof(ast));
a->tipo = NODO_DECIMAL;
nodo_valor *val = (nodo_valor*)lat_asignar_memoria(sizeof(nodo_valor));
val->t = VALOR_DECIMAL;
val->v.d = d;
a->valor = val;
a->valor->es_constante = false;
a->valor->num_linea = num_linea;
a->valor->num_columna = num_columna;
return a;
}
lat_objeto *nodo_analizar_arbol(lat_vm *vm, ast *tree) {
lat_bytecode *bcode = (lat_bytecode *)lat_asignar_memoria(sizeof(lat_bytecode) * MAX_BYTECODE_FUNCTION);
int i = nodo_analizar(vm, tree, bcode, 0);
dbc(OP_END, 0, 0, NULL);
nodo_liberar(tree);
return lat_definir_funcion(vm, bcode);
}
hash_map* lat_clonar_hash(lat_vm* vm, hash_map* h)
{
int c = 0;
hash_map* ret = make_hash_map();
list_node* l;
for (c = 0; c < 256; ++c) {
l = h->buckets[c];
if (l != NULL) {
ret->buckets[c] = lat_crear_lista();
if (l != NULL) {
list_node* cur;
for (cur = l->next; cur != NULL; cur = cur->next) {
if (cur->data != NULL) {
hash_val* hv = (hash_val*)lat_asignar_memoria(sizeof(hash_val));
//vm->memory_usage += sizeof(hash_val);
strncpy(hv->key, ((hash_val*)cur->data)->key, 256);
hv->val = lat_clonar_objeto(vm, (lat_objeto*)((hash_val*)cur->data)->val);
insert_list(ret->buckets[c], hv);
}
}
}
}
}
return ret;
}
void set_hash(hash_map *m, char *key, void *val)
{
hash_val *hv = (hash_val *)lat_asignar_memoria(sizeof(hash_val));
strncpy(hv->key, key, (strlen(key)+1));
hv->val = val;
int hk = hash(key);
if (m->buckets[hk] == NULL)
{
m->buckets[hk] = lat_crear_lista();
}
else
{
list_node *c;
for (c = m->buckets[hk]; c->next != NULL; c = c->next)
{
if (c->data != NULL)
{
if (strcmp(((hash_val *)c->data)->key, key) == 0)
{
free(c->data);
c->data = (void *)hv;
return;
}
}
}
}
insert_list(m->buckets[hk], (void *)hv);
}
lat_objeto* lat_crear_objeto(lat_vm* vm)
{
lat_objeto* ret = (lat_objeto*)lat_asignar_memoria(sizeof(lat_objeto));
ret->type = T_NULO;
ret->data_size = 0;
return ret;
}
ast *nodo_nuevo_funcion(ast *s, ast *syms, ast *func) {
ast *a = (ast*)lat_asignar_memoria(sizeof(ast));
a->tipo = NODO_ASIGNACION;
a->l = nodo_nuevo(NODO_FUNCION_USUARIO, syms, func);
a->r = s;
a->valor = NULL;
return a;
}
ast *nodo_nuevo_hacer(ast *cond, ast *stmts) {
ast *a = (ast*)lat_asignar_memoria(sizeof(ast));
a->tipo = NODO_HACER;
a->l = cond;
a->r = stmts;
a->valor = NULL;
return a;
}
ast *nodo_nuevo_mientras(ast *cond, ast *stmts) {
ast *a = (ast*)lat_asignar_memoria(sizeof(ast));
a->tipo = NODO_MIENTRAS;
a->l = cond;
a->r = stmts;
a->valor = NULL;
return a;
}
ast *nodo_nuevo_si(ast *cond, ast *th, ast *el) {
nodo_si *a = (nodo_si*)lat_asignar_memoria(sizeof(nodo_si));
a->tipo = NODO_SI;
a->cond = cond;
a->th = th;
a->el = el;
return (ast *)a;
}
ast *nodo_nuevo_asignacion_lista(ast *exp, ast *id, ast *pos) {
nodo_lista_elem *a = (nodo_lista_elem*)lat_asignar_memoria(sizeof(nodo_lista_elem));
a->tipo = NODO_LISTA_ASIGNAR_ELEMENTO;
a->exp = exp;
a->id = id;
a->pos = pos;
return (ast *)a;
}
ast *nodo_nuevo_asignacion(ast *v, ast *s) {
ast *a = (ast*)lat_asignar_memoria(sizeof(ast));
a->tipo = NODO_ASIGNACION;
a->l = v;
a->r = s;
a->valor = NULL;
return a;
}
ast *nodo_nuevo(nodo_tipo nt, ast *l, ast *r) {
ast *a = (ast*)lat_asignar_memoria(sizeof(ast));
a->tipo = nt;
a->l = l;
a->r = r;
a->valor = NULL;
return a;
}
ast *nodo_nuevo_desde(ast *dec, ast *cond, ast *inc, ast *stmts) {
ast *a = (ast*)lat_asignar_memoria(sizeof(ast));
a->tipo = NODO_BLOQUE;
a->l = nodo_nuevo_mientras(cond, nodo_nuevo(NODO_BLOQUE, inc, stmts));
a->r = dec;
a->valor = NULL;
return a;
}
char* parse_string(const char* s, size_t len)
{
char* ret = lat_asignar_memoria(len + 1);
int i = 0;
int j = 0;
int c = '@';
for (i = 0; i < len; i++)
{
switch (s[i])
{
case '\\':
{
switch (s[i + 1])
{
case 'a':
c = '\n';
i++;
goto save;
case 'b':
c = '\n';
i++;
goto save;
case 'f':
c = '\n';
i++;
goto save;
case 'n':
c = '\n';
i++;
goto save;
case 'r':
c = '\n';
i++;
goto save;
case 't':
c = '\t';
i++;
goto save;
case 'v':
c = '\n';
i++;
goto save;
default:
break;
}
}
break;
default:
c = s[i];
break;
}
save:
ret[j] = c;
j++;
}
ret[j] = '\0';
return ret;
}
ast* nodo_nuevo_incluir(ast* ruta)
{
ast *a = (ast*)lat_asignar_memoria(sizeof(ast));
a->tipo = NODO_INCLUIR;
a->l = ruta;
a->r = NULL;
a->valor = NULL;
return a;
}
void insert_list(list_node* l, void* data)
{
list_node* ins = (list_node*)lat_asignar_memoria(sizeof(list_node));
ins->data = data;
ins->next = l->next;
l->next = ins;
ins->next->prev = ins;
ins->prev = l;
}
ast *nodo_nuevo_asignacion_dicc_elem(ast *exp, ast *id, ast *llave)
{
nodo_lista_elem *a = (nodo_lista_elem*)lat_asignar_memoria(sizeof(nodo_lista_elem));
a->tipo = NODO_DICC_ASIGNAR_ELEMENTO;
a->exp = exp;
a->id = id;
a->pos = llave;
return (ast *)a;
}
hash_map* make_hash_map()
{
hash_map* ret = (hash_map*)lat_asignar_memoria(sizeof(hash_map));
int c;
for (c = 0; c < 256; c++)
{
ret->buckets[c] = NULL;
}
return ret;
}