fa_pair_t fa_pair_unassoc(fa_pair_t p) { fa_ptr_t a = fa_copy(((fa_pair_t) p->values[0])->values[0]); fa_ptr_t b = fa_copy(((fa_pair_t) p->values[0])->values[1]); fa_ptr_t c = fa_copy(p->values[1]); return new_pair(a, new_pair(b, c)); }
/* Initialize Roots nodes */ void initialize(node **root) { (*root) = safe_alloc(sizeof(node)); (*root) -> previous = NULL; (*root) -> next = NULL; (*root) -> from = new_pair(MARKER,MARKER); (*root) -> to = new_pair(MARKER,MARKER); }
node *infer_alignment(node *root_left,node *root_right) { node *left=root_left->next, *right=root_right->next, *new_list; int x1,x2,y1,y2,diff; initialize(&new_list); while(left!= NULL && right!=NULL) { if(left->to->end < right->from->begin) left=left->next; else if(right->from->end < left->to->begin) right=right->next; else { /* We're creating an inferred node */ /* For the beginning */ if((diff = left->to->begin - right->from->begin) > 0) { x1=left->from->begin; /* Shift down the beginning */ y1=right->to->begin + diff; } else { /* Otherwise shift down left side */ x1=left->from->begin - diff; y1=right->to->begin; } /* For the end */ if((diff = left->to->end - right->from->end) > 0) { /* i.e. The right one ends first - so advance it */ x2=left->from->end - diff; y2=right->to->end; right=right->next; } else { x2=left->from->end; y2=right->to->end + diff; left=left->next; } add(new_list, new_pair(x1,x2),new_pair(y1,y2)); } } return new_list; }
// Parses a pair, assuming the opening left parenthesis has already been read. static struct ParseResult parse_pair(const char *text) { struct ParseResult result; result.err_type = -1; const char *s = text; s += skip_whitespace(s); if (*s == ')') { s++; result.expr = new_null(); goto chars_read; } struct ParseResult first = parse(s); s += first.chars_read; if (first.err_type != -1) { result.err_type = first.err_type; goto chars_read; } if (*s == '.') { s++; struct ParseResult second = parse(s); s += second.chars_read; if (second.err_type != -1) { result.err_type = second.err_type; release_expression(first.expr); goto chars_read; } if (*s != ')') { result.err_type = *s ? ERR_EXPECTED_RPAREN : ERR_UNEXPECTED_EOI; release_expression(first.expr); goto chars_read; } s++; result.expr = new_pair(first.expr, second.expr); } else { struct ParseResult rest = parse_pair(s); s += rest.chars_read; if (rest.err_type != -1) { result.err_type = rest.err_type; release_expression(first.expr); goto chars_read; } result.expr = new_pair(first.expr, rest.expr); } chars_read: result.chars_read = (size_t)(s - text); return result; }
/** * Insert a new `struct pair` into table `*t` * * Don't check if the key to be inserted exists already or not. */ void table_insert(Table** t, const char* key, ast* value) { Pair* p = new_pair(key, value); Table* new_header = malloc(sizeof(Table)); new_header->elem = p; new_header->next = *t; *t = new_header; }
void insert_table(hash_t *h, char *key, char *value) { // Compute hash value of key. long hash_val = hash_f(key, (*h)->size); // Create the new pair struct element* new_node = new_pair(key, value); // Create pointer to traverse the linked list struct element* temp = (*h)->entries[hash_val]; // If there's no entry already if (temp == NULL) { new_node->next = temp; (*h)->entries[hash_val] = new_node; printf("1\n"); } /* else { while (temp != NULL) { temp = temp->next; } temp->next = new_node; h->entries[hash_val] = temp; } */ }
void insert(hashtable_s *hashtable, char *key, char *value){ int bin = 0; hashnode_s *newpair = NULL; hashnode_s *next = NULL; hashnode_s *last = NULL; bin = hash(hashtable, key); next = hashtable->nodes[bin]; while(next != NULL && next->key != NULL && strcmp( key, next->key) > 0){ last = next; next = next->next; } if(next != NULL && next->key != NULL && strcmp(key, next->key) == 0){ free(next->value); next->value = strdup(value); } else{ newpair = new_pair(key, value); // Beginning of bucket if(next == hashtable->nodes[bin]){ newpair->next = next; hashtable->nodes[bin] = newpair; }else if (next == NULL){ last->next = newpair; }else{ newpair->next = next; last->next = newpair; } } }
int main (int argc, char **argv) { node * left_list = NULL, *right_list, *current=NULL, *inferred_list; FILE *in_left, *in_right; int x1,x2,y1,y2; /* Check argc */ if(argc != 3) print_usage(); /* Initialize lists */ initialize(&left_list); initialize(&right_list); /* Open files */ in_left = safe_open(argv[1],"r"); in_right = safe_open(argv[2],"r"); /* Read in pairs */ while(!feof(in_left)) { fscanf(in_left,"%d%d%d%d\n",&x1,&x2,&y1,&y2); add(left_list, new_pair(x1,x2),new_pair(y1,y2)); } /* Print out list */ print_list(left_list); /* Read in pairs */ while(!feof(in_right)) { fscanf(in_right,"%d%d%d%d\n",&x1,&x2,&y1,&y2); add(right_list, new_pair(x1,x2),new_pair(y1,y2)); } /* Print out list */ print_list(right_list); /* Infer alignment */ inferred_list = infer_alignment(left_list,right_list); fprintf(stdout,"\nInferred list\n"); print_list(inferred_list); return 0; }
static pcred_pair_t const get_pair_permanent( ucred_t const* u, bool const force_privileged) { pcred_pair_t p = new_pair(force_privileged); p.next.uids.r = p.next.uids.e = p.next.uids.s = u->uid; p.next.gids.r = p.next.gids.e = p.next.gids.s = u->gid; p.next.sups = u->sups; return p; }
std::pair<CellPtr, Node<DIM>* > NodeBasedCellPopulation<DIM>::GetCellNodePair(unsigned nodeIndex) { Node<DIM>* p_node = this->GetNode(nodeIndex); CellPtr p_cell = this->GetCellUsingLocationIndex(nodeIndex); std::pair<CellPtr, Node<DIM>* > new_pair(p_cell, p_node); return new_pair; }
global Cell * read_stream(Cell *cell) { long c; c = cell->c_file == stdin ? get_one_char() : GetChar(cell->c_file); if (c == EOF) { end_stream(cell->c_file); return new_cnst(nil); } return new_cons(cons, new_pair(new_char((Char)c), new_stream(cell->c_file))); }
/** * transform a table to an understandable value for ncurses functions * * bool normal * bool bold * bool underline * bool blink * bool standout * bool reverse * int foreground * int background * * @param: L * @param: n position of the table on the stack * * the following parameter is filled by the function * @param: s attributes to turn on or off * * FIXME: vocabulary...? */ void table_to_style(lua_State *L, int n, t_style *s) { int i; int fg = -1; int bg = -1; s->on = A_NORMAL; s->off = A_NORMAL; if (! lua_istable(L, n)) { luaL_error(L, "invalid argument, table expected (got %s)", lua_typename(L, lua_type(L, n))); } for (i = 0; attr_list[i].name != NULL; i++) { lua_getfield(L, n, attr_list[i].name); /* get key */ if (! lua_isnoneornil(L, -1) && lua_isboolean(L, -1)) { if (lua_toboolean(L, -1)) /* t[key] = true */ s->on |= attr_list[i].value; else /* t[key] = false */ s->off |= attr_list[i].value; } lua_pop(L, 1); } /* foreground and background settings */ if (has_colors()) /* terminal is capable to output colors ? */ { lua_getfield(L, n, "foreground"); /* -2 */ lua_getfield(L, n, "background"); /* -1 */ /* at least one of background/foreground property is set ? */ if (! lua_isnil(L, -1) || ! lua_isnil(L, -2)) { if (! lua_isnil(L, -2) && lua_isnumber(L, -2)) /* fg */ fg = lua_tointeger(L, -2); if (! lua_isnil(L, -1) && lua_isnumber(L, -1)) /* bg */ bg = lua_tointeger(L, -1); s->on |= new_pair(fg, bg); } lua_pop(L, 2); } }
static id_pairs_t const get_pairs_temporary( ucred_t const* u, bool const force_privileged) { pcred_pair_t p = new_pair(force_privileged); id_pairs_t pairs; pairs.prev = p.prev; pairs.sups = u->sups; // Effective ID must be u's ids unsigned i; for (i = 0; i < ID_PAIR_COLLECTION_SIZE; ++i) { pairs.uids[i].e = u->uid; pairs.gids[i].e = u->gid; } // Prefer leaving real ID unchanged and using saved ID to store previous // effective ID pairs.uids[0].r = p.prev.uids.r; pairs.gids[0].r = p.prev.gids.r; pairs.uids[0].s = p.prev.uids.e; pairs.gids[0].s = p.prev.gids.e; pairs.uids[1].r = p.prev.uids.e; pairs.gids[1].r = p.prev.gids.e; pairs.uids[1].s = p.prev.uids.e; pairs.gids[1].s = p.prev.gids.e; pairs.uids[2].r = p.prev.uids.s; pairs.gids[2].r = p.prev.gids.s; pairs.uids[2].s = p.prev.uids.e; pairs.gids[2].s = p.prev.gids.e; pairs.uids[3].r = p.prev.uids.e; pairs.gids[3].r = p.prev.gids.e; pairs.uids[3].s = p.prev.uids.r; pairs.gids[3].s = p.prev.gids.r; pairs.uids[4].r = p.prev.uids.e; pairs.gids[4].r = p.prev.gids.e; pairs.uids[4].s = p.prev.uids.s; pairs.gids[4].s = p.prev.gids.s; return pairs; }
// ***************************************** // Brute force matcher // ***************************************** double BruteForceMatcher::match(std::vector<Line_param> l1, std::vector<Line_param> l2, std::vector<BruteForceMatcher::Pair> &matched, std::vector<Line_param> &unmatched) { const double unmatch_penalty = 90; if (l1.size() == 0) { unmatched = l2; return unmatch_penalty * unmatched.size(); } if (l2.size() == 0) { unmatched = l1; return unmatch_penalty * unmatched.size(); } Line_param query_line = l1.back(); // vec1: 2 3 4 5 // vec2: 1 2 3 4 5 ('1' vanished from the view) l1.pop_back(); std::vector<BruteForceMatcher::Pair> matched_0; std::vector<Line_param> unmatched_0; double err_0 = match(l1, l2, matched_0, unmatched_0) + unmatch_penalty; // vec1: 2 3 4 5 // vec2: 1 2 4 5 ('1' did not vanish) unsigned int l2_id = get_best_fit(query_line, l2); BruteForceMatcher::Pair new_pair(query_line, l2[l2_id]); l2.erase (l2.begin() + l2_id); std::vector<BruteForceMatcher::Pair> matched_1; std::vector<Line_param> unmatched_1; double err_1 = match(l1, l2, matched_1, unmatched_1) + new_pair.err; if (err_0 < err_1) { matched = matched_0; unmatched = unmatched_0; unmatched.push_back(query_line); return err_0; } else { matched = matched_1; unmatched = unmatched_1; matched.push_back(new_pair); return err_1; } };
void superposition::insert_r(clause * cls, expr * n, unsigned i, bool lhs) { if (is_app(n)) { unsigned idx = (i << 1) | static_cast<unsigned>(lhs); clause_pos_pair new_pair(cls, idx); SASSERT(m_todo.empty()); m_todo.push_back(to_app(n)); while (!m_todo.empty()) { app * n = m_todo.back(); m_todo.pop_back(); clause_pos_set * s = m_r2clause_set.get_parents(n); if (s == 0 || !s->contains(new_pair)) { m_r.insert(n); m_r2clause_set.insert(new_pair, n); unsigned num_args = n->get_num_args(); for (unsigned i = 0; i < num_args; i++) { expr * c = n->get_arg(i); if (is_app(c)) m_todo.push_back(to_app(c)); } } } } }
/********************************************************************** * add_seam_to_queue * * Adds the given new_seam to the seams priority queue, unless it is full * and the new seam is worse than the worst. **********************************************************************/ void Wordrec::add_seam_to_queue(float new_priority, SEAM *new_seam, SeamQueue* seams) { if (new_seam == NULL) return; if (chop_debug) { tprintf("Pushing new seam with priority %g :", new_priority); new_seam->Print("seam: "); } if (seams->size() >= MAX_NUM_SEAMS) { SeamPair old_pair(0, NULL); if (seams->PopWorst(&old_pair) && old_pair.key() <= new_priority) { if (chop_debug) { tprintf("Old seam staying with priority %g\n", old_pair.key()); } delete new_seam; seams->Push(&old_pair); return; } else if (chop_debug) { tprintf("New seam with priority %g beats old worst seam with %g\n", new_priority, old_pair.key()); } } SeamPair new_pair(new_priority, new_seam); seams->Push(&new_pair); }
CodeVar* ASTFactory:: build_codeRef(CvarSymbolTable::Entry e, POETCode* args, POETCode* attr) { POETCode* pars=e.get_param(); if (pars != 0 && args != 0) { e.get_symTable()->push_table(false); if (!match_parameters(pars, args, MATCH_PAR_MOD_CODE)) CVAR_MISMATCH(e.get_name(), pars, args); } int size = e.attr_size(); if (size > 0 && attr == 0) { if (size == 1) attr = eval_AST(e.get_attr(0)->get_entry().get_code()); else { attr = new_pair(eval_AST(e.get_attr(0)->get_entry().get_code()), eval_AST(e.get_attr(1)->get_entry().get_code())); for (int i = 2; i < size; ++i) attr = append_tuple(attr, eval_AST(e.get_attr(i)->get_entry().get_code())); } } if (pars != 0 && args != 0) e.get_symTable()->pop_table(); CvarTable* m = get_cvarTable(e); return static_cast<CodeVar*>(m->new_item(args, attr)); }
fa_pair_t fa_pair_copy(fa_pair_t pair) { return new_pair(pair->values[0], pair->values[1]); }
fa_pair_t fa_pair_read(fa_pair_struct_t *input) { return new_pair(input->first, input->second); }
fa_pair_t fa_pair_create(fa_ptr_t first, fa_ptr_t second) { return new_pair(first, second); }
fa_pair_t fa_pair_dswap(fa_pair_t pair) { fa_pair_t pair2 = new_pair(pair->values[1], pair->values[0]); fa_destroy(pair); return pair2; }
fa_pair_t fa_pair_dduplicate(fa_ptr_t value) { return new_pair(value, fa_copy(value)); }
void CGppe::Elicit( const VectorXd & theta_x, const VectorXd& theta_t, const double& sigma, const MatrixXd& train_t, const MatrixXd &x, TypePair & train_pairs , const MatrixXd & test_t, int test_user_idx, MatrixXd idx_pairs, int Maxiter, const TypePair& Oracle , MatrixXd& F) { train_pairs.conservativeResize(train_pairs.rows()+1); int N = x.rows(); int Mtrain = train_t.rows(); int M = Mtrain + 1; int Npairs = idx_pairs.rows(); int Lgood; VectorXd vrand, idx_good; //VectorXd is_selected(Npairs); Matrix<bool, Dynamic, 1> is_selected(Npairs); is_selected.fill(false); VectorXd loss = VectorXd::Zero(Maxiter + 1); double loss_current; VectorXd evoi(Npairs), ind_t, ind_x; VectorXd idx_global_1, idx_global_2, idx_global; compute_global_index(idx_global_1, idx_global_2, train_pairs, N); unique(idx_global, idx_global_1, idx_global_2); ind2sub(ind_x, ind_t, N, M, idx_global); bool stop = false; double foo, val; int count = 0; MatrixXd new_pair; MatrixXd t; VectorXd p_12(Npairs); t.resize(M, train_t.cols()); t << train_t, test_t; for (int iter = 0;iter <= Maxiter;iter++) { Approx_CGppe_Laplace( theta_x, theta_t, sigma, t, x, train_pairs, idx_global, idx_global_1, idx_global_2, ind_t, ind_x, Mtrain, N); Predictive_Utility_Distribution(t, test_t, N, idx_global ); //dsp(mustar,"mustar"); //dsp(varstar,"varstar"); std::ptrdiff_t best_item_idx; foo = mustar.maxCoeff(&best_item_idx); double fbest = get_fbest(N); //dsp(fbest,"fbest"); MatrixXd test_pair; for (int i = 0;i < Npairs;i++) { Predict_CGppe_Laplace(sigma, t, x, idx_global, ind_t, ind_x, t.row(M-1), idx_pairs.row(i)); p_12(i)=p; } for (int i = 0;i < Npairs;i++) { if (is_selected(i)) { evoi(i) = INT_MIN; continue; } test_pair = idx_pairs.row(i); evoi(i) = expected_voi(theta_x, theta_t, sigma, t, x, train_pairs, idx_global, ind_t, ind_x, test_pair, fbest,p_12(i)); } //dsp(evoi,"evoi"); std::ptrdiff_t query_idx; val = evoi.maxCoeff(&query_idx); idx_good = find(evoi, val); //dsp(val,"val"); Lgood = idx_good.rows(); if ( Lgood > 1) { //vrand = randperm(Lgood); cout<<"Solving clashes at random"<<endl; //query_idx = idx_good(vrand(0)); query_idx = idx_good(0); } is_selected(query_idx) = true; //dsp(query_idx,"queryidx"); new_pair = make_query_toydata(Oracle, query_idx, test_user_idx); //adding the new pair train_pairs(M-1)=MatAdd(train_pairs(M-1),new_pair); compute_global_index(idx_global_1, idx_global_2, train_pairs, N); unique(idx_global, idx_global_1, idx_global_2); ind2sub(ind_x, ind_t, N, M, idx_global); //Computes the loss of making a recommendation at this point loss_query_toydata(loss_current, F, stop, test_user_idx, best_item_idx); loss(iter)=loss_current; count++; cout << "Query " << count << "[" << new_pair(0) << " " << new_pair(1) << "] done, Recommended Item= " << best_item_idx << ", loss=" << loss(iter) << endl; } }
// Parses any expression. struct ParseResult parse(const char *text) { struct ParseResult result; result.err_type = PARSE_SUCCESS; const char *s = text; s += skip_whitespace(s); size_t len; switch (*s) { case '\0': result.err_type = ERR_UNEXPECTED_EOI; break; case '(': s++; result = parse_pair(s); s += result.chars_read; break; case ')': result.err_type = ERR_UNEXPECTED_RPAREN; break; case '.': result.err_type = ERR_INVALID_DOT; break; case '#': len = skip_symbol(s + 1); if (len == 1 && s[1] == 't') { s += 2; result.expr = new_boolean(true); } else if (len == 1 && s[1] == 'f') { s += 2; result.expr = new_boolean(false); } else if (len > 2 && s[1] == '\\') { char c = parse_char_name(s + 2, len - 1); if (c == '\0') { s += 2; result.err_type = ERR_UNKNOWN_CHARACTER; } else { s += 1 + len; result.expr = new_character(c); } } else if (s[1] == '\\' && s[2] && !isspace(s[2])) { result.expr = new_character(s[2]); s += 3; } else { result.err_type = ERR_INVALID_LITERAL; } break; case '\'': s++; result = parse(s); s += result.chars_read; if (result.err_type == PARSE_SUCCESS) { result.expr = new_pair( new_stdmacro(F_QUOTE), new_pair(result.expr, new_null())); } break; case '`': s++; result = parse(s); s += result.chars_read; if (result.err_type == PARSE_SUCCESS) { result.expr = new_pair( new_stdmacro(F_QUASIQUOTE), new_pair(result.expr, new_null())); } break; case ',': s++; enum StandardMacro stdmacro = F_UNQUOTE; if (*s == '@') { s++; stdmacro = F_UNQUOTE_SPLICING; } result = parse(s); s += result.chars_read; if (result.err_type == PARSE_SUCCESS) { result.expr = new_pair( new_stdmacro(stdmacro), new_pair(result.expr, new_null())); } break; case '"': s++; len = skip_string(s); if (!(s[len-1] == '\\' && (len < 2 || s[len-2] == '\\')) && s[len] == '"') { result.expr = parse_string(s, len); } else { result.err_type = ERR_UNEXPECTED_EOI; } s += len; s++; break; default:; len = skip_symbol(s); assert(len > 0); Number number; if (parse_number(s, len, &number)) { result.expr = new_number(number); } else { InternId symbol_id = intern_string_n(s, len); result.expr = new_symbol(symbol_id); } s += len; break; } if (result.err_type == PARSE_SUCCESS) { s += skip_whitespace(s); assert(s > text); } result.chars_read = (size_t)(s - text); return result; }
static pcred_pair_t get_pair_current(bool const force_privileged) { pcred_pair_t p = new_pair(force_privileged); p.next = p.prev; return p; }
fa_pair_t fa_pair_deep_copy(fa_pair_t pair) { return new_pair(pair->values[0] ? fa_deep_copy(pair->values[0]) : NULL, pair->values[1] ? fa_deep_copy(pair->values[1]) : NULL); }
fa_pair_t fa_pair_swap(fa_pair_t pair) { return new_pair(fa_copy(pair->values[1]), fa_copy(pair->values[0])); }
bool read_literals(char *oldpos, size_t size, Header* h) { int i, j; int n = 0; char type; uint32_t str_length; uint32_t ref; char *startpos = oldpos + h->size * 4; char *curpos = startpos; while (!eofreached) { type = *curpos++; if (eofreached) { break; } n++; switch (type) { case TYPE_NUM: curpos += 8; break; case TYPE_NUM | TYPE_SHORT: curpos += 3; break; case TYPE_STR: case TYPE_IDENT: memcpy(&str_length, curpos, 4); curpos += 4 + ntohl(str_length); break; case TYPE_STR | TYPE_SHORT: case TYPE_IDENT | TYPE_SHORT: str_length = (unsigned char)*curpos++; curpos += str_length; break; case TYPE_PAIR: curpos += 6; break; case TYPE_FRAC: curpos += 16; break; case TYPE_FRAC | TYPE_SHORT: curpos += 2; break; case TYPE_LIST: memcpy(&str_length, curpos, 4); curpos += 4 + 3 * ntohl(str_length); break; case TYPE_DICT: memcpy(&str_length, curpos, 4); curpos += 4 + 6 * ntohl(str_length); break; } } V* arr = calloc(n, sizeof(V)); V t; curpos = startpos; for (i = 0; i < n; i++) { type = *curpos++; if (type == TYPE_NUM) { union double_or_uint64_t d; memcpy(&d, curpos, 8); curpos += 8; d.i = ntohll(d.i); t = double_to_value(d.d); } else if (type == (TYPE_NUM | TYPE_SHORT)) { ref = 0; memcpy(((char*)&ref) + 1, curpos, 3); ref = ntohl(ref); curpos += 3; t = int_to_value(ref); } else if (type == TYPE_STR) { memcpy(&str_length, curpos, 4); curpos += 4; str_length = ntohl(str_length); if (!valid_utf8(str_length, curpos)) { set_error_msg("wrong encoding for string literal, should be UTF-8"); return false; } t = str_to_string(str_length, curpos); curpos += str_length; } else if (type == TYPE_IDENT) { memcpy(&str_length, curpos, 4); curpos += 4; str_length = ntohl(str_length); char data[str_length + 1]; memcpy(&data, curpos, str_length); data[str_length] = '\0'; t = lookup_ident(str_length, data); curpos += str_length; } else if (type == (TYPE_STR | TYPE_SHORT)) { str_length = (unsigned char)*curpos++; if (!valid_utf8(str_length, curpos)) { set_error_msg("wrong encoding for string literal, should be UTF-8"); return false; } t = str_to_string(str_length, curpos); curpos += str_length; } else if (type == (TYPE_IDENT | TYPE_SHORT)) { str_length = *curpos++; char data[str_length + 1]; memcpy(&data, curpos, str_length); data[str_length] = '\0'; t = lookup_ident(str_length, data); curpos += str_length; } else if (type == TYPE_PAIR) { ref = 0; memcpy(((char*)&ref) + 1, curpos, 3); ref = ntohl(ref); if (ref >= i) { set_error_msg("illegal pair detected"); return false; } V v1 = arr[ref]; ref = 0; memcpy(((char*)&ref) + 1, curpos + 3, 3); ref = ntohl(ref); if (ref >= i) { set_error_msg("illegal pair detected"); return false; } V v2 = arr[ref]; t = new_pair(v1, v2); curpos += 6; } else if (type == TYPE_FRAC) { int64_t numer; int64_t denom; memcpy(&numer, curpos, 8); numer = ntohll(numer); memcpy(&denom, curpos + 8, 8); denom = ntohll(denom); t = new_frac(numer, denom); curpos += 16; } else if (type == (TYPE_FRAC | TYPE_SHORT)) { int8_t numer; uint8_t denom; numer = *curpos++; denom = *curpos++; t = new_frac(numer, denom); } else if (type == TYPE_LIST) { memcpy(&str_length, curpos, 4); str_length = ntohl(str_length); t = new_list(); curpos += 4; if (str_length > 0) { uint32_t size = 64; while (size < str_length) size <<= 1; toStack(t)->size = size; toStack(t)->used = str_length; toStack(t)->nodes = calloc(size, sizeof(V)); for (j = 0; j < str_length; j++) { ref = 0; memcpy(((char*)&ref) + 1, curpos, 3); ref = ntohl(ref); toStack(t)->nodes[j] = intToV((uint64_t)ref); curpos += 3; } } } else if (type == TYPE_DICT) { memcpy(&str_length, curpos, 4); curpos += 4; str_length = ntohl(str_length); t = new_dict(); if (str_length > 0) { uint32_t size = 16; while (size < str_length) size <<= 1; toHashMap(t)->size = size; toHashMap(t)->used = str_length; toHashMap(t)->map = (Bucket**)curpos; } curpos += 6 * str_length; } else { set_error_msg("Unknown literal type."); return false; } arr[i] = t; } for (i = 0; i < n; i++) { t = arr[i]; switch(getType(t)) { case TYPE_LIST: for (j = 0; j < toStack(t)->used; j++) { toStack(t)->nodes[j] = arr[toInt(toStack(t)->nodes[j])]; } break; case TYPE_DICT: if (toHashMap(t)->map) { curpos = ((char*)toHashMap(t)->map); toHashMap(t)->map = NULL; str_length = toHashMap(t)->used; //worst abuse of variable name ever Y/Y? toHashMap(t)->used = 0; for (j = 0; j < str_length; j++) { ref = 0; memcpy(((char*)&ref) + 1, curpos, 3); ref = ntohl(ref); V key = arr[ref]; ref = 0; memcpy(((char*)&ref) + 1, curpos + 3, 3); ref = ntohl(ref); V value = arr[ref]; set_hashmap(toHashMap(t), key, value); curpos += 6; } } break; } } h->n_literals = n; h->literals = arr; return true; }