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