void fill_predict_set(void)
{
GRAMMAR *G_ptr;
TOKEN *ptr , *first , *follow , *predict;
SET *set_ptr , *set_srtat , *set_end;
predict = (TOKEN*) malloc(sizeof(TOKEN));
predict->set = NULL;
predict->next = NULL;
strncpy( predict->string , "predict" , strlen("predict")+1 );
for ( G_ptr = G_start ; G_ptr != NULL ; G_ptr = G_ptr->next )
{
set_srtat = NULL;
set_end = NULL;
//predict = search_token( predict_set_start , G_ptr->lhs );
for ( ptr = G_ptr->rhs_string ; ptr != NULL ; ptr = ptr->next )
{
first = search_token( first_set_start , ptr->string );
if ( first == NULL )
{
continue;
}
else if ( search_set( first , "£f" ) == TRUE )
{
add_set( predict , first );
delete_set( &(predict->set) , "£f" );
continue;
}
else
{
add_set( predict , first );
break;
}
}
if ( ptr == NULL )
{
follow = search_token( follow_set_start , G_ptr->lhs );
add_set( predict , follow );
}
for( set_ptr = predict->set ; set_ptr != NULL ; set_ptr = set_ptr->next )
{
insert_predict( &set_srtat , &set_end , set_ptr->string );
//printf("%s ",set_ptr->string);
}
G_ptr->set = set_srtat;
//printf("\n");
//view_token(predict);
free_set(&(predict->set));
}
}
/** Add every set for which an element is only covered by that set **/
void column_inclusion(instance *inst, solution *sol) {
int i;
for (i = 0; i<inst->m; i++) {
if (inst->ncol[i] == 1) add_set(inst, sol, inst->col[i][0]);
}
return;
}
/**********************************************************************
*
* firstpos
*
* Fills firstpos-field in syntax tree. Here we suppose, that all
* nodes below current node are already visited (depth-first traversal).
* Firstpos is a set of positions that can match the first symbol of a
* string generated by the subexpression rooted by node.
*/
static void firstpos(REG1 int node, REG2 node_t* tnode)
{
switch (tnode->type) {
case EMPTY_ID:
set_clear(tnode->firstpos, rbuf.setsize);
break;
case CLASS_ID:
case ID:
add_set(tnode->firstpos, node);
break;
case OR:
set_union(tnode->firstpos,
rbuf.tree[tnode->val.next.left].firstpos,
rbuf.tree[tnode->val.next.right].firstpos,
rbuf.setsize);
break;
case CAT:
if (rbuf.tree[tnode->val.next.left].nullable)
set_union(tnode->firstpos,
rbuf.tree[tnode->val.next.left].firstpos,
rbuf.tree[tnode->val.next.right].firstpos,
rbuf.setsize);
else
set_copy(tnode->firstpos,
rbuf.tree[tnode->val.next.left].firstpos,
rbuf.setsize);
break;
case CLOSURE:
set_copy(tnode->firstpos,
rbuf.tree[tnode->val.next.left].firstpos,
rbuf.setsize);
break;
}
}
int main()
{
TabSample t;
auto x = t.alpha = 7;
auto y = t.beta = "kaesekuchen";
auto z = t.gamma = true;
{
using T = decltype(update(t));
static_assert(sqlpp::is_regular<T>::value, "type requirement");
}
{
using T = decltype(update(t).set(t.gamma = false).where(t.beta != "transparent"));
static_assert(sqlpp::is_regular<T>::value, "type requirement");
}
{
using T = decltype(dynamic_update(db, t).dynamic_set(t.gamma = false).dynamic_where());
static_assert(sqlpp::is_regular<T>::value, "type requirement");
}
update(t).serialize(std::cerr, db); std::cerr << "\n";
update(t).set(t.gamma = false).serialize(std::cerr, db); std::cerr << "\n";
update(t).set(t.gamma = false).where(t.beta != "transparent").serialize(std::cerr, db); std::cerr << "\n";
auto u = dynamic_update(db, t).dynamic_set(t.gamma = false).dynamic_where();
u = u.add_set(t.gamma = false);
u.serialize(std::cerr, db); std::cerr << "\n";
return 0;
}
ATrans *boolean(tl_Node *p) /* computes the transitions to boolean nodes -> next & init */
{
ATrans *t1, *t2, *lft, *rgt, *result = (ATrans *)0;
int id;
switch (p->ntyp)
{
case TRUE:
result = emalloc_atrans();
clear_set(result->to, 0);
clear_set(result->pos, 1);
clear_set(result->neg, 1);
case FALSE:
break;
case AND:
lft = boolean(p->lft);
rgt = boolean(p->rgt);
for (t1 = lft; t1; t1 = t1->nxt)
{
for (t2 = rgt; t2; t2 = t2->nxt)
{
ATrans *tmp = merge_trans(t1, t2);
if (tmp)
{
tmp->nxt = result;
result = tmp;
}
}
}
free_atrans(lft, 1);
free_atrans(rgt, 1);
break;
case OR:
lft = boolean(p->lft);
for (t1 = lft; t1; t1 = t1->nxt)
{
ATrans *tmp = dup_trans(t1);
tmp->nxt = result;
result = tmp;
}
free_atrans(lft, 1);
rgt = boolean(p->rgt);
for (t1 = rgt; t1; t1 = t1->nxt)
{
ATrans *tmp = dup_trans(t1);
tmp->nxt = result;
result = tmp;
}
free_atrans(rgt, 1);
break;
default:
build_alternating(p);
result = emalloc_atrans();
clear_set(result->to, 0);
clear_set(result->pos, 1);
clear_set(result->neg, 1);
add_set(result->to, already_done(p));
}
return result;
}
int init_global(void){//str *info_set_mapping){
int i, j;
char *s, *p;
int count = -1;
for(i=0; i< db_urls_count; i++){
s = db_urls_list[i];
LM_DBG("line = %s\n", s);
if(s && strlen(s) && s[0]!='#'){
if(strncmp("define", s, strlen("define")) == 0){
s += strlen("define")+1;
p = strchr(s, ' ');
/* set1=FAILOVER */
*p = 0;
p++;
LM_DBG("set_mode = {%s}, mode = {%s}\n", s, p);
add_set(s, p);
/*LM_ERR("done\n"); */
count++;
}
else{
/* mysql:........ */
LM_DBG("db = %s\n", s);
add_url(count, s);
}
}
}
for(i = 0; i< global->size; i++)
for(j=0; j<global->set_list[i].size; j++){
global->set_list[i].db_list[j].dbf.cap = 0;
if(db_bind_mod(&global->set_list[i].db_list[j].db_url,
&global->set_list[i].db_list[j].dbf)){
LM_ERR("cant bind db : %.*s",
global->set_list[i].db_list[j].db_url.len,
global->set_list[i].db_list[j].db_url.s);
goto error;
}
}
LM_DBG("global done\n");
/*is_initialized = 1; */
return 0;
error:
destroy();
return -1;
}
int propagate_link( int state , Config_set *A , Config_set *B )
{
STATE *shift_state;
Config_set *C_ptr , *ptr;
TOKEN *T_ptr , *first;
TOKEN *dot;
TOKEN *L2;
TOKEN *L1;
int i;
if( B == NULL )
return 0;
L1 = A->lookahead;
dot = A->dot;
L2 = B->lookahead;
if ( add_set( L2 , L1 ) == FALSE )
return 0;
if( B->dot == NULL )
return 0;
i = parser_table[state][make_id(B->dot->string)-1].go_to;
//printf("%d %s -> %d\n",state , B->dot->string , i );
//view_state(state);
// if ( i == 105 )
// printf("hit\n");
// shift state
for( shift_state = state_start ; i != shift_state->statenum ; shift_state = shift_state->next );
for( C_ptr = shift_state->config_set ; C_ptr != NULL && B->rule != C_ptr->rule ; C_ptr = C_ptr->set_next );
propagate_link( i , B , C_ptr );
//comput lookahead by closue 0
for( C_ptr = shift_state->config_set ; C_ptr != NULL && C_ptr->set_next != NULL ; C_ptr = C_ptr->set_next )
{
for( ptr = shift_state->config_set ; ptr != NULL ; ptr = ptr->set_next )
{
if ( C_ptr->dot == NULL )
continue;
if ( strcmp( C_ptr->dot->string , ptr->rule->lhs ) == 0 )
propagate( shift_state->statenum , C_ptr , ptr );
}
}
return 0;
}
static int
qpkg_cb(cache_pkg_ctx *pkg_ctx, void *priv)
{
set *vdb = (set *)priv;
depend_atom *atom;
char buf[_Q_PATH_MAX];
snprintf(buf, sizeof(buf), "%s/%s", pkg_ctx->cat_ctx->name, pkg_ctx->name);
atom = atom_explode(buf);
if (atom == NULL)
return 0;
vdb = add_set(buf, vdb);
return 1;
}
/**
* Creates a new set of the given name and parameters.
* @arg set_name The name of the set
* @arg custom_config Optional, can be null. Configs that override the defaults.
* @return 0 on success, -1 if the set already exists.
* -2 for internal error. -3 if there is a pending delete.
*/
int setmgr_create_set(hlld_setmgr *mgr, char *set_name, hlld_config *custom_config) {
int res = 0;
pthread_mutex_lock(&mgr->write_lock);
/*
* Bail if the set already exists.
* -1 if the set is active
* -3 if delete is pending
*/
hlld_set_wrapper *set = find_set(mgr, set_name);
if (set) {
res = (set->is_active) ? -1 : -3;
goto LEAVE;
}
// Scan the pending delete queue
LOCK_HLLD_SPIN(&mgr->pending_lock);
if (mgr->pending_deletes) {
hlld_set_list *node = mgr->pending_deletes;
while (node) {
if (!strcmp(node->set_name, set_name)) {
res = -3; // Pending delete
UNLOCK_HLLD_SPIN(&mgr->pending_lock);
goto LEAVE;
}
node = node->next;
}
}
UNLOCK_HLLD_SPIN(&mgr->pending_lock);
// Use a custom config if provided, else the default
hlld_config *config = (custom_config) ? custom_config : mgr->config;
// Add the set
if (add_set(mgr, set_name, config, 1, 1)) {
res = -2; // Internal error
}
LEAVE:
pthread_mutex_unlock(&mgr->write_lock);
return res;
}
void fill_follow_set(void)
{
TOKEN *term , *nonterm , *ptr , *ptr2 , *ptr3 , *ptr_end;
TOKEN *test;
GRAMMAR *gram , *G_ptr;
int change;
int lambda;
test = (TOKEN*) malloc(sizeof(TOKEN));
// set start symbol
ptr = follow_set_start;
insert_set( ptr , "£f" );
do {
change = FALSE;
for( G_ptr = G_start ; G_ptr != NULL ; G_ptr = G_ptr->next ) // start with first production rule
{
for( nonterm = G_ptr->rhs_string ; nonterm != NULL ; nonterm = nonterm->next )
{
if( search_token( nonterminal_start , nonterm->string ) == NULL )
continue;
// follow[B] = follow[B] U (comput_first(£]) - £f)
if ( comput_first_f( nonterm->next , follow_set_start , nonterm->string ) == TRUE )
change = TRUE;
// if ( £f in comput_first(£]) then follow[B] = follow[B] U follow[A])
if( is_lambda == TRUE )
{
ptr = search_token( follow_set_start , G_ptr->lhs );
ptr2 = search_token( follow_set_start , nonterm->string );
//printf(" %s %s \n",ptr->string , ptr2->string);
if ( add_set( ptr2 , ptr) == TRUE )
change = TRUE;
}
}
}
} while ( change );
}
/**
* Loads the existing sets. This is not thread
* safe and assumes that we are being initialized.
*/
static int load_existing_sets(hlld_setmgr *mgr) {
struct dirent **namelist;
int num;
num = scandir(mgr->config->data_dir, &namelist, set_hlld_folders, NULL);
if (num == -1) {
syslog(LOG_ERR, "Failed to scan files for existing sets!");
return -1;
}
syslog(LOG_INFO, "Found %d existing sets", num);
// Add all the sets
for (int i=0; i< num; i++) {
char *folder_name = namelist[i]->d_name;
char *set_name = folder_name + FOLDER_PREFIX_LEN;
if (add_set(mgr, set_name, mgr->config, 0, 0)) {
syslog(LOG_ERR, "Failed to load set '%s'!", set_name);
}
}
for (int i=0; i < num; i++) free(namelist[i]);
free(namelist);
return 0;
}
int comput_first_f( TOKEN *alpha , TOKEN *dst , char *dst_name )
{
int change = FALSE;
TOKEN *ptr , *ptr2 , *ptr3 , *ptr_end;
TOKEN *tmp;
is_lambda = FALSE;
tmp = (TOKEN*) malloc(sizeof(TOKEN));
strncpy( tmp->string , "tmp" , 4 );
tmp->set = NULL;
tmp->next = NULL;
if( alpha == NULL )
{
is_lambda = TRUE;
return FALSE;
}
if ( strcmp( alpha->string , "£f" ) == 0 )
{
//ptr = search_token( dst , dst_name );
//if ( insert_set( ptr , "£f" ) == TRUE )
is_lambda = TRUE;
change = TRUE;
}
else
{
ptr = search_token( dst , dst_name );
ptr2 = search_token( first_set_start , alpha->string );
add_set( tmp , ptr2 );
delete_set( &(tmp->set) , "£f" );
if ( add_set( ptr , tmp ) == TRUE )
change = TRUE;
free_set( &(tmp->set) );
for( ptr3 = alpha ; ptr3 != NULL ; ptr3 = ptr3->next )
{
ptr2 = search_token( first_set_start , ptr3->string );
if( search_set( ptr2 , "£f" ) != TRUE )
break;
if ( ptr3->next == NULL )
{
ptr_end = ptr3;
ptr3 = search_token( first_set_start , ptr_end->string );
if( search_set( ptr3 , "£f" ) == TRUE )
{
if ( insert_set( ptr , "£f" ) == TRUE )
{
is_lambda = TRUE;
change = TRUE;
}
}
break;
}
ptr2 = search_token( first_set_start , ptr3->next->string );
add_set( tmp , ptr2 );
delete_set( &(tmp->set) , "£f" );
if ( add_set( ptr , tmp ) == TRUE )
{
delete_set( &(ptr->set) , "£f" );
change = TRUE;
}
free_set( &(tmp->set) );
}
}
free_token(&tmp);
return change;
}
int propagate( int state , Config_set *A , Config_set *B )
{
STATE *shift_state;
Config_set *C_ptr , *ptr;
TOKEN *T_ptr , *first;
TOKEN *dot;
TOKEN *L2;
TOKEN *L1;
int i;
L1 = A->lookahead;
dot = A->dot;
L2 = B->lookahead;
//First(£^L)
for( T_ptr = dot->next ; T_ptr != NULL ; T_ptr = T_ptr->next )
{
first = search_token( first_set_start , T_ptr->string );
if (first == NULL )
continue;
if ( search_set(first,"£f") == TRUE )
{
add_set(L2,first);
delete_set( &(L2->set) , "£f" );
continue;
}
else
{
if ( add_set(L2,first) == FALSE )
return 0;
break;
}
}
//First(£^L) , £^ is lambda
if(T_ptr == NULL)
{
add_set( L2 , L1 );
}
//printf("%d\n", parser_table[state][make_id(dot->string)].go_to );
if( B->dot == NULL )
return 0;
i = parser_table[state][make_id(B->dot->string)-1].go_to;
//printf("%d %s -> %d\n",state , B->dot->string , i );
//view_state(state);
if( i == state )
return 0;
// shift state
for( shift_state = state_start ; i != shift_state->statenum ; shift_state = shift_state->next );
for( C_ptr = shift_state->config_set ; C_ptr != NULL && B->rule != C_ptr->rule ; C_ptr = C_ptr->set_next );
{
// if ( i == 105 )
// printf("hit\n");
propagate_link( i , B , C_ptr );
}
//comput lookahead by closue 0
C_ptr = shift_state->config_set;
for( C_ptr = shift_state->config_set ; C_ptr != NULL && C_ptr->set_next != NULL ; C_ptr = C_ptr->set_next )
{
for( ptr = shift_state->config_set ; ptr != NULL ; ptr = ptr->set_next )
{
if ( C_ptr->dot == NULL )
continue;
if ( strcmp( C_ptr->dot->string , ptr->rule->lhs ) == 0 )
{
propagate( shift_state->statenum , C_ptr , ptr );
}
}
}
return 0;
}
void union_set(s,t)
{register int i,v ;
itr(t,i,v,add_set(s,v));
}
ATrans *build_alternating(Node *p) /* builds an alternating automaton for p */
{
ATrans *t1, *t2, *t = (ATrans *)0;
int node = already_done(p);
if(node >= 0) return transition[node];
switch (p->ntyp) {
case TRUE:
t = emalloc_atrans();
clear_set(t->to, 0);
clear_set(t->pos, 1);
clear_set(t->neg, 1);
case FALSE:
break;
case PREDICATE:
t = emalloc_atrans();
clear_set(t->to, 0);
clear_set(t->pos, 1);
clear_set(t->neg, 1);
add_set(t->pos, get_sym_id(p->sym->name));
break;
case NOT:
t = emalloc_atrans();
clear_set(t->to, 0);
clear_set(t->pos, 1);
clear_set(t->neg, 1);
add_set(t->neg, get_sym_id(p->lft->sym->name));
break;
#ifdef NXT
case NEXT:
t = boolean(p->lft);
break;
#endif
case U_OPER: /* p U q <-> q || (p && X (p U q)) */
for(t2 = build_alternating(p->rgt); t2; t2 = t2->nxt) {
ATrans *tmp = dup_trans(t2); /* q */
tmp->nxt = t;
t = tmp;
}
for(t1 = build_alternating(p->lft); t1; t1 = t1->nxt) {
ATrans *tmp = dup_trans(t1); /* p */
add_set(tmp->to, node_id); /* X (p U q) */
tmp->nxt = t;
t = tmp;
}
add_set(final_set, node_id);
break;
case V_OPER: /* p V q <-> (p && q) || (p && X (p V q)) */
for(t1 = build_alternating(p->rgt); t1; t1 = t1->nxt) {
ATrans *tmp;
for(t2 = build_alternating(p->lft); t2; t2 = t2->nxt) {
tmp = merge_trans(t1, t2); /* p && q */
if(tmp) {
tmp->nxt = t;
t = tmp;
}
}
tmp = dup_trans(t1); /* p */
add_set(tmp->to, node_id); /* X (p V q) */
tmp->nxt = t;
t = tmp;
}
break;
case AND:
t = (ATrans *)0;
for(t1 = build_alternating(p->lft); t1; t1 = t1->nxt) {
for(t2 = build_alternating(p->rgt); t2; t2 = t2->nxt) {
ATrans *tmp = merge_trans(t1, t2);
if(tmp) {
tmp->nxt = t;
t = tmp;
}
}
}
break;
case OR:
t = (ATrans *)0;
for(t1 = build_alternating(p->lft); t1; t1 = t1->nxt) {
ATrans *tmp = dup_trans(t1);
tmp->nxt = t;
t = tmp;
}
for(t1 = build_alternating(p->rgt); t1; t1 = t1->nxt) {
ATrans *tmp = dup_trans(t1);
tmp->nxt = t;
t = tmp;
}
break;
default:
break;
}
transition[node_id] = t;
label[node_id++] = p;
return(t);
}
/* figure out what dirs we want to process for cleaning and display results. */
int qpkg_clean(char *dirp)
{
FILE *fp;
int i, count;
size_t disp_units = 0;
uint64_t num_all_bytes;
struct dirent **dnames;
queue *vdb;
vdb = get_vdb_atoms(1);
if (chdir(dirp) != 0) {
free_sets(vdb);
return 1;
}
if ((count = scandir(".", &dnames, filter_hidden, alphasort)) < 0) {
free_sets(vdb);
return 1;
}
if (eclean) {
if ((fp = fopen(initialize_ebuild_flat(), "r")) != NULL) {
size_t buflen;
char *buf;
buf = NULL;
while (getline(&buf, &buflen, fp) != -1) {
char *name, *p;
if ((p = strrchr(buf, '.')) == NULL)
continue;
*p = 0;
if ((p = strrchr(buf, '/')) == NULL)
continue;
*p = 0;
name = p + 1;
if ((p = strrchr(buf, '/')) == NULL)
continue;
*p = 0;
/* these strcat() are safe. the name is extracted from buf already. */
strcat(buf, "/");
strcat(buf, name);
/* num_all_bytes will be off when pretend and eclean are enabled together */
/* vdb = del_set(buf, vdb, &i); */
vdb = add_set(buf, vdb);
}
free(buf);
fclose(fp);
}
}
num_all_bytes = qpkg_clean_dir(dirp, vdb);
for (i = 0; i < count; i++) {
char buf[_Q_PATH_MAX];
snprintf(buf, sizeof(buf), "%s/%s", dirp, dnames[i]->d_name);
num_all_bytes += qpkg_clean_dir(buf, vdb);
}
scandir_free(dnames, count);
free_sets(vdb);
disp_units = KILOBYTE;
if ((num_all_bytes / KILOBYTE) > 1000)
disp_units = MEGABYTE;
qprintf(" %s*%s Total space that would be freed in packages directory: %s%s %c%s\n", GREEN, NORM, RED,
make_human_readable_str(num_all_bytes, 1, disp_units), disp_units == MEGABYTE ? 'M' : 'K', NORM);
return 0;
}
