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;
}
