Exemple #1
0
inline optional get_sym(table *t, char *id) {
    if (*id == '$') {
        return arr_get(t->tmps, (unsigned) atoi(&id[1]));
    } else if (isdigit(*id) || *id == '.') {
        unsigned idx;
        optional opt;
        for (idx = 0; idx < arr_size(t->lits); idx++) {
            if (strcmp(((sym *) (opt = arr_get(t->lits, idx)).val)->id, id) == 0) {
                return opt;
            }
        }

        opt.e = false;
        opt.err = element_not_found;
        return opt;
    } else {
        unsigned idx;
        optional opt;
        for (idx = 0; idx < arr_size(t->syms); idx++) {
            if (cmp((opt = arr_get(t->syms, idx)).val, id)) {
                return opt;
            }
        }

        opt.e = false;
        opt.err = element_not_found;
        return opt;
    }
}
Exemple #2
0
static void new_void__arr_add(void **state)
{
    arr_t * arr = arr_new(5);
    assert_int_equal(arr_add(arr, 3, 10), 0);
    assert_int_equal(arr_add(arr, 6, 10), 1);
    int elem = 0;
    assert_int_equal(arr_get(arr, 3, &elem), 1);
    assert_int_equal(elem, 10);
    assert_int_equal(arr_get(arr, 37, &elem), 0);
    arr_remove(&arr);
}
Exemple #3
0
char is_close(compiler_wrapper *cw, int idx)
{
    lky_object *o = arr_get(&cw->rops, idx);
    lky_instruction istr = OBJ_NUM_UNWRAP(o);

    return istr == LI_LOAD_CLOSE || istr == LI_SAVE_CLOSE;
}
Exemple #4
0
char switch_to_close(compiler_wrapper *cw, char *sid, int idx)
{
    lky_object *o = arr_get(&cw->rops, idx);
    lky_instruction istr = OBJ_NUM_UNWRAP(o);

    if(istr == LI_LOAD_CLOSE || istr == LI_SAVE_CLOSE)
        return 0;

    istr = istr == LI_LOAD_LOCAL ? LI_LOAD_CLOSE : LI_SAVE_CLOSE;

    cw->rops.items[idx] = lobjb_build_int(istr);
    char *nsid = malloc(strlen(sid) + 1);
    strcpy(nsid, sid);

    int i = find_prev_name(cw, nsid);
    if(i < 0)
    {
        i = (int)cw->rnames.count;
        arr_append(&cw->rnames, nsid);
    }

    unsigned char buf[4];
    int_to_byte_array(buf, i);

    cw->rops.items[idx + 1] = lobjb_build_int(buf[0]);
    cw->rops.items[idx + 2] = lobjb_build_int(buf[1]);
    cw->rops.items[idx + 3] = lobjb_build_int(buf[2]);
    cw->rops.items[idx + 4] = lobjb_build_int(buf[3]);
    return 1;
}
Exemple #5
0
int ty_class_implements_interface(EagleComplexType *type, EagleComplexType *interface)
{
    while(type->type == ETPointer)
        type = ET_POINTEE(type);

    while(interface->type == ETPointer)
        interface = ET_POINTEE(interface);

    EagleStructType *st = (EagleStructType *)type;

    Arraylist *ifcs = &st->interfaces;
    EagleInterfaceType *ie = (EagleInterfaceType *)interface;

    int j;
    for(j = 0; j < ie->names.count; j++)
    {
        int good = 0;
        char *name = arr_get(&ie->names, j);
        int i;
        for(i = 0; i < ifcs->count; i++)
        {
            if(strcmp(ifcs->items[i], name) == 0)
                good = 1;
        }

        if(!good)
            return 0;
    }

    return 1;
}
Exemple #6
0
inline optional create_sym(table *t, char *id, value val) {
    optional opt;
    if (isdigit(*id) || *id == '.') {
        sym *s = malloc(sizeof(sym));
        memset(s, 0, sizeof(sym));
        strcpy(s->id, id);
        s->val = val;
        opt.e = true;
        opt.val = s;

        unsigned idx;
        unsigned n = arr_size(t->lits);
        for (idx = 0; idx < n; idx++) {
            if (strcmp(((sym *) arr_get(t->lits, idx).val)->id, id) == 0) {
                break;
            }
        }
        if (idx >= n) {
            arr_push(t->lits, s);
        }
    } else {
        unsigned idx;
        opt.e = true;
        for (idx = 0; idx < arr_size(t->syms); idx++) {
            if (strcmp(((sym *) (opt = arr_get(t->syms, idx)).val)->id, id) == 0) {
                opt.e = false;
                opt.err = element_not_found;
            }
        }

        if (opt.e) {
            sym *s = malloc(sizeof(sym));
            memset(s, 0, sizeof(sym));
            strcpy(s->id, id);

            s->val = val;
            opt.val = s;
            arr_push(t->syms, s);
        }
    }

    return opt;
}
Exemple #7
0
void compile_class_decl(compiler_wrapper *cw, ast_node *root)
{
    ast_class_decl_node *node = (ast_class_decl_node *)root;

    arraylist list = arr_create(10);
    ast_node *member = node->members->next;
    for(; member; member = member->next)
    {
        ast_class_member_node *m = (ast_class_member_node *)member;
        //append_op(cw, m->prefix);
        compile(cw, m->payload);
        arr_append(&list, member);
    }

    int init_flag = 0;

    if(node->super)
    {
        compile(cw, node->super);
        init_flag |= 2;
    }
    if(node->init)
    {
        compile(cw, ((ast_class_member_node *)node->init)->payload);
        init_flag |= 1;
    }

    append_op(cw, LI_MAKE_CLASS, node->lineno);
    append_op(cw, list.count, node->lineno);
    append_op(cw, init_flag, node->lineno);
    int i;
    for(i = list.count - 1; i >= 0; i--)
    {
        ast_class_member_node *m = (ast_class_member_node *)arr_get(&list, i);
        append_op(cw, m->prefix, node->lineno);
        
        long idx = find_prev_name(cw, m->name);

        if(idx < 0)
        {
            idx = cw->rnames.count;
            char *nid = malloc(strlen(m->name) + 1);
            strcpy(nid, m->name);
            arr_append(&cw->rnames, nid);
        }

        unsigned char buf[4];
        int_to_byte_array(buf, idx);

        append_op(cw, buf[0], node->lineno);
        append_op(cw, buf[1], node->lineno);
        append_op(cw, buf[2], node->lineno);
        append_op(cw, buf[3], node->lineno);
    }
}
Exemple #8
0
// Generic break/continue compilation
void compile_one_off(compiler_wrapper *cw, ast_node *root)
{
    ast_one_off_node *node = (ast_one_off_node *)root;
    long jix = -1;

    switch(node->opt)
    {
        case 'c':
            jix = OBJ_NUM_UNWRAP(arr_get(&cw->loop_start_stack, cw->loop_start_stack.count - 1));
            break;
        case 'b':
            jix = OBJ_NUM_UNWRAP(arr_get(&cw->loop_end_stack, cw->loop_end_stack.count - 1));
            break;
    }

    append_op(cw, LI_JUMP, node->lineno);
    append_op(cw, jix, node->lineno);
    append_op(cw, -1, node->lineno);
    append_op(cw, -1, node->lineno);
    append_op(cw, -1, node->lineno);
}
Exemple #9
0
// Used to find and reuse previous constants.
long find_prev_const(compiler_wrapper *cw, lky_object *obj)
{
    long i;
    for(i = 0; i < cw->rcon.count; i++)
    {
        lky_object *o = arr_get(&cw->rcon, i);
        if(lobjb_quick_compare(obj, o))
            return i;
    }

    return -1;
}
Exemple #10
0
// Used to lookup and reuse previous names/identifiers
int find_prev_name(compiler_wrapper *cw, char *name)
{
    long i;
    for(i = 0; i < cw->rnames.count; i++)
    {
        char *n = arr_get(&cw->rnames, i);
        if(strcmp(name, n) == 0)
            return (int)i;
    }
    
    return -1;
}
Exemple #11
0
long *finalize_indices(compiler_wrapper *cw)
{
    long *idcs = malloc(cw->rindices.count * sizeof(long));

    long i;
    for(i = 0; i < cw->rindices.count; i++)
    {
        lky_object_builtin *obj = arr_get(&cw->rindices, i);
        idcs[i] = (long)(OBJ_NUM_UNWRAP(obj));
    }

    return idcs;
}
Exemple #12
0
// Converts the arraylist 'rops' referenced in 'cw'
// into an unsigned char array. Note that we are 
// downcasting from a long to an unsigned char.
// We need to make sure everything makes sense
// *before* this step.
unsigned char *finalize_ops(compiler_wrapper *cw)
{
    unsigned char *ops = malloc(cw->rops.count);

    long i;
    for(i = 0; i < cw->rops.count; i++)
    {
        lky_object_builtin *obj = arr_get(&cw->rops, i);
        ops[i] = (unsigned char)(OBJ_NUM_UNWRAP(obj));
    }

    return ops;
}
Exemple #13
0
void compile_object_simple(compiler_wrapper *cw, ast_object_decl_node *node)
{
    int ct = 0;
    ast_node *list = node->payload;
    arraylist names = arr_create(20);
    for(; list; list = list->next)
    {
        arr_append(&names, ((ast_value_node *)list)->value.s);
        list = list->next;
        compile(cw, list);
        ct++;
    }

    if(node->obj)
        compile(cw, node->obj);
    else
        append_op(cw, LI_PUSH_NEW_OBJECT, node->lineno);

    unsigned char buf[4];
    int_to_byte_array(buf, ct);

    append_op(cw, LI_MAKE_OBJECT, node->lineno);
    append_op(cw, buf[0], node->lineno);
    append_op(cw, buf[1], node->lineno);
    append_op(cw, buf[2], node->lineno);
    append_op(cw, buf[3], node->lineno);

    int i;
    for(i = ct - 1; i >= 0; i--)
    {
        char *sid = arr_get(&names, i);
        char *nsid = malloc(strlen(sid) + 1);
        strcpy(nsid, sid);

        int i = find_prev_name(cw, nsid);
        if(i < 0)
        {
            i = (int)cw->rnames.count;
            arr_append(&cw->rnames, nsid);
        }

        unsigned char buf[4];
        int_to_byte_array(buf, i);
        append_op(cw, buf[0], node->lineno);
        append_op(cw, buf[1], node->lineno);
        append_op(cw, buf[2], node->lineno);
        append_op(cw, buf[3], node->lineno);
    }

    arr_free(&names);
}
Exemple #14
0
char *ty_interface_for_method(EagleComplexType *ett, char *method)
{
    EagleInterfaceType *it = (EagleInterfaceType *)ett;
    Arraylist *names = &it->names;

    int i;
    for(i = 0; i < names->count; i++)
    {
        char *name = arr_get(names, i);
        if(ty_method_lookup(name, method))
            return name;
    }

    return NULL;
}
Exemple #15
0
static void
avl_clear_intern (avl_t avl, int free_data)
{
  arr_t arr;
  avl_entry_t curr;
  size_t size;

  /* Create a new array to be used as a stack */
  arr = arr_init ();

  /* Iterate over every node */
  arr_insert_back (arr, avl->root);
  while ((size = arr_size (arr)) > 0)
    {
      /* Get the current element from the stack */
      curr = (avl_entry_t) arr_get (arr, size-1);
      arr_remove (arr, size-1);

      /* Check for invalid nodes */
      if (curr == NULL)
	continue;

      /* Push children onto the stack */
      arr_insert_back (arr, curr->left);
      arr_insert_back (arr, curr->right);

      /* Free parent */
      if (free_data && curr->data != NULL)
	free (curr->data);
      avl->free (curr->key);
      free (curr);
    }

  /* Cleanup the array */
  arr_destroy (arr);

  /* Update AVL Struct */
  avl->size = 0;
  avl->root = NULL;

  return;
}
Exemple #16
0
void append_var_info(compiler_wrapper *cw, char *ch, char load, int lineno)
{
    char needs_close = cw->repl;
    char already_defined = 0;
    arraylist list = cw->used_names;
    int i;
    for(i = 0; i < list.count; i++)
    {
        name_wrapper *w = arr_get(&cw->used_names, i);
        
        if(strcmp(w->name, ch))
            continue;   

        if(w->owner != cw)
        {
            switch_to_close(w->owner, ch, w->idx);
            needs_close = 1;
        }
        else
        {
            needs_close = is_close(cw, w->idx);
            already_defined = 1;
        }
    }

    if(!needs_close && !already_defined && load)
        needs_close = 1;

    if(needs_close)
    {
        lky_instruction istr = load ? LI_LOAD_CLOSE : LI_SAVE_CLOSE;
        char *nsid = malloc(strlen(ch) + 1);
        strcpy(nsid, ch);

        int i = find_prev_name(cw, nsid);
        if(i < 0)
        {
            i = (int)cw->rnames.count;
            arr_append(&cw->rnames, nsid);
        }

        append_op(cw, istr, lineno);
        unsigned char buf[4];
        int_to_byte_array(buf, i);
        append_op(cw, buf[0], lineno);
        append_op(cw, buf[1], lineno);
        append_op(cw, buf[2], lineno);
        append_op(cw, buf[3], lineno);

        return;
    }

    lky_instruction istr = load ? LI_LOAD_LOCAL : LI_SAVE_LOCAL;
    hm_error_t err;
    
    int idx = 0;
    lky_object_builtin *o = hm_get(&cw->saved_locals, ch, &err);
    if(err == HM_KEY_NOT_FOUND)
    {
        idx = get_next_local(cw);
        lky_object *obj = lobjb_build_int(idx);
        pool_add(&ast_memory_pool, obj);
        hm_put(&cw->saved_locals, ch, obj);
    }
    else
        idx = OBJ_NUM_UNWRAP(o);

    append_op(cw, istr, lineno);
    unsigned char buf[4];
    int_to_byte_array(buf, idx);
    append_op(cw, buf[0], lineno);
    append_op(cw, buf[1], lineno);
    append_op(cw, buf[2], lineno);
    append_op(cw, buf[3], lineno);

    name_wrapper *wrap = malloc(sizeof(name_wrapper));
    pool_add(&ast_memory_pool, wrap);
    wrap->idx = cw->rops.count - 5;
    wrap->name = ch;
    wrap->owner = cw;
    arr_append(&cw->used_names, wrap);
}
Exemple #17
0
void compile_object(compiler_wrapper *cw, ast_node *n)
{
    ast_object_decl_node *node = (ast_object_decl_node *)n;

    if(!node->refname)
        return compile_object_simple(cw, node);

    arraylist name_list = cw->used_names;
    int i;
    for(i = 0; i < name_list.count; i++)
    {
        name_wrapper *w = arr_get(&cw->used_names, i);
        
        if(strcmp(w->name, node->refname))
            continue;   

        switch_to_close(cw, node->refname, w->idx);
    }

    int ct = 0;
    ast_node *list = node->payload;
    arraylist names = arr_create(20);
    for(; list; list = list->next)
    {
        arr_append(&names, ((ast_value_node *)list)->value.s);
        list = list->next;
        compile(cw, list);
        ct++;
    }

    char *nsid = malloc(strlen(node->refname) + 1);
    strcpy(nsid, node->refname);

    i = find_prev_name(cw, nsid);
    if(i < 0)
    {
        i = (int)cw->rnames.count;
        arr_append(&cw->rnames, nsid);
    }

    append_op(cw, LI_LOAD_CLOSE, node->lineno);
    unsigned char buf[4];
    int_to_byte_array(buf, i);
    append_op(cw, buf[0], node->lineno);
    append_op(cw, buf[1], node->lineno);
    append_op(cw, buf[2], node->lineno);
    append_op(cw, buf[3], node->lineno);


    int_to_byte_array(buf, ct);

    append_op(cw, LI_MAKE_OBJECT, node->lineno);
    append_op(cw, buf[0], node->lineno);
    append_op(cw, buf[1], node->lineno);
    append_op(cw, buf[2], node->lineno);
    append_op(cw, buf[3], node->lineno);

    for(i = ct - 1; i >= 0; i--)
    {
        char *sid = arr_get(&names, i);
        char *nsid = malloc(strlen(sid) + 1);
        strcpy(nsid, sid);

        int i = find_prev_name(cw, nsid);
        if(i < 0)
        {
            i = (int)cw->rnames.count;
            arr_append(&cw->rnames, nsid);
        }

        unsigned char buf[4];
        int_to_byte_array(buf, i);
        append_op(cw, buf[0], node->lineno);
        append_op(cw, buf[1], node->lineno);
        append_op(cw, buf[2], node->lineno);
        append_op(cw, buf[3], node->lineno);
    }

    arr_free(&names);
}