Beispiel #1
0
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;
}
Beispiel #2
0
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;
}
Beispiel #3
0
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;
}
Beispiel #4
0
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;
}
Beispiel #5
0
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;
}
Beispiel #6
0
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;
}
Beispiel #7
0
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;
}
Beispiel #8
0
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;
}
Beispiel #9
0
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;
}
Beispiel #10
0
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;
}
Beispiel #11
0
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;
}
Beispiel #12
0
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;
}
Beispiel #13
0
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;
}
Beispiel #14
0
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);
}
Beispiel #15
0
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;
}
Beispiel #16
0
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);
}
Beispiel #17
0
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;
}
Beispiel #18
0
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;
}
Beispiel #19
0
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;
}
Beispiel #20
0
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;
}
Beispiel #21
0
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;
}
Beispiel #22
0
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;
}
Beispiel #23
0
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;
}
Beispiel #24
0
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;
}
Beispiel #25
0
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;
}
Beispiel #26
0
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;
}
Beispiel #27
0
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;
}
Beispiel #28
0
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;
}
Beispiel #29
0
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;
}
Beispiel #30
0
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;
}