int add_set(char * name, char * mode) { int nmode = 0; if(strncmp(mode, "FAILOVER", strlen("FAILOVER")) == 0) nmode = FAILOVER; else if(strncmp(mode, "PARALLEL", strlen("PARALLEL")) == 0) nmode = PARALLEL; else if(strncmp(mode, "ROUND", strlen("ROUND")) == 0) nmode = ROUND; LM_DBG("add set=%s mode=%i\n", name, nmode); if (!global) { global = shm_malloc(sizeof *global); if (!global) MEM_ERR(MEM_SHM); memset(global, 0, sizeof *global); } /* realloc set_list */ int i = global->size; global->set_list = (info_set_t *)shm_realloc(global->set_list, (i+1)*sizeof(info_set_t)); if(!global->set_list) MEM_ERR(MEM_SHM); memset(&global->set_list[i], 0, sizeof *global->set_list); global->size++; global->set_list[i].set_name.s = (char *) shm_malloc(strlen(name)*sizeof(char)); global->set_list[i].set_name.len = strlen(name); memcpy(global->set_list[i].set_name.s, name, strlen(name)); /* set mode */ global->set_list[i].set_mode = nmode; global->set_list[i].size = 0; return 0; error: return 1; }
int add_url(int index, char * name) { LM_DBG("add url (%i . %s)\n", index, name); int i; LM_DBG("add another url %p\n", global->set_list[index].db_list); /* realoc */ i = global->set_list[index].size; /* db_list realloc */ global->set_list[index].db_list = (info_db_t *) shm_realloc(global->set_list[index].db_list, (i+1)* sizeof(info_db_t)); if(!global->set_list[index].db_list) MEM_ERR(MEM_SHM); global->set_list[index].size++; /* db_url */ global->set_list[index].db_list[i].db_url.s = (char *) shm_malloc(strlen(name) * sizeof(char)); global->set_list[index].db_list[i].db_url.len = strlen(name); memcpy(global->set_list[index].db_list[i].db_url.s, name, strlen(name)); global->set_list[index].db_list[i].flags = CAN_USE | MAY_USE; return 0; error: return 1; }
/*--------------------------------------------------------------------------- gamma.c (create_rules) called by standard.l (init_stand_process) calls util.c (open_aux_file) calls gamma.c (initialize_link, is_input_symbol, is_output_symbol, classify_link,precompute_gamma_function) ----------------------------------------------------------------------------*/ RULE_PARAM *create_rules( const char *rule_name , PAGC_GLOBAL *glo_p ) { /* -- returns size of Gamma Function Matrix -- */ SYMB a , t ; NODE u ; int i , w ; int is_eof = FALSE ; int rule_number = 0 ; int last_node = EPSILON ; FILE *rule_file ; SYMB *rule_start , *rule_end , *r ; KW *keyw , *k_s ; KW ***o_l ; NODE **Trie ; SYMB *r_s ; RULE_PARAM *r_p ; ERR_PARAM *err_p ; err_p = glo_p -> process_errors ; PAGC_ALLOC_STRUC(r_p,RULE_PARAM,err_p,NULL) ; /* -- initialize the statistics record -- */ r_p -> collect_statistics = FALSE ; r_p -> total_best_keys = 0 ; r_p -> total_key_hits = 0 ; /* -- open the rule file, if possible -- */ if ( ( rule_file = open_aux_file( glo_p , rule_name ) ) == NULL ) { return NULL ; } /* -- rule file has the format of i i ... i -1 o o ... o -1 t f -- */ /* -- storage for input and output records -- */ PAGC_CALLOC_STRUC(r_s,SYMB,RULESPACESIZE,err_p,NULL); /* -- storage for temporary trie for rules -- */ PAGC_CALLOC_STRUC(Trie,NODE *,MAXNODES,err_p,NULL); /* -- initialize the first( EPSILON ) node of the trie -- */ PAGC_CALLOC_STRUC(Trie[EPSILON],NODE,MAXINSYM,err_p,NULL); for ( a = 0 ; a < MAXINSYM ; a++ ) { Trie[ EPSILON ][ a ] = FAIL ; } /* -- storage for global output_link -- */ PAGC_CALLOC_STRUC(o_l,KW **,MAXNODES,err_p,NULL); PAGC_CALLOC_STRUC(k_s,KW,MAXRULES,err_p,NULL); rule_end = r_s + RULESPACESIZE ; if ( !initialize_link( err_p , o_l , EPSILON ) ) { return NULL ; } for ( r = r_s ; !feof( rule_file ) ; r++, rule_number++ ) { if ( rule_number >= MAXRULES ) { CLIENT_ERR( err_p ) ; RET_ERR( "create_rules: Too many rules in file", err_p, NULL) ; } keyw = k_s + rule_number ; MEM_ERR(keyw,err_p,NULL); /* -- get input record -- */ u = EPSILON ; rule_start = r ; /* -- save rule start for inclusion in record -- */ if ( rule_start > rule_end ) { RET_ERR( "create_rules: Too many rules for allocated memory", err_p, NULL ) ; } for ( i = 0 ; ; i++, r++ ) { /* -- read the first integer -- */ fscanf( rule_file, "%d", r ) ; /* -- a fail at the beginning of a field indicates end of record unless it's at the beginning of the record, in which case it's the end of file -- */ if ( *r == FAIL ) { if ( i == 0 ) { is_eof = TRUE ; } break ; } /* -- check the input -- */ if ( !is_input_symbol( *r ) ) { CLIENT_ERR( err_p ) ; RET_ERR2( "create_rules: Rule file: Bad Input Token %d at rule %d", *r, rule_number , err_p, NULL ) ; } /* -- build the trie structure -- */ if ( Trie[ u ][ *r ] == FAIL ) { if ( ++last_node >= MAXNODES ) { RET_ERR( "create_rules: Too many nodes in gamma function", err_p, NULL ) ; } Trie[ u ][ *r ] = last_node ; PAGC_CALLOC_STRUC(Trie[last_node],NODE,MAXINSYM,err_p,NULL) ; for ( a = 0 ; a < MAXINSYM ; a++ ) { Trie[ last_node ][ a ] = FAIL ; } if ( !initialize_link( err_p , o_l , last_node ) ) { return NULL ; } } u = Trie[ u ][ *r ] ; } if ( is_eof ) break ; keyw -> Input = rule_start ; if ( ( keyw -> Length = i ) == 0 ) { CLIENT_ERR( err_p ) ; RET_ERR1( "create_rules: Error Rule File: 0 length rule #%d", rule_number, err_p, NULL ) ; } /* -- read the output tokens into the rule_space -- */ r++ ; /* -- move to beginning of the output tokens -- */ rule_start = r ; /* -- remember the beginning -- */ while ( TRUE ) { fscanf( rule_file, "%d", r ) ; if ( *r == FAIL ) break ; if ( !is_output_symbol( *r ) ) { RET_ERR2( "create_rules: Rule File: Non-Token %d in Rule #%d\n", *r , rule_number, err_p, NULL ) ; } r++ ; } keyw -> Output = rule_start ; /* -- classify the output -- */ fscanf( rule_file , "%d" , &t ) ; fscanf( rule_file , "%d" , &w ) ; classify_link( r_p , o_l , keyw , u , w , t ) ; } /* -- end of file read -- */ r_p -> rule_space = r_s ; r_p -> key_space = k_s ; r_p -> output_link = o_l ; r_p -> rules_read = rule_number ; fclose( rule_file ) ; if ( ++last_node >= MAXNODES ) { RET_ERR( "create_rules: Too many nodes in gamma function" , err_p, NULL) ; } /* -- change the EPSILON node transitions in preparation for Gamma -- */ for ( a = 0 ; a < MAXINSYM ; a++ ) { if ( Trie[ EPSILON ][ a ] == FAIL ) { Trie[ EPSILON ][ a ] = EPSILON ; } } /* -- create the global Gamma function matrix -- */ if ( ( r_p -> gamma_matrix = precompute_gamma_function( err_p, Trie , o_l , last_node ) ) == NULL ) { return NULL ; } /* -- no longer need the Trie -- */ PAGC_DESTROY_2D_ARRAY(Trie,NODE,last_node) ; r_p -> num_nodes = last_node ; if ( glo_p -> log_init ) { CLIENT_ERR( err_p ) ; LOG_MESS2( "create_rules: Rules installed with %d nodes and %d rules", last_node , rule_number , err_p ) ; } return r_p ; }
int rules_add_rule(RULES *rules, int num, int *rule) { int i , w ; SYMB a , t ; SYMB *rule_start , *r ; NODE u ; NODE **Trie ; KW *keyw , *k_s ; KW ***o_l ; if ( !rules ) return 1; /* error rules obj not initialized */ if ( !rules -> r_p ) return 2; /* RULE_PARAM not allocated */ if ( rules -> ready ) return 3; /* rules have already be readied */ if ( rules -> rule_number >= MAXRULES ) { RET_ERR( "rules_add_rule: Too many rules are being added.", rules -> err_p, 4); } /* get local copies of stuff saved in RULES */ o_l = rules -> r_p -> output_link ; k_s = rules -> r_p -> key_space ; Trie = rules -> Trie ; r = rules -> r ; keyw = k_s + rules -> rule_number ; MEM_ERR(keyw, rules -> err_p, 5); u = EPSILON ; rule_start = r ; /* save rule start for inclusion in the record */ if ( rule_start > rules -> rule_end ) { RET_ERR( "rules_add_rule: Too many rules for allocated memory.", rules -> err_p, 5); } for (i=0; ; i++, r++ ) { if (i >= num) { RET_ERR( "rules_add_rule: invalid rule structure.", rules -> err_p, 6); } *r = rule[i] ; /* -- a fail at the beginning of a field indicates end of record unless it's at the beginning of the record, in which case it's the end of file -- */ if ( *r == FAIL ) { if ( i == 0 ) return 0; break; } /* -- check the input -- */ if ( !is_input_symbol( *r ) ) { RET_ERR2( "rules_add_rule: Bad Input Token %d at rule %d", *r, rules -> rule_number , rules -> err_p, 7 ) ; } /* -- build the trie structure -- */ if ( Trie[ u ][ *r ] == FAIL ) { if ( ++rules -> last_node >= MAXNODES ) { RET_ERR( "rules_add_rule: Too many nodes in gamma function", rules -> err_p, 8 ) ; } Trie[ u ][ *r ] = rules -> last_node ; PAGC_CALLOC_STRUC(Trie[rules -> last_node],NODE,MAXINSYM,rules -> err_p,9) ; for ( a = 0 ; a < MAXINSYM ; a++ ) { Trie[ rules -> last_node ][ a ] = FAIL ; } if ( !initialize_link( rules -> err_p , o_l , rules -> last_node ) ) { return 10; } } u = Trie[ u ][ *r ] ; } /* end of for loop */ keyw -> Input = rule_start ; if ( ( keyw -> Length = i ) == 0 ) { RET_ERR1( "rules_add_rule: Error 0 length rule #%d", rules -> rule_number, rules -> err_p, 11 ) ; } /* -- read the output tokens into the rule_space -- */ r++ ; /* -- move to beginning of the output tokens -- */ rule_start = r ; /* -- remember the beginning -- */ while ( TRUE ) { i++; if ( i >= num ) { RET_ERR( "rules_add_rule: invalid rule structure.", rules -> err_p, 6); } *r = rule[i] ; if ( *r == FAIL ) break; if ( !is_output_symbol( *r ) ) { RET_ERR2( "rules_add_rule: Rule File: Non-Token %d in Rule #%d\n", *r , rules -> rule_number, rules -> err_p, 7 ) ; } r++ ; } keyw -> Output = rule_start ; /* -- classify the output -- */ i++ ; t = rule[i] ; i++ ; w = rule[i] ; classify_link( rules -> r_p , o_l , keyw , u , w , t ) ; rules -> rule_number++ ; rules -> r = ++r ; ; return 0; }
int add_set(char * name, char * mode){ int nmode = 0; if(strncmp(mode, "FAILOVER", strlen("FAILOVER")) == 0) nmode = FAILOVER; else if(strncmp(mode, "PARALLEL", strlen("PARALLEL")) == 0) nmode = PARALLEL; else if(strncmp(mode, "ROUND", strlen("ROUND")) == 0) nmode = ROUND; LM_DBG("add set=%s mode=%i\n", name, nmode); if(global){ LM_DBG("realloc\n"); /* realoc set_list */ int i = global->size; global->set_list = (info_set_t *)shm_realloc(global->set_list, (i+1)*sizeof(info_set_t)); if(!global->set_list) MEM_ERR(MEM_SHM); global->size +=1; global->set_list[i].set_name.s = (char *) shm_malloc(strlen(name)*sizeof(char)); global->set_list[i].set_name.len = strlen(name); memcpy(global->set_list[i].set_name.s, name, strlen(name)); /* set mode */ global->set_list[i].set_mode = nmode; global->set_list[i].size = 0 ; }else{ LM_DBG("alloc %p %i\n", global, (int)sizeof(info_global_t)); /* alloc global */ LM_DBG("alloc %p\n", global); global = (info_global_t *) shm_malloc (1 * sizeof(info_global_t)); LM_DBG("alloc %p\n", global); if(!global) MEM_ERR(MEM_SHM); memset(global, 0, 1 * sizeof(info_global_t)); LM_DBG("alloc done\n"); /* alloc set array */ global->set_list = (info_set_t *) shm_malloc (1 * sizeof(info_set_t)); if(!global->set_list) MEM_ERR(MEM_SHM); memset(global->set_list, 0, 1 * sizeof(info_set_t)); /* set array size */ global->size = 1; /* alloc set name */ global->set_list[0].set_name.s = (char *) shm_malloc(strlen(name)*sizeof(char)); global->set_list[0].set_name.len = strlen(name); memcpy(global->set_list[0].set_name.s, name, strlen(name)); /* set mode */ global->set_list[0].set_mode = nmode; /* set size */ global->set_list[0].size=0; } return 0; error: return 1; }