/**************************************************************************** find first available connection slot, starting from a random position. The randomisation stops problems with the server dieing and clients thinking the server is still available. ****************************************************************************/ connection_struct *conn_new(void) { connection_struct *conn; int i; i = bitmap_find(bmap, 1); if (i == -1) { DEBUG(1,("ERROR! Out of connection structures\n")); return NULL; } conn = (connection_struct *)malloc(sizeof(*conn)); if (!conn) return NULL; ZERO_STRUCTP(conn); conn->cnum = i; bitmap_set(bmap, i); num_open++; string_set(&conn->user,""); string_set(&conn->dirpath,""); string_set(&conn->connectpath,""); string_set(&conn->origpath,""); DLIST_ADD(Connections, conn); return conn; }
void do_grouping(Cudd& cudd, const vector<VecUint>& orders) { L_INF("trying to group vars.."); if (orders[0].size() < 5) // window size is too big return; hmap<uint, vector<SetUint>> groups_by_length; groups_by_length[2] = get_group_candidates(orders, 2); groups_by_length[3] = get_group_candidates(orders, 3); groups_by_length[4] = get_group_candidates(orders, 4); groups_by_length[5] = get_group_candidates(orders, 5); L_INF("# of group candidates: of size 2 -- " << groups_by_length[2].size()); for (auto const& g : groups_by_length[2]) { L_INF(string_set(g)); } L_INF("# of group candidates: of size 3 -- " << groups_by_length[3].size()); for (auto const& g : groups_by_length[3]) { L_INF(string_set(g)); } L_INF("# of group candidates: of size 4 -- " << groups_by_length[4].size()); L_INF("# of group candidates: of size 5 -- " << groups_by_length[5].size()); auto cur_order = orders.back(); // we fix only groups present in the current order (because that is easier to implement) for (uint i = 5; i>=2; --i) // decreasing order! if (!groups_by_length[i].empty()) _do_grouping(cudd, groups_by_length, i, cur_order); }
void port_read_line(port_t *port, string_t *s) { char ch; string_set(s, ""); assert(port_is_input(port)); if (port_is_input(port)) { for (;;) { ch = port_read_char(port); /* Line break on \r or \n or \r\n and consume the line break character(s) */ if (ch == '\r') { ch = port_peek_char(port); if (ch == '\n') ch = port_read_char(port); break; } else if (ch == '\n' || ch == EOF) break; string_nappend(s, &ch, 1); } } }
int main(int argc, char *argv[]) { void *a = new(String, "a"); void *b = new(String, "bbb"); void *s = new(Set); printf("LENGTH A: %lu\n", string_length(a)); printf("LENGTH B: %lu\n", string_length(b)); printf("Prev: %s\n", string_get(a)); string_set(a, "New String"); printf("New: %s\n", string_get(a)); set_add(s, a); set_add(s, b); printf("CONTAINS A: %u\n", set_contains(s, a)); printf("CONTAINS B: %u\n", set_contains(s, b)); printf("DROP B: %p\n", set_drop(s, b)); printf("DROP B: %p\n", set_drop(s, b)); printf("ADD B: %p\n", set_add(s, b)); delete(s); delete(a); delete(b); return 0; }
/* function: transpose_string_array * * Implementation of transpose(A) for matrix A. */ void transpose_string_array(const string_array_t * a, string_array_t* dest) { size_t i; size_t j; /* size_t k;*/ size_t n,m; if(a->ndims == 1) { copy_string_array_data(*a,dest); return; } assert(a->ndims==2 && dest->ndims==2); n = a->dim_size[0]; m = a->dim_size[1]; assert(dest->dim_size[0] == m && dest->dim_size[1] == n); for(i = 0; i < n; ++i) { for(j = 0; j < m; ++j) { string_set(dest, (j * n) + i, string_get(*a, (i * m) + j)); } } }
void array_string_array(string_array_t* dest,int n,string_array_t first,...) { int i,j,c; va_list ap; string_array_t *elts=(string_array_t*)malloc(sizeof(string_array_t) * n); assert(elts); /* collect all array ptrs to simplify traversal.*/ va_start(ap,first); elts[0] = first; for(i = 1; i < n; ++i) { elts[i] = va_arg(ap, string_array_t); } va_end(ap); check_base_array_dim_sizes(elts,n); for(i = 0, c = 0; i < n; ++i) { int m = base_array_nr_of_elements(elts[i]); for(j = 0; j < m; ++j) { string_set(dest, c, string_get(elts[i], j)); c++; } } free(elts); }
void matrix_string_scalar(modelica_string a, string_array_t* dest) { dest->ndims = 2; dest->dim_size[0] = 1; dest->dim_size[1] = 1; string_set(dest, 0, a); }
string_t *string_copy(string_t *str) { string_t *res = string_alloc(); if (str->buf) string_set(res, str->buf); return res; }
void set_legacy_jre_path(const char *path) { if (!legacy_jre_path) legacy_jre_path = string_init(32); string_set(legacy_jre_path, is_absolute_path(path) ? path : ij_path(path)); if (debug) error("Using JRE from ImageJ.cfg: %s", legacy_jre_path->buffer); }
/* Zero based index */ void simple_indexed_assign_string_array1(const string_array_t * source, int i1, string_array_t* dest) { /* Assert that source has the correct dimension */ /* Assert that dest has the correct dimension */ string_set(dest, i1, string_get(*source, i1)); }
void put_string_matrix_element(modelica_string value, int r, int c, string_array_t* dest) { /* Assert that dest hast correct dimension */ /* Assert that r and c are valid indices */ string_set(dest, (r * dest->dim_size[1]) + c, value); /* printf("Index %d\n",r*dest->dim_size[1]+c); */ }
void wiki_save(Database* db, char* page_name, char* content) { Wiki* wiki_a = wiki_new(); wiki_a->content = xalloc(sizeof(char) * strlen(content) + 1); string_set(wiki_a->name, page_name); strcpy(wiki_a->content, content); db_register_wiki(db, wiki_a); wiki_free(wiki_a); }
void fill_string_array(string_array_t* dest,modelica_string s) { size_t nr_of_elements; size_t i; nr_of_elements = base_array_nr_of_elements(*dest); for(i = 0; i < nr_of_elements; ++i) { string_set(dest, i, s); } }
obj_ptr obj_alloc_string(cptr val) { obj_ptr res = gc_alloc(); res->type = TYPE_STRING; res->data.as_string.buf = 0; res->data.as_string.len = 0; res->data.as_string.size = 0; string_set(&res->data.as_string, val); return res; }
void simple_indexed_assign_string_array2(const string_array_t * source, int i1, int i2, string_array_t* dest) { size_t index; /* Assert that source has correct dimension */ /* Assert that dest has correct dimension */ index = (i1 * source->dim_size[1]) + i2; string_set(dest, index, string_get(*source, index)); }
/* function: cat_string_array * * Concatenates n string arrays along the k:th dimension. * k is one based */ void cat_string_array(int k, string_array_t* dest, int n, string_array_t* first,...) { va_list ap; int i, j, r, c; int n_sub = 1, n_super = 1; int new_k_dim_size = 0; string_array_t **elts = (string_array_t**)malloc(sizeof(string_array_t *) * n); assert(elts); /* collect all array ptrs to simplify traversal.*/ va_start(ap, first); elts[0] = first; for(i = 1; i < n; i++) { elts[i] = va_arg(ap,string_array_t*); } va_end(ap); /* check dim sizes of all inputs and dest */ assert(elts[0]->ndims >= k); for(i = 0; i < n; i++) { assert(dest->ndims == elts[i]->ndims); for(j = 0; j < (k - 1); j++) { assert(dest->dim_size[j] == elts[i]->dim_size[j]); } new_k_dim_size += elts[i]->dim_size[k-1]; for(j = k; j < elts[0]->ndims; j++) { assert(dest->dim_size[j] == elts[i]->dim_size[j]); } } assert(dest->dim_size[k-1] == new_k_dim_size); /* calculate size of sub and super structure in 1-dim data representation */ for(i = 0; i < (k - 1); i++) { n_super *= elts[0]->dim_size[i]; } for(i = k; i < elts[0]->ndims; i++) { n_sub *= elts[0]->dim_size[i]; } /* concatenation along k-th dimension */ j = 0; for(i = 0; i < n_super; i++) { for(c = 0; c < n; c++) { int n_sub_k = n_sub * elts[c]->dim_size[k-1]; for(r = 0; r < n_sub_k; r++) { string_set(dest, j, string_get(*elts[c], r + (i * n_sub_k))); j++; } } } free(elts); }
void index_string_array(const string_array_t * source, const index_spec_t* source_spec, string_array_t* dest) { _index_t* idx_vec1; _index_t* idx_vec2; _index_t* idx_size; int j; int i; assert(base_array_ok(source)); assert(base_array_ok(dest)); assert(index_spec_ok(source_spec)); assert(index_spec_fit_base_array(source_spec,source)); for(i = 0, j = 0; i < source->ndims; ++i) { if((source_spec->index_type[i] == 'W') || (source_spec->index_type[i] == 'A')) { ++j; } } assert(j == dest->ndims); idx_vec1 = size_alloc(source->ndims); /*indices in the source array*/ idx_vec2 = size_alloc(dest->ndims); /* indices in the destination array*/ idx_size = size_alloc(source_spec->ndims); for(i = 0; i < source->ndims; ++i) { idx_vec1[i] = 0; } for(i = 0; i < source_spec->ndims; ++i) { if(source_spec->index[i] != NULL) { idx_size[i] = imax(source_spec->dim_size[i],1); } else { idx_size[i] = source->dim_size[i]; } } do { for(i = 0, j = 0; i < source->ndims; ++i) { if((source_spec->index_type[i] == 'W') || (source_spec->index_type[i] == 'A')) { idx_vec2[j] = idx_vec1[i]; j++; } } string_set(dest, calc_base_index(dest->ndims, idx_vec2, dest), string_get(*source, calc_base_index_spec(source->ndims, idx_vec1, source, source_spec))); } while(0 == next_index(source->ndims, idx_vec1, idx_size)); }
void vector_string_array(const string_array_t * a, string_array_t* dest) { size_t i, nr_of_elements; /* Assert that a has at most one dimension with dim_size>1*/ nr_of_elements = base_array_nr_of_elements(*a); for(i = 0; i < nr_of_elements; ++i) { string_set(dest, i, string_get(*a, i)); } }
void simple_index_string_array2(const string_array_t * source, int i1, int i2, string_array_t* dest) { size_t i; size_t nr_of_elements = base_array_nr_of_elements(*dest); size_t off = nr_of_elements * ((source->dim_size[1] * i1) + i2); for(i = 0 ; i < nr_of_elements ; i++) { string_set(dest, i, string_get(*source, off + i)); } }
void simple_index_string_array1(const string_array_t * source, int i1, string_array_t* dest) { size_t i; size_t nr_of_elements = base_array_nr_of_elements(*dest); size_t off = nr_of_elements * i1; assert(dest->ndims == (source->ndims - 1)); for(i = 0 ; i < nr_of_elements ; i++) { string_set(dest, i, string_get(*source, off + i)); } }
void matrix_string_array(const string_array_t * a, string_array_t* dest) { size_t i, cnt; /* Assert that size(A,i)=1 for 2 <i<=ndims(A)*/ dest->dim_size[0] = a->dim_size[0]; dest->dim_size[1] = (a->ndims < 2)? 1 : a->dim_size[1]; cnt = dest->dim_size[0] * dest->dim_size[1]; for(i = 0; i < cnt; ++i) { string_set(dest, i, string_get(*a, i)); } }
void copy_string_array_data(const string_array_t source, string_array_t *dest) { size_t i, nr_of_elements; assert(base_array_ok(&source)); assert(base_array_ok(dest)); assert(base_array_shape_eq(&source, dest)); nr_of_elements = base_array_nr_of_elements(source); for(i = 0; i < nr_of_elements; ++i) { string_set(dest, i, string_get(source, i)); } }
void fill_alloc_string_array(string_array_t* dest, modelica_string value, int ndims, ...) { size_t i; size_t elements = 0; va_list ap; va_start(ap, ndims); elements = alloc_base_array(dest, ndims, ap); va_end(ap); dest->data = string_alloc(elements); for(i = 0; i < elements; ++i) { string_set(dest, i, value); } }
static int open_acl_xattr(vfs_handle_struct *handle, const char *fname, files_struct *fsp, int flags, mode_t mode) { uint32_t access_granted = 0; struct security_descriptor *pdesc = NULL; bool file_existed = true; NTSTATUS status = get_nt_acl_xattr_internal(handle, NULL, fname, (OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION), &pdesc); if (NT_STATUS_IS_OK(status)) { /* See if we can access it. */ status = smb1_file_se_access_check(pdesc, handle->conn->server_info->ptok, fsp->access_mask, &access_granted); if (!NT_STATUS_IS_OK(status)) { DEBUG(10,("open_acl_xattr: file %s open " "refused with error %s\n", fname, nt_errstr(status) )); errno = map_errno_from_nt_status(status); return -1; } } else if (NT_STATUS_EQUAL(status,NT_STATUS_OBJECT_NAME_NOT_FOUND)) { file_existed = false; } DEBUG(10,("open_acl_xattr: get_nt_acl_attr_internal for " "file %s returned %s\n", fname, nt_errstr(status) )); fsp->fh->fd = SMB_VFS_NEXT_OPEN(handle, fname, fsp, flags, mode); if (!file_existed && fsp->fh->fd != -1) { /* File was created. Inherit from parent directory. */ string_set(&fsp->fsp_name, fname); inherit_new_acl(handle, fname, fsp, false); } return fsp->fh->fd; }
void indexed_assign_string_array(const string_array_t * source, string_array_t* dest, const index_spec_t* dest_spec) { _index_t* idx_vec1; _index_t* idx_vec2; _index_t* idx_size; int i,j; assert(base_array_ok(source)); assert(base_array_ok(dest)); assert(index_spec_ok(dest_spec)); assert(index_spec_fit_base_array(dest_spec, dest)); for(i = 0,j = 0; i < dest_spec->ndims; ++i) { if(dest_spec->dim_size[i] != 0) { ++j; } } assert(j == source->ndims); idx_vec1 = size_alloc(dest->ndims); idx_vec2 = size_alloc(source->ndims); idx_size = size_alloc(dest_spec->ndims); for(i = 0; i < dest_spec->ndims; ++i) { idx_vec1[i] = 0; if(dest_spec->index[i] != NULL) { idx_size[i] = imax(dest_spec->dim_size[i],1); } else { idx_size[i] = dest->dim_size[i]; } } do { for(i = 0, j = 0; i < dest_spec->ndims; ++i) { if(dest_spec->dim_size[i] != 0) { idx_vec2[j] = idx_vec1[i]; ++j; } } string_set(dest, calc_base_index_spec(dest->ndims, idx_vec1, dest, dest_spec), string_get(*source, calc_base_index(source->ndims, idx_vec2, source))); } while(0 == next_index(dest_spec->ndims, idx_vec1, idx_size)); }
void string_set(string_t *str, cptr val) { if (!val) string_set(str, ""); else if (str->buf == val) { } else { size_t size = strlen(val) + 1; string_grow(str, size); memcpy(str->buf, val, size); str->len = size - 1; } }
void port_read_until(port_t *port, string_t *s, char_predicate_fn f) { char ch; string_set(s, ""); assert(port_is_input(port)); if (port_is_input(port)) { for (;;) { ch = port_peek_char(port); if (ch == EOF || f(ch)) break; ch = port_read_char(port); string_nappend(s, &ch, 1); } } }
void promote_scalar_string_array(modelica_string s,int n, string_array_t* dest) { int i; /* Assert that dest is of correct dimension */ /* Alloc size */ dest->dim_size = size_alloc(n); /* Alloc data */ dest->data = string_alloc(1); dest->ndims = n; string_set(dest, 0, s); for(i = 0; i < n; ++i) { dest->dim_size[i] = 1; } }
l3obj* make_new_string_obj(const qqchar& s, Tag* owner, const qqchar& varname) { FILE* ifp = 0; l3obj* obj = 0; l3path basenm("make_new_string_obj_"); basenm.pushq(varname); make_new_captag((l3obj*)&basenm ,0,0, 0,&obj,owner, 0,t_str, owner,ifp); LIVEO(obj); obj->_type = t_str; obj->_dtor = &string_dtor; // array should start empty. assert(obj->_judyL == 0); if (s.len()) { string_set(obj,0,s); } return obj; }
/** * insert temp. state into the compressed array */ int new_state(int i, int k) { int j,c; for (j=first_free_cell; ; j++) { if (j>=cells_size-k) { if ((cells=realloc(cells,(cells_size+=cells_delta)*sizeof(tcell)))==NULL) error("Memory full"); memset(cells+(cells_size-cells_delta),0,cells_delta*sizeof(tcell)); } if (free_cell(j) && state_fits(i,j,k)) { for (c=1; c<=k; c++) if (state(i,c)!=0) save_cell(j+c, c, state(i,c)); save_cell(j, (state(i,0)==0 ? letter_count : 0), string_set(i)); break; } } if (j-COMPWIN > first_free_cell) first_free_cell = j-COMPWIN; for ( ; !free_cell(first_free_cell); first_free_cell++) ; if (j+k > last_full_cell) last_full_cell = j+k; return(j); }