static int epr_add_selector(epr_t *epr, const char *name, selector_entry *selector) { int i; Selector *p; if(epr == NULL) return 0; p = epr->refparams.selectorset.selectors; for(i = 0; i< epr->refparams.selectorset.count; i++) { if(p->name && ( strcmp(name, p->name) == 0 ) ) { return -1; } p++; } p = epr->refparams.selectorset.selectors; p = u_realloc(p, (epr->refparams.selectorset.count+1) * sizeof(Selector)); if(p == NULL) return -1; p[epr->refparams.selectorset.count].name = u_strdup(name); p[epr->refparams.selectorset.count].type = selector->type; if(selector->type == 0) { if (selector->entry.text) { p[epr->refparams.selectorset.count].value = u_strdup(selector->entry.text); } } else { p[epr->refparams.selectorset.count].value = (char *)epr_copy(selector->entry.eprp); } epr->refparams.selectorset.selectors = p; epr->refparams.selectorset.count++; return 0; }
/** * This program is designed for test purpose only. */ int main(int /*argc*/,char * /* argv*/ []) { setBufferMode(); unichar* inflected=u_strdup("abcdegfh"); unichar* lemma=u_strdup("hbc"); unichar result[1024]; return 0; }
void wsman_get_fragment_type(char *fragstr, int *fragment_flag, char **element, int *index) { char *p, *p1, *p2, *dupstr; *fragment_flag = 0; *element = NULL; *index = 0; if(fragstr == NULL) return; dupstr = u_strdup(fragstr); p = strstr(dupstr, "/text()"); if(p) { *p = '\0'; *fragment_flag = 2; *element = u_strdup(dupstr); } else { if((p1 = strstr(dupstr, "[")) && (p2 = strstr(dupstr, "]"))) { *element = u_strndup(dupstr, p1 - dupstr); *p2 = '\0'; *index = atoi(p1+1); *fragment_flag = 3; } else { *element = u_strdup(dupstr); *fragment_flag = 1; } } u_free(dupstr); }
char *wsman_transport_get_agent(WsManClient * cl) { if (cl->user_agent) return u_strdup(cl->user_agent); else return u_strdup(DEFAULT_USER_AGENT); }
/** * Prints the given hypotheses to the output, and if needed, * print the word to the modified input file. */ static void display_hypotheses(unichar* word,SpellCheckHypothesis* list,SpellCheckConfig* cfg) { Ustring* line=new_Ustring(128); int printed=0; while (list!=NULL) { printed=1; struct dela_entry* entry=tokenize_DELAF_line(list->entry); if (entry==NULL) { fatal_error("Internal error in display_hypotheses; cannot tokenize entry:\n%S\n",list->entry); } unichar* inflected=entry->inflected; entry->inflected=u_strdup(word); entry->semantic_codes[entry->n_semantic_codes++]=u_strdup("SP_ERR"); u_sprintf(line,"SP_INF=%S",inflected); entry->semantic_codes[entry->n_semantic_codes++]=u_strdup(line->str); dela_entry_to_string(line,entry); u_fprintf(cfg->out,"%S/score=%d\n",line->str,list->score); free(inflected); free_dela_entry(entry); list=list->next; } free_Ustring(line); /* Now, we may have to print the word to the modified input file */ if (cfg->input_op=='M') { /* If we must keep matched words, then we print the word if it had matched */ if (printed) u_fprintf(cfg->modified_input,"%S\n",word); } else if (cfg->input_op=='U') { /* If we must keep unmatched words, then we print the word if it had matched */ if (!printed) u_fprintf(cfg->modified_input,"%S\n",word); } }
epr_t *epr_copy(epr_t *epr) { int i; Selector *p1; Selector *p2; epr_t *cpy_epr = NULL; if(epr == NULL) return cpy_epr; cpy_epr = u_malloc(sizeof(epr_t)); if (epr && epr->address) cpy_epr->address = u_strdup(epr->address); cpy_epr->refparams.uri = u_strdup(epr->refparams.uri); cpy_epr->refparams.selectorset.count = epr->refparams.selectorset.count; cpy_epr->refparams.selectorset.selectors = u_malloc(sizeof(Selector)* epr->refparams.selectorset.count); p1 = epr->refparams.selectorset.selectors; p2 = cpy_epr->refparams.selectorset.selectors; for(i = 0; i < epr->refparams.selectorset.count; i++) { p2->name = u_strdup(p1->name); p2->type = p1->type; if(p1->type == 0) p2->value = u_strdup(p1->value); else p2->value = (char *)epr_copy((epr_t*)p1->value); p1++; p2++; } return cpy_epr; }
/** * This function allocates and returns a token_t structure corresponding to the given * string. */ token_t* new_token_t(unichar* str) { token_t* tok=(token_t*)malloc(sizeof(token_t)); if (tok==NULL) { fatal_alloc_error("new_token_t"); } for (const keyword_t* key=keywords;key->str!=NULL;key++) { if (!u_strcmp(str, key->str)) { /* If the token is a keyword */ tok->type=key->val; tok->str= NULL; tok->next=NULL; return tok; } } if (*str=='<') { /* If we have a '<', we look for the ending '>' */ unichar* p=u_strchr(str,'>'); if (p==NULL || *(p+1)!='\0') { fatal_error("Invalid token: '%S'\n",str); } *p='\0'; tok->type=TOK_ANGLE; /* We copy the content between the angle brackets */ tok->str=u_strdup(str+1); tok->next=NULL; return tok; } /* Otherwise, we create a default token with the string */ tok->type=TOK_STR; tok->str=u_strdup(str); tok->next=NULL; return tok; }
/** * \brief create a \c klog_args_t object with configuration parameters read * from a log subsection of a kloned configuration file * * \param ls a log configuration record * \param pka the corresponding \c klog_args_t object as a value-result * argument * \return * - \c 0 success * - \c ~0 on failure (\p pka MUST not be referenced) */ int klog_args (u_config_t *ls, klog_args_t **pka) { const char *cs; klog_args_t *ka = NULL; dbg_return_if (ls == NULL, ~0); dbg_return_if (pka == NULL, ~0); /* here defaults are set */ dbg_err_if (klog_args_new(&ka)); /* read in config values */ ka->type = klog_type(u_config_get_subkey_value(ls, "type")); if ((cs = u_config_get_subkey_value(ls, "ident")) != NULL) ka->ident = u_strdup(cs); ka->threshold = klog_threshold(u_config_get_subkey_value(ls, "threshold")); if ((cs = u_config_get_subkey_value(ls, "memory.limit")) != NULL) { dbg_err_ifm (u_atoi(cs, &ka->mlimit), "'memory.limit' bad value: %s", cs); } if ((cs = u_config_get_subkey_value(ls, "file.basename")) != NULL) ka->fbasename = u_strdup(cs); if ((cs = u_config_get_subkey_value(ls, "file.limit")) != NULL) { dbg_err_ifm (u_atoi(cs, &ka->flimit), "'file.limit' bad value: %s", cs); } if ((cs = u_config_get_subkey_value(ls, "file.splits")) != NULL) { dbg_err_ifm (u_atoi(cs, &ka->fsplits), "'file.splits' bad value: %s", cs); } #ifdef HAVE_SYSLOG ka->sfacility = klog_facility(ka, u_config_get_subkey_value(ls, "syslog.facility")); ka->soptions = klog_logopt(u_config_get_subkey_value(ls, "syslog.options")); #endif dbg_return_if (klog_args_check(ka), ~0); *pka = ka; return 0; err: if (ka) klog_args_free(ka); return ~0; }
/** * This function takes a unicode string representing a regular expression and * compiles it into a .grf file. It returns 1 in case of success; 0 otherwise. */ int reg2grf(const unichar* regexp,const char* name_grf, const VersatileEncodingConfig* vec) { if (regexp[0]=='\0') { error("You must specify a non empty regular expression\n"); return 0; } U_FILE* out=u_fopen(vec,name_grf,U_WRITE); if (out==NULL) { error("Cannot open the output file for the regular expression\n"); return 0; } struct reg2grf_info* INFO=new_reg2grf_info(); /* We create the initial and final states that must have numbers 0 and 1 */ add_state(INFO,u_strdup("<E>")); add_state(INFO,u_strdup("")); /* We print the grf header */ u_fprintf(out,"#Unigraph\n"); u_fprintf(out,"SIZE 1313 950\n"); u_fprintf(out,"FONT Times New Roman: 12\n"); u_fprintf(out,"OFONT Times New Roman:B 12\n"); u_fprintf(out,"BCOLOR 16777215\n"); u_fprintf(out,"FCOLOR 0\n"); u_fprintf(out,"ACOLOR 12632256\n"); u_fprintf(out,"SCOLOR 16711680\n"); u_fprintf(out,"CCOLOR 255\n"); u_fprintf(out,"DBOXES y\n"); u_fprintf(out,"DFRAME y\n"); u_fprintf(out,"DDATE y\n"); u_fprintf(out,"DFILE y\n"); u_fprintf(out,"DDIR y\n"); u_fprintf(out,"DRIG n\n"); u_fprintf(out,"DRST n\n"); u_fprintf(out,"FITS 100\n"); u_fprintf(out,"PORIENT L\n"); u_fprintf(out,"#\n"); int input_state; int output_state; int result=reg_2_grf(regexp,&input_state,&output_state,INFO); if (result!=1) { u_fclose(out); af_remove(name_grf); free_reg2grf_info(INFO); if (result==0) { error("Syntax error in regular expression\n"); } return 0; } /* If the compilation has successed, we must link the resulting automaton piece * to the grf's initial and final states */ add_transition(0,input_state,INFO); add_transition(output_state,1,INFO); save_states(out,INFO); free_reg2grf_info(INFO); u_fclose(out); return 1; }
/** * This function moves outputs from final nodes to transitions leading to final nodes. */ static void subsequential_to_normal_transducer(struct dictionary_node* root, struct dictionary_node* node, struct string_hash* inf_codes, int pos,unichar* z, Ustring* normalizedOutput) { struct dictionary_node_transition* tmp=node->trans; int prefix_set=0; Ustring* prefix=new_Ustring(); while (tmp!=NULL) { z[pos]=tmp->letter; z[pos+1]='\0'; subsequential_to_normal_transducer(root,tmp->node,inf_codes,pos+1,z,normalizedOutput); /* First, if the destination state is final, we place its output on the output * of the current transition */ if (tmp->node->single_INF_code_list!=NULL) { //error("<%S>: output=<%S>\n",z,normalizedOutput->str); tmp->output=u_strdup(inf_codes->value[tmp->node->INF_code]); } if (normalizedOutput->len!=0) { /* Then, we add the normalized output obtained recursively, if any */ //error("<%S>: moving normalized output <%S>\n",z,normalizedOutput->str); if (tmp->output==NULL) { tmp->output=u_strdup(normalizedOutput->str); } else { tmp->output=(unichar*)realloc(tmp->output,sizeof(unichar)*(1+normalizedOutput->len+u_strlen(tmp->output))); } } if (!prefix_set) { prefix_set=1; u_strcpy(prefix,tmp->output); } else { get_longest_common_prefix(prefix,tmp->output); } tmp=tmp->next; } if (node==root || node->single_INF_code_list!=NULL) { /* If we are in the initial state or a final one, we let the transitions as they are, since * their outputs can not move more to the left */ z[pos]='\0'; free_Ustring(prefix); empty(normalizedOutput); return; } tmp=node->trans; while (tmp!=NULL) { //error("prefix removal: <%S> => ",tmp->output); remove_prefix(prefix->len,tmp->output); //error("<%S>\n",tmp->output); tmp=tmp->next; } z[pos]='\0'; u_strcpy(normalizedOutput,prefix); free_Ustring(prefix); }
/** * Set the range's name to a new value * @param r the range in question * @param name the new name (maybe like the old one) * @return 1 if it worked, else 0 */ int range_set_name( range *r, UChar *name ) { if ( r->name == NULL ) r->name = u_strdup( name ); else if ( u_strcmp(r->name,name)!= 0 ) { free( r->name ); r->name = u_strdup( name ); } return r->name != NULL; }
/** * * @param n_props number of properties (html_tags+property-names) * @param properties array of props and html tag names alternately * @return an initialised matrix */ matrix *matrix_create( int n_props, UChar **properties ) { matrix *m = calloc(1,sizeof(matrix) ); if ( m != NULL ) { m->n_props = n_props/2; m->names = calloc( m->n_props, sizeof(UChar*) ); m->html_tags = calloc( m->n_props, sizeof(UChar*) ); if ( m->names != NULL && m->html_tags != NULL ) { int i,j; for ( j=0,i=0;i<n_props-1;j++,i+=2 ) { m->names[j] = u_strdup(properties[i]); //printf("%s\n",properties[i]); m->html_tags[j] = (properties[i+1]==NULL) ?NULL:u_strdup(properties[i+1]); } m->cells = (int*)calloc( m->n_props*m->n_props, sizeof(int) ); if ( m->cells == NULL ) { matrix_dispose( m ); m = NULL; warning("failed to allocate %dx%d matrix\n",n_props,n_props); } else { m->lookup = hashset_create(); if ( m->lookup == NULL ) { matrix_dispose( m ); m = NULL; } else { int k; for ( k=0;k<m->n_props;k++ ) { hashset_put( m->lookup, m->names[k] ); } } } } else { warning("matrix: failed to allocate names and tags\n"); matrix_dispose( m ); m = NULL; } } return m; }
void key_value_copy(const key_value_t *from, key_value_t *to) { if (from->key) to->key = u_strdup(from->key); else to->key = NULL; to->type = from->type; if (from->type == 0) to->v.text = u_strdup(from->v.text); else to->v.epr = epr_copy(from->v.epr); }
/** * Allocates, initializes and returns a new corpus_entry structure. */ struct corpus_entry* new_corpus_entry(const unichar* line){ struct corpus_entry* entry = (corpus_entry*)malloc(sizeof(corpus_entry)); if(entry == NULL){ fatal_alloc_error("compute_corpus_entry"); } /* we fill corpus entry with information extracted from the corpus line*/ int pos = u_strrchr(line,'/'); if(pos == -1){ fatal_error("Wrong format for line %S\n",line); } entry->word = (unichar*)malloc(sizeof(unichar)*(pos+1)); if(entry->word == NULL){ fatal_alloc_error("compute_corpus_entry"); } unichar* tmp = u_strcpy_sized(entry->word,pos+1,line); u_strcat(tmp,"\0"); int code_pos = u_strrchr(line,':'); /* there are no morphological codes associated to this entry */ if(code_pos == -1){ entry->pos_code = (unichar*)malloc(sizeof(unichar)*(u_strlen(line)-pos)); if(entry->pos_code == NULL){ fatal_alloc_error("new_corpus_entry"); } u_strcpy(entry->pos_code,&line[pos+1]); entry->overall_codes = u_strdup(entry->pos_code); } else{ entry->pos_code = (unichar*)malloc(sizeof(unichar)*(code_pos-pos)); if(entry->pos_code == NULL){ fatal_alloc_error("new_corpus_entry"); } entry->overall_codes = (unichar*)malloc(sizeof(unichar)*(u_strlen(line)-pos)); if(entry->overall_codes == NULL){ fatal_alloc_error("new_corpus_entry"); } unichar* tmp2 = u_strcpy_sized(entry->pos_code,code_pos-pos,&line[pos+1]); u_strcat(tmp2,"\0"); u_strcpy(entry->overall_codes,&line[pos+1]); } /* if the token is not annotated in the corpus, we put "UNK" */ if(u_strlen(entry->pos_code) == 0){ free(entry->pos_code); free(entry->overall_codes); entry->pos_code = u_strdup("UNK"); entry->overall_codes = u_strdup("UNK"); } return entry; }
////////////////////////////////////////////////////////////////////////////////// // If variable "var" already instantiated, returns -1. Otherwise, // instantiates the unification variable "var" to category "cat" and value "val". // Returns 1 or -1 in case of error, 0 otherwise. int unif_instantiate(MultiFlex_ctx* p_multiFlex_ctx,unichar* var, l_category_T* cat, unichar* val) { int i; int v; //Check if not yet instantiated. if (unif_instantiated(p_multiFlex_ctx,var)) return -1; i = (p_multiFlex_ctx->UNIF_VARS).no_vars; //Category (p_multiFlex_ctx->UNIF_VARS).vars[i].cat = cat; //value v = is_valid_val(cat,val); if (v == -1) { error("Instantiation impossible: %S is an invalid value in category %S.\n",val,cat->name); return 1; } (p_multiFlex_ctx->UNIF_VARS).vars[i].val = v; //id (p_multiFlex_ctx->UNIF_VARS).vars[i].id = u_strdup(var); (p_multiFlex_ctx->UNIF_VARS).no_vars++; return 0; }
/* map threshold directive to the internal representation */ static int klog_logopt (const char *options) { char *o2 = NULL; /* 'options' dupped for safe u_tokenize() */ int i, logopt = 0; enum { NOPTS = 4 }; char *optv[NOPTS + 1]; dbg_return_if (options == NULL, 0); dbg_return_if ((o2 = u_strdup(options)) == NULL, 0); dbg_err_if (u_tokenize(o2, " \t", optv, NOPTS + 1)); for (i = 0; optv[i] != NULL; i++) { if (!strcasecmp(optv[i], "LOG_CONS")) logopt |= LOG_CONS; else if (!strcasecmp(optv[i], "LOG_NDELAY")) logopt |= LOG_NDELAY; #ifdef HAVE_LOG_PERROR else if (!strcasecmp(optv[i], "LOG_PERROR")) logopt |= LOG_PERROR; #endif /* HAVE_LOG_PERROR */ else if (!strcasecmp(optv[i], "LOG_PID")) logopt |= LOG_PID; else warn("bad log option: \'%s\'", optv[i]); } U_FREE(o2); return logopt; err: U_FREE(o2); return 0; }
void lemmatize(struct dela_entry* e,struct string_hash_ptr* keywords,Alphabet* alphabet) { unichar* lower=u_strdup(e->inflected); u_tolower(lower); KeyWord* k_inflected=(KeyWord*)get_value(lower,keywords); free(lower); if (k_inflected==NULL) return; Ustring* tmp=new_Ustring(64); u_sprintf(tmp,"%S.%S",e->lemma,e->semantic_codes[0]); KeyWord* k_lemma=(KeyWord*)get_value(tmp->str,keywords); if (k_lemma==NULL) { k_lemma=new_KeyWord(0,tmp->str,NULL); k_lemma->lemmatized=LEMMATIZED_KEYWORD; get_value_index(tmp->str,keywords,INSERT_IF_NEEDED,k_lemma); } /* Now, we look for all the case compatible tokens, and we add * their weights to the new lemmatized element */ while (k_inflected!=NULL) { if (k_inflected->sequence!=NULL && is_equal_or_uppercase(e->inflected,k_inflected->sequence,alphabet)) { /* We have a match */ k_lemma->weight+=k_inflected->weight; k_inflected->lemmatized=1; } k_inflected=k_inflected->next; } free_Ustring(tmp); }
bool sysfile_setRootPath(const char *name) { char *path = u_strdup(name); if (!path) { return false; } rootPath.name = str_toNativeSeparators(path); #ifdef ENABLE_ZIP if (str_hasZipExtension(rootPath.name)) { rootPath.zip = unzOpen(rootPath.name); if (!rootPath.zip) { sys_error("(sysfile) can not open zip file \"%s\"",rootPath.name); return false; } } else /* dealing with a directory */ { /* FIXME check that it is a valid directory */ rootPath.zip = NULL; } #endif /* ENABLE_ZIP */ return true; }
/** * Create a single range * @param name the name of the property * @param html_name the range's mapped html name * @param start its start offset inside the text * @param len its length * @return the finished range */ range *range_create( UChar *name, UChar *html_name, int start, int len ) { range *r = calloc( 1, sizeof(range) ); if ( r != NULL ) { r->name = u_strdup(name); if ( html_name != NULL ) r->html_name = u_strdup( html_name ); r->start = start; r->len = len; r->rightmost = 1; } else warning("range creation failed\n"); return r; }
////////////////////////////////////////////////////////////////////////////////// // If variable "var" already instantiated, returns -1. Otherwise, // instantiates the unification variable "var" to category "cat" and value "val". // Returns 1 or -1 in case of error, 0 otherwise. int unif_instantiate(unif_vars_T* UNIF_VARS,unichar* var, l_category_T* cat, unichar* val) { int i; int v; //Check if not yet instantiated. if (unif_instantiated(UNIF_VARS,var)) return -1; i = UNIF_VARS->no_vars; //Category UNIF_VARS->vars[i].cat = cat; //value v = is_valid_val(cat,val); if (v == -1) { error("Instantiation impossible: %S is an invalid value in category %S.\n",val,cat->name); return 1; } UNIF_VARS->vars[i].val = v; //id UNIF_VARS->vars[i].id = u_strdup(var); UNIF_VARS->no_vars++; return 0; }
int WsManTest_EventPoll_EP(WsEventThreadContextH threadcntx) { int retval = 0; WsNotificationInfoH notificationinfo = u_malloc(sizeof(*notificationinfo)); if(notificationinfo == NULL) return -1; notificationinfo->headerOpaqueData = ws_xml_create_doc( XML_NS_OPENWSMAN"/test", "EventTopics"); WsXmlNodeH node = ws_xml_get_doc_root(notificationinfo->headerOpaqueData); if(node) { ws_xml_set_node_text(node, "openwsman.event.test"); } notificationinfo->EventAction = u_strdup(XML_NS_OPENWSMAN"/EventReport"); notificationinfo->EventContent = ws_xml_create_doc( XML_NS_OPENWSMAN"/test", "TestReport"); if(notificationinfo->EventContent == NULL) return retval; node = ws_xml_get_doc_root(notificationinfo->EventContent); time_t timest = time(0); struct tm tm; localtime_r(×t, &tm); ws_xml_add_child_format(node, XML_NS_OPENWSMAN"/test", "EventTime","%u-%u%u-%u%uT%u%u:%u%u:%u%u", tm.tm_year + 1900, (tm.tm_mon + 1)/10, (tm.tm_mon + 1)%10, tm.tm_mday/10, tm.tm_mday%10, tm.tm_hour/10, tm.tm_hour%10, tm.tm_min/10, tm.tm_min%10, tm.tm_sec/10, tm.tm_sec%10); EventPoolOpSetH opset = threadcntx->soap->eventpoolOpSet; if(threadcntx->subsInfo->deliveryMode == WS_EVENT_DELIVERY_MODE_PULL) retval = opset->addpull(threadcntx->subsInfo->subsId, notificationinfo); else retval = opset->add(threadcntx->subsInfo->subsId, notificationinfo); if(retval) { u_free(notificationinfo->EventAction); ws_xml_destroy_doc(notificationinfo->EventContent); ws_xml_destroy_doc(notificationinfo->headerOpaqueData); u_free(notificationinfo); } return 0; }
char * wsman_get_option_set(WsContextH cntx, WsXmlDocH doc, const char *op) { char *optval = NULL; int index = 0; WsXmlNodeH node, option; if (doc == NULL) { doc = cntx->indoc; if (!doc) return NULL; } node = ws_xml_get_soap_header(doc); if (node && (node = ws_xml_get_child(node, 0, XML_NS_WS_MAN, WSM_OPTION_SET))) { while ((option = ws_xml_get_child(node, index++, XML_NS_WS_MAN, WSM_OPTION))) { char *attrVal = ws_xml_find_attr_value(option, NULL, WSM_NAME); if (attrVal && strcmp(attrVal, op ) == 0 ) { optval = ws_xml_get_node_text(option); if (optval[0] == 0) optval = "true"; optval = u_strdup(optval); debug("Option: %s=%s", attrVal, optval); break; } } } return optval; }
epr_t *epr_create(const char *uri, hash_t * selectors, const char *address) { epr_t *epr = NULL; epr = u_malloc(sizeof(epr_t)); if (address == NULL) epr->address = u_strdup(WSA_TO_ANONYMOUS); else epr->address = u_strdup(address); epr->refparams.uri = u_strdup(uri); if (selectors) { hnode_t *hn; hscan_t hs; Selector *p; selector_entry *entry; epr->refparams.selectorset.count = hash_count(selectors); epr->refparams.selectorset.selectors = u_malloc(sizeof(Selector)* epr->refparams.selectorset.count); p = epr->refparams.selectorset.selectors; hash_scan_begin(&hs, selectors); while ((hn = hash_scan_next(&hs))) { p->name = u_strdup((char *)hnode_getkey(hn)); entry = (selector_entry *)hnode_get(hn); if(entry->type == 0) { p->type = 0; p->value = u_strdup(entry->entry.text); debug("key = %s value=%s", (char *) hnode_getkey(hn), p->value); } else { p->type = 1; p->value = (char *)epr_copy(entry->entry.eprp); debug("key = %s value=%p(nested epr)", (char *) hnode_getkey(hn), p->value); } p++; } } else { epr->refparams.selectorset.count = 0; epr->refparams.selectorset.selectors = NULL; } return epr; }
/** * Returns a clone of the pattern. */ struct pattern* clone(const struct pattern* src,Abstract_allocator prv_alloc) { struct pattern* dst; if (src == NULL) return NULL; dst=(struct pattern*)malloc_cb(sizeof(struct pattern),prv_alloc); if (dst==NULL) { fatal_error("Not enough memory in new_pattern_ByCopy\n"); } dst->inflected=u_strdup(src->inflected,prv_alloc); dst->lemma=u_strdup(src->lemma,prv_alloc); dst->grammatical_codes=clone(src->grammatical_codes,prv_alloc); dst->inflectional_codes=clone(src->inflectional_codes,prv_alloc); dst->forbidden_codes=clone(src->forbidden_codes,prv_alloc); dst->type=src->type; return dst; }
/** * Allocates, initializes and returns a new tagset_t structure. */ tagset_t* new_tagset_t(unichar* name) { tagset_t* tree=(tagset_t*)malloc(sizeof(tagset_t)); if (tree==NULL) { fatal_alloc_error("new_tagset_t"); } tree->name=u_strdup(name); tree->pos_sections=NULL; return tree; }
static char * wsmc_create_delivery_mode_str(WsmanDeliveryMode mode) { char * str = NULL; switch(mode) { case WSMAN_DELIVERY_PUSH: str = u_strdup(WSEVENT_DELIVERY_MODE_PUSH); break; case WSMAN_DELIVERY_PUSHWITHACK: str = u_strdup(WSEVENT_DELIVERY_MODE_PUSHWITHACK); break; case WSMAN_DELIVERY_EVENTS: str = u_strdup(WSEVENT_DELIVERY_MODE_EVENTS); break; case WSMAN_DELIVERY_PULL: str = u_strdup(WSEVENT_DELIVERY_MODE_PULL); } return str; }
/** * Allocates, initializes and returns a new norm_info structure. */ struct norm_info* new_norm_info(const unichar* output,struct normalization_tree* n) { struct norm_info* t=(struct norm_info*)malloc(sizeof(struct norm_info)); if (t==NULL) { fatal_alloc_error("new_norm_info"); } t->output=u_strdup(output); t->node=n; t->next=NULL; return t; }
/** * Frees all the memory associated to the given matrix of corpus_entry structure. */ void initialize_context_matrix(struct corpus_entry** context){ for(int i=0;i<MAX_CONTEXT;i++){ if(context[i] != NULL){ free_corpus_entry(context[i]); } unichar* str = u_strdup("#/#"); context[i] = new_corpus_entry(str); free(str); } }
/** * Allocates, initializes and returns a new debug tfst_match. */ struct tfst_match* new_debug_tfst_match(const unichar* output,struct tfst_match* next) { struct tfst_match* match=(struct tfst_match*)malloc(sizeof(struct tfst_match)); if (match==NULL) { fatal_alloc_error("new_debug_tfst_match"); } match->debug_output=u_strdup(output); match->fst2_transition=NULL; match->text_tag_numbers=NULL; match->next=next; return match; }
/** * Allocates, initializes and returns a new couple. */ struct couple* new_couple(unichar* s) { struct couple* c = (struct couple*) malloc(sizeof(struct couple)); if (c == NULL) { alloc_error("new_couple"); return NULL; } c->next = NULL; c->n = 1; c->s = u_strdup(s); return c; }