void dictionary_delete(Dictionary dict) { if (!dict) return; if (verbosity > 0) { prt_error("Info: Freeing dictionary %s", dict->name); } #ifdef USE_CORPUS lg_corpus_delete(dict->corpus); #endif if (dict->affix_table != NULL) { affix_list_delete(dict->affix_table); dictionary_delete(dict->affix_table); } spellcheck_destroy(dict->spell_checker); connector_set_delete(dict->unlimited_connector_set); if (dict->close) dict->close(dict); pp_knowledge_close(dict->base_knowledge); pp_knowledge_close(dict->hpsg_knowledge); string_set_delete(dict->string_set); free_regexs(dict->regex_root); #ifdef USE_ANYSPLIT free_anysplit(dict); #endif free_dictionary(dict); xfree(dict, sizeof(struct Dictionary_s)); object_open(NULL, NULL, NULL); /* Free the directory path cache */ }
int ifuse_statfs(const char *path, struct statvfs *stats) { afc_client_t afc = fuse_get_context()->private_data; char **info_raw = NULL; uint64_t totalspace = 0, freespace = 0; int i = 0, blocksize = 0; afc_error_t err = afc_get_device_info(afc, &info_raw); if (err != AFC_E_SUCCESS) { int res = get_afc_error_as_errno(err); return -res; } if (!info_raw) return -ENOENT; for (i = 0; info_raw[i]; i++) { if (!strcmp(info_raw[i], "FSTotalBytes")) { totalspace = strtoull(info_raw[i + 1], (char **) NULL, 10); } else if (!strcmp(info_raw[i], "FSFreeBytes")) { freespace = strtoull(info_raw[i + 1], (char **) NULL, 10); } else if (!strcmp(info_raw[i], "FSBlockSize")) { blocksize = atoi(info_raw[i + 1]); } } free_dictionary(info_raw); stats->f_bsize = stats->f_frsize = blocksize; stats->f_blocks = totalspace / blocksize; stats->f_bfree = stats->f_bavail = freespace / blocksize; stats->f_namemax = 255; stats->f_files = stats->f_ffree = 1000000000; return 0; }
int ifuse_readlink(const char *path, char *linktarget, size_t buflen) { int i, ret; char **info = NULL; if (!path || !linktarget || (buflen == 0)) { return -EINVAL; } linktarget[0] = '\0'; // in case the link target cannot be determined afc_client_t afc = fuse_get_context()->private_data; afc_error_t err = afc_get_file_info(afc, path, &info); if ((err == AFC_E_SUCCESS) && info) { ret = -1; for (i = 0; info[i]; i+=2) { if (!strcmp(info[i], "LinkTarget")) { strncpy(linktarget, info[i+1], buflen-1); linktarget[buflen-1] = '\0'; ret = 0; } } free_dictionary(info); } else { ret = get_afc_error_as_errno(err); return -ret; } return ret; }
void *ifuse_init(struct fuse_conn_info *conn) { afc_client_t afc = NULL; conn->async_read = 0; afc_client_new(phone, opts.port, &afc); lockdownd_client_free(control); control = NULL; if (afc) { // get file system block size int i; char **info_raw = NULL; if ((AFC_E_SUCCESS == afc_get_device_info(afc, &info_raw)) && info_raw) { for (i = 0; info_raw[i]; i+=2) { if (!strcmp(info_raw[i], "FSBlockSize")) { g_blocksize = atoi(info_raw[i + 1]); break; } } free_dictionary(info_raw); } } return afc; }
void close_stringdist(Stringdist *S){ free(S->work); free(S->weight); if (S->distance == dl){ free_dictionary(S->dict); } if (S->distance == qgram || S->distance == cosine || S->distance == jaccard){ free_qtree(S->tree); } free(S); }
static int ifuse_readdir(const char *path, void *buf, fuse_fill_dir_t filler, off_t offset, struct fuse_file_info *fi) { int i; char **dirs = NULL; afc_client_t afc = fuse_get_context()->private_data; afc_read_directory(afc, path, &dirs); if (!dirs) return -ENOENT; for (i = 0; dirs[i]; i++) { filler(buf, dirs[i], NULL, 0); } free_dictionary(dirs); return 0; }
int dictionary_delete(Dictionary dict) { if (verbosity > 0) { fprintf(stderr, "Freeing dictionary %s\n", dict->name); } if (dict->affix_table != NULL) { dictionary_delete(dict->affix_table); } connector_set_delete(dict->andable_connector_set); connector_set_delete(dict->unlimited_connector_set); post_process_close(dict->postprocessor); post_process_close(dict->constituent_pp); string_set_delete(dict->string_set); free_dictionary(dict); xfree(dict, sizeof(struct Dictionary_s)); return 0; }
void *ifuse_init(struct fuse_conn_info *conn) { afc_client_t afc = NULL; conn->async_read = 0; #ifdef HAVE_LIBIMOBILEDEVICE_1_1 if (house_arrest) { afc_client_new_from_house_arrest_client(house_arrest, &afc); } else { #endif #ifdef HAVE_LIBIMOBILEDEVICE_1_1_5 afc_client_new(phone, opts.service, &afc); #else afc_client_new(phone, opts.port, &afc); #endif #ifdef HAVE_LIBIMOBILEDEVICE_1_1 } #endif lockdownd_client_free(control); control = NULL; if (afc) { // get file system block size int i; char **info_raw = NULL; if ((AFC_E_SUCCESS == afc_get_device_info(afc, &info_raw)) && info_raw) { for (i = 0; info_raw[i]; i+=2) { if (!strcmp(info_raw[i], "FSBlockSize")) { g_blocksize = atoi(info_raw[i + 1]); break; } } free_dictionary(info_raw); } } return afc; }
SEXP R_match_dl(SEXP x, SEXP table, SEXP nomatch, SEXP matchNA, SEXP weight, SEXP maxDistance){ PROTECT(x); PROTECT(table); PROTECT(nomatch); PROTECT(matchNA); PROTECT(weight); PROTECT(maxDistance); int nx = length(x) , ntable = length(table) , no_match = INTEGER(nomatch)[0] , match_na = INTEGER(matchNA)[0] , bytes = IS_CHARACTER(x) , ml_x = max_length(x) , ml_t = max_length(table); double *w = REAL(weight); double maxDist = REAL(maxDistance)[0]; /* claim space for workhorse */ dictionary *dict = new_dictionary( ml_x + ml_t + 1 ); double *scores = (double *) malloc( (ml_x + 3) * (ml_t + 2) * sizeof(double) ); unsigned int *X = NULL, *T = NULL; X = (unsigned int *) malloc( (ml_x + ml_t + 2) * sizeof(int) ); if ( (scores == NULL) || (X == NULL) ){ UNPROTECT(6); free(X); free(scores); error("Unable to allocate enough memory"); } T = X + ml_x + 1; memset(X, 0, (ml_x + ml_t + 2)*sizeof(int)); // output vector SEXP yy; PROTECT(yy = allocVector(INTSXP, nx)); int *y = INTEGER(yy); double d = R_PosInf, d1 = R_PosInf; int index, len_X, len_T, isna_X, isna_T; unsigned int *X1, *T1; for ( int i=0; i<nx; i++){ index = no_match; if ( bytes ){ X = get_elem(x, i , bytes, &len_X, &isna_X, X); } else { X1 = get_elem(x, i , bytes, &len_X, &isna_X, X); memcpy(X, X1, len_X*sizeof(int)); } d1 = R_PosInf; for ( int j=0; j<ntable; j++){ if ( bytes ){ T = get_elem(table, j, bytes, &len_T, &isna_T, T); } else { T1 = get_elem(table, j, bytes, &len_T, &isna_T, T); memcpy(T, T1, len_T * sizeof(int)); } if ( !isna_X && !isna_T ){ // both are char (usual case) d = distance( X, T, len_X, len_T, w, dict, scores ); memset(T,0, (ml_t+1)*sizeof(int)); if ( d <= maxDist && d < d1){ index = j + 1; if ( abs(d) < 1e-14 ) break; d1 = d; } } else if ( isna_X && isna_T ) { // both are NA index = match_na ? j + 1 : no_match; break; } } y[i] = index; memset(X,0,(ml_x + 1)*sizeof(int)); } UNPROTECT(7); free(X); free_dictionary(dict); free(scores); return(yy); }
SEXP R_dl(SEXP a, SEXP b, SEXP weight){ PROTECT(a); PROTECT(b); PROTECT(weight); int na = length(a) , nb = length(b) , nt = (na > nb) ? na : nb , bytes = IS_CHARACTER(a) , ml_a = max_length(a) , ml_b = max_length(b); double *w = REAL(weight); /* claim space for workhorse */ unsigned int *s=NULL, *t=NULL; dictionary *dict = new_dictionary( ml_a + ml_b + 1 ); double *scores = (double *) malloc( (ml_a + 3) * (ml_b + 2) * sizeof(double) ); int slen = (ml_a + ml_b + 2) * sizeof(int); s = (unsigned int *) malloc(slen); if ( (scores == NULL) | ( s == NULL ) ){ UNPROTECT(3); free(scores); free(s); error("Unable to allocate enough memory"); } t = s + ml_a + 1; memset(s, 0, slen); // output SEXP yy; PROTECT(yy = allocVector(REALSXP, nt)); double *y = REAL(yy); int i=0, j=0, len_s, len_t, isna_s, isna_t; unsigned int *s1, *t1; for ( int k=0; k < nt; ++k ){ if (bytes){ s = get_elem(a, i, bytes, &len_s, &isna_s, s); t = get_elem(b, j, bytes, &len_t, &isna_t, t); } else { // make sure there's an extra 0 at the end of the string. s1 = get_elem(a, i, bytes, &len_s, &isna_s, s); t1 = get_elem(b, j, bytes, &len_t, &isna_t, t); memcpy(s,s1,len_s*sizeof(int)); memcpy(t,t1,len_t*sizeof(int)); } if ( isna_s || isna_t ){ y[k] = NA_REAL; continue; } y[k] = distance( s, t, len_s, len_t, w, dict, scores ); if (y[k] < 0 ) y[k] = R_PosInf; i = RECYCLE(i+1,na); j = RECYCLE(j+1,nb); memset(s, 0, slen); } free_dictionary(dict); free(scores); free(s); UNPROTECT(4); return yy; }
static SEXP read_SPSS_SAVE(const char *filename) { struct file_handle *fh = fh_get_handle_by_filename(filename); struct sfm_read_info inf; struct dictionary *dict; SEXP ans; SEXP ans_names; union value *case_vals; int i; int nvar_label; int nval = 0; SEXP val_labels; SEXP variable_labels; SEXP miss_labels; int have_miss = 0; /* package multcomp has an example in which this does not get initialized */ inf.encoding = 0; dict = sfm_read_dictionary(fh, &inf); ans = PROTECT(allocVector(VECSXP, dict->nvar)); ans_names = PROTECT(allocVector(STRSXP, dict->nvar)); /* Set the fv and lv elements of all variables in the dictionary. */ for (i = 0; i < dict->nvar; i++) { struct variable *v = dict->var[i]; v->fv = nval; nval += v->nv; } dict->nval = nval; if (!nval) error(_("nval is 0")); case_vals = (union value *) R_alloc(dict->nval, sizeof(union value)); for (i = 0; i < dict->nvar; i++) { struct variable *v = dict->var[i]; if (v->get.fv == -1) continue; SET_STRING_ELT(ans_names, i, mkChar(dict->var[i]->name)); if (v->type == NUMERIC) { SET_VECTOR_ELT(ans, i, allocVector(REALSXP, inf.ncases)); } else { SET_VECTOR_ELT(ans, i, allocVector(STRSXP, inf.ncases)); case_vals[v->fv].c = (unsigned char *) R_alloc(v->width + 1, 1); ((char *) &case_vals[v->fv].c[0])[v->width] = '\0'; } } for (i = 0; i < inf.ncases; i++) { int j; sfm_read_case(fh, case_vals, dict); for (j = 0; j < dict->nvar; j++) { struct variable *v = dict->var[j]; if (v->get.fv == -1) continue; if (v->type == NUMERIC) { REAL(VECTOR_ELT(ans, j))[i] = case_vals[v->fv].f; } else { SET_STRING_ELT(VECTOR_ELT(ans, j), i, mkChar((char *)case_vals[v->fv].c)); } } } sfm_maybe_close(fh); /* get all the value labels */ PROTECT(val_labels = getSPSSvaluelabels(dict)); namesgets(val_labels, duplicate(ans_names)); setAttrib(ans, install("label.table"), val_labels); UNPROTECT(1); /* get SPSS variable labels */ PROTECT(variable_labels = allocVector(STRSXP, dict->nvar)); nvar_label = 0; for (i = 0; i < dict->nvar; i++) { char *lab = dict->var[i]->label; if (lab != NULL) { nvar_label++; SET_STRING_ELT(variable_labels, i, mkChar(lab)); } } if (nvar_label > 0) { namesgets(variable_labels, ans_names); setAttrib(ans,install("variable.labels"), variable_labels); } UNPROTECT(1); /* report missingness */ PROTECT(miss_labels = getSPSSmissing(dict, &have_miss)); if(have_miss) { namesgets(miss_labels, duplicate(ans_names)); setAttrib(ans, install("missings"), miss_labels); } UNPROTECT(1); free_dictionary(dict); setAttrib(ans, R_NamesSymbol, ans_names); setAttrib(ans, install("codepage"), ScalarInteger(inf.encoding)); UNPROTECT(2); return ans; }
static SEXP read_SPSS_PORT(const char *filename) { struct file_handle *fh = fh_get_handle_by_filename(filename); struct pfm_read_info inf; struct dictionary *dict = pfm_read_dictionary(fh, &inf); SEXP ans = PROTECT(allocVector(VECSXP, dict->nvar)); SEXP ans_names = PROTECT(allocVector(STRSXP, dict->nvar)); union value *case_vals; int i; int ncases = 0; int N = 10; int nval = 0; int nvar_label; SEXP val_labels; SEXP variable_labels; SEXP miss_labels; int have_miss = 0; /* Set the fv and lv elements of all variables in the dictionary. */ for (i = 0; i < dict->nvar; i++) { struct variable *v = dict->var[i]; v->fv = nval; nval += v->nv; } dict->nval = nval; if (!nval) error(_("nval is 0")); case_vals = (union value *) R_alloc(dict->nval, sizeof(union value)); for (i = 0; i < dict->nvar; i++) { struct variable *v = dict->var[i]; if (v->get.fv == -1) continue; SET_STRING_ELT(ans_names, i, mkChar(dict->var[i]->name)); if (v->type == NUMERIC) { SET_VECTOR_ELT(ans, i, allocVector(REALSXP, N)); } else { SET_VECTOR_ELT(ans, i, allocVector(STRSXP, N)); case_vals[v->fv].c = (unsigned char *) R_alloc(v->width + 1, 1); ((char *) &case_vals[v->fv].c[0])[v->width] = '\0'; } } while(pfm_read_case(fh, case_vals, dict)) { if (ncases == N) { N *= 2; for (i = 0; i < dict->nvar; i++) { SEXP elt = VECTOR_ELT(ans, i); elt = lengthgets(elt, N); SET_VECTOR_ELT(ans, i, elt); } } for (i = 0; i < dict->nvar; i++) { struct variable *v = dict->var[i]; if (v->get.fv == -1) continue; if (v->type == NUMERIC) { REAL(VECTOR_ELT(ans, i))[ncases] = case_vals[v->fv].f; } else { SET_STRING_ELT(VECTOR_ELT(ans, i), ncases, mkChar((char *)case_vals[v->fv].c)); } } ++ncases; } if (N != ncases) { for (i = 0; i < dict->nvar; i++) { SEXP elt = VECTOR_ELT(ans, i); elt = lengthgets(elt, ncases); SET_VECTOR_ELT(ans, i, elt); } } fh_close_handle(fh); /* get all the value labels */ PROTECT(val_labels = getSPSSvaluelabels(dict)); namesgets(val_labels, ans_names); setAttrib(ans, install("label.table"), val_labels); UNPROTECT(1); /* get SPSS variable labels */ PROTECT(variable_labels = allocVector(STRSXP, dict->nvar)); nvar_label = 0; for (i = 0; i < dict->nvar; i++) { char *lab = dict->var[i]->label; if (lab != NULL) { nvar_label++; SET_STRING_ELT(variable_labels, i, mkChar(lab)); } } if (nvar_label > 0) { namesgets(variable_labels, ans_names); setAttrib(ans, install("variable.labels"), variable_labels); } UNPROTECT(1); /* report missingness */ PROTECT(miss_labels = getSPSSmissing(dict, &have_miss)); if(have_miss) { namesgets(miss_labels, duplicate(ans_names)); setAttrib(ans, install("missings"), miss_labels); } UNPROTECT(1); free_dictionary(dict); setAttrib(ans, R_NamesSymbol, ans_names); UNPROTECT(2); return ans; }
static int ifuse_getattr(const char *path, struct stat *stbuf) { int i; int res = 0; char **info = NULL; afc_client_t afc = fuse_get_context()->private_data; afc_error_t ret = afc_get_file_info(afc, path, &info); memset(stbuf, 0, sizeof(struct stat)); if (ret != AFC_E_SUCCESS) { int e = get_afc_error_as_errno(ret); res = -e; } else if (!info) { res = -1; } else { // get file attributes from info list for (i = 0; info[i]; i += 2) { if (!strcmp(info[i], "st_size")) { stbuf->st_size = atoll(info[i+1]); } else if (!strcmp(info[i], "st_blocks")) { stbuf->st_blocks = atoi(info[i+1]); } else if (!strcmp(info[i], "st_ifmt")) { if (!strcmp(info[i+1], "S_IFREG")) { stbuf->st_mode = S_IFREG; } else if (!strcmp(info[i+1], "S_IFDIR")) { stbuf->st_mode = S_IFDIR; } else if (!strcmp(info[i+1], "S_IFLNK")) { stbuf->st_mode = S_IFLNK; } else if (!strcmp(info[i+1], "S_IFBLK")) { stbuf->st_mode = S_IFBLK; } else if (!strcmp(info[i+1], "S_IFCHR")) { stbuf->st_mode = S_IFCHR; } else if (!strcmp(info[i+1], "S_IFIFO")) { stbuf->st_mode = S_IFIFO; } else if (!strcmp(info[i+1], "S_IFSOCK")) { stbuf->st_mode = S_IFSOCK; } } else if (!strcmp(info[i], "st_nlink")) { stbuf->st_nlink = atoi(info[i+1]); } else if (!strcmp(info[i], "st_mtime")) { stbuf->st_mtime = (time_t)(atoll(info[i+1]) / 1000000000); } } free_dictionary(info); // set permission bits according to the file type if (S_ISDIR(stbuf->st_mode)) { stbuf->st_mode |= 0755; } else if (S_ISLNK(stbuf->st_mode)) { stbuf->st_mode |= 0777; } else { stbuf->st_mode |= 0644; } // and set some additional info stbuf->st_uid = getuid(); stbuf->st_gid = getgid(); stbuf->st_blksize = g_blocksize; } return res; }