result_type operator() (string_type const& val) const
{
m_filter = predicate_wrapper< log::string_types::type, predicate >(m_name, predicate(RelationT(), val));
}
utree eval (utree const& subject) const {
if (!predicate(subject))
BOOST_THROW_EXCEPTION(assertion_failed());
return utree();
}
SPOTriplets NLP::sentence2triplets ( const char* sentence )
{
// vector of triplets
SPOTriplets triplets;
#ifdef DEBUG
std::cout << "The sentence: " << sentence << std::endl;
#endif
// creates a Sentence from the input char*
Sentence sent = sentence_create ( sentence, dict_ );
#ifdef DEBUG
std::cout << "Sentence created" << std::endl;
#endif
// tokenizes the sentence
sentence_split ( sent, parse_opts_ );
#ifdef DEBUG
std::cout << "Sentence splitted" << std::endl;
#endif
// searches for all possible linkages
int num_linkages = sentence_parse ( sent, parse_opts_ );
#ifdef DEBUG
std::cout << "Sentence parsed" << std::endl;
std::cout << "Number of linkages: " << num_linkages << std::endl;
#endif
// just one triplet
SPOTriplet triplet;
// if there is any linkage in the sentence
if( num_linkages > 0 )
{
// create the linkage
Linkage linkage = linkage_create ( 0, sent, parse_opts_ );
#ifdef DEBUG
// prints the sentence's diagram
std::cout << "The diagram: " << std::endl;
char *diagram = linkage_print_diagram(linkage, true, 800);
std::cout << diagram << std::endl;
linkage_free_diagram( diagram );
// end print diagram
#endif
std::vector<std::string> labels;
// 1. find the S_link
// S* except there is an SJ* because then S* except Spx
// two cases: there is SJ* and there is not SJ*
// TODO: VJlp VJrp same as SJ but to predications
// TODO: SFut SFst what the f**k? ###FIXED###
// TODO: His form was shining like the light not working ###FIXED###
// TODO: Car is mine not working ###FIXED###
// TODO: The little brown bear has eaten all of the honey not working ###FIXED###
// REGEXES
std::regex SJ_( "SJ.*" );
std::regex VJ_( "VJ.*");
std::regex subject( "(Ss.*)|(SFut)|(Sp\*.*)" );
std::regex Spx( "Spx.*" );
// TODO:fix theese initializer list not allowed ###FIXED###
std::regex predicate( "(Pv.*)|(Pg.*)|(PP.*)|(I.*)|(TO)|(MVi.*)" );
// TODO: make one from theese // (Sp.*)|(Ss.*) ###FIXED###
std::regex noun_adject_object ( "(O.*)|(Os.*)|(Op.*)|(MVpn.*)|(Pa.*)|(MVa.*)" );
std::regex preposition ( "(MVp.*)|(Pp.*)|(OF)|(TO)" );
std::regex prep_object ( "(J.*)|(TI)|(I.*)|(ON)" );
// TODO: problems with matching!! Pg*!! ###FIXED###
// TODO: problems with matching!! Mvp.*!! ###FIXED###
bool s_found = false;
bool p_found = false;
bool o_found = false;
bool SJ = false;
// search for SJ.s labels
for( auto label: labels )
{
if( std::regex_match( label, SJ_ ) )
{
SJ = true;
break;
}
}
// multiple subject in the sentence
if( SJ )
{
// SPls left -> first subject
// SPrs right -> second subject
// Spx right -> predicate
// SJ-s are multiple subjects
std::string temp;
// go through every linkage
for( int i = 0; i < linkage_get_num_links( linkage ); ++i )
{
// get their label
std::string l = linkage_get_link_label( linkage, i );
// if there is an SJl* label
if( std::regex_match( l, std::regex( "SJl.*" ) ) )
{
// SJls left side
triplet.s = linkage_get_word( linkage, linkage_get_link_lword( linkage, i ) );
triplet.cut( triplet.s );
temp = triplet.s + " ";
// and word
triplet.s = linkage_get_word( linkage, linkage_get_link_rword( linkage, i ) );
triplet.cut( triplet.s );
temp += triplet.s + " ";
// find SJr*
for( int j = 0; j < linkage_get_num_links( linkage ); ++j )
{
std::string m = linkage_get_link_label( linkage, j );
if( std::regex_match( m, std::regex( "SJr.*" ) ) )
{
triplet.s = linkage_get_word( linkage, linkage_get_link_rword( linkage, j ) );
triplet.cut();
temp += triplet.s;
triplet.s = temp;
s_found = true;
#ifdef DEBUG
std::cout << "Subject found: " << triplet.s << std::endl;
#endif
break;
} // if
} // for
break;
} // if
} // for
// now we have the subject
// find Spx and its right side will be the starter predicate
std::string current_word;
for( int i = 0; i < linkage_get_num_links( linkage ); ++i )
{
std::string l = linkage_get_link_label( linkage, i );
if( std::regex_match( l, std::regex( "Spx.*" ) ) )
{
triplet.p = linkage_get_word( linkage, linkage_get_link_rword( linkage, i ) );
current_word = linkage_get_word( linkage, linkage_get_link_rword( linkage, i ) );
}
}
// from now all the same as on the else branch !!!!
bool predicate_match = false;
// search for the linkage that has triplet.s as left!
do
{
predicate_match = false;
for( int i = 0; i < linkage_get_num_links( linkage ); ++i )
{
// every linkage's left word
std::string word_i = linkage_get_word( linkage, linkage_get_link_lword( linkage, i ) );
// every linkage's label
std::string l = linkage_get_link_label( linkage, i );
if( std::regex_match( l, predicate ) && word_i == current_word )
{
// found predicate
triplet.p = linkage_get_word( linkage, linkage_get_link_rword( linkage, i ) );
current_word = triplet.p;
predicate_match = true;
break;
}
}
}
while( predicate_match );
// we now have the predicate too
// TODO: multiple predicates!
p_found = true;
#ifdef DEBUG
std::cout << "Predicate found: " << triplet.p << std::endl;
#endif
// ###COPY BEGIN###
// search for noun object or adjective object
for( int i = 0; i < linkage_get_num_links( linkage ); ++i )
{
// get every linkage label
std::string l = linkage_get_link_label( linkage, i );
// get the left word of every linkage
std::string l_word = linkage_get_word( linkage, linkage_get_link_lword( linkage, i ) );
// if thete is a label that match AND its left word is the predicate
if( std::regex_match( l, noun_adject_object ) && triplet.p == l_word )
{
// then the object is that linkage's right word
triplet.o = linkage_get_word( linkage, linkage_get_link_rword( linkage, i ) );
triplet.cut( triplet.o );
o_found = true;
#ifdef DEBUG
std::cout << "Adjective or noun object found: " << triplet.o << std::endl;
#endif
} // if
} // for
// still not found object, then search for preposition
if( !o_found )
{
// go through every linkage
for( int i = 0; i < linkage_get_num_links( linkage ); ++i )
{
// get the linkage's label
std::string l = linkage_get_link_label( linkage, i );
// and left word
std::string word_i = linkage_get_word( linkage, linkage_get_link_lword( linkage, i ) );
// if there is a linkage which is a preposition and its left word is the predicate
if( std::regex_match( l, preposition ) && triplet.p == word_i )
{
// found preposition
// search for prep_object
// then the temp will contain the preposition label's right word
std::string temp = linkage_get_word( linkage, linkage_get_link_rword( linkage, i ) );
#ifdef DEBUG
std::cout << "Preposition found! and its rigth word is: " << temp << std::endl;
#endif
for( int j = 0; j < linkage_get_num_links( linkage ); ++j )
{
// every linkages
std::string m = linkage_get_link_label( linkage, j );
// every left word
std::string word_j = linkage_get_word( linkage, linkage_get_link_lword( linkage, j ) );
// if there is a label with match and its left is exactly the preposition's right
if( std::regex_match( m, prep_object ) && temp == word_j )
{
triplet.o = linkage_get_word( linkage, linkage_get_link_lword( linkage, j ) );
triplet.cut(triplet.o);
triplet.o += " ";
// save o
std::string temp = triplet.o;
triplet.o = linkage_get_word( linkage, linkage_get_link_rword( linkage, j ) );
triplet.cut(triplet.o);
temp += triplet.o;
triplet.o = temp;
o_found = true;
#ifdef DEBUG
std::cout << "Object found: " << triplet.o << std::endl;
#endif
} // if( std::regex_match( m, prep_object ) && temp == word_j ) END
} // for J END
} // if( std::regex_match( l, preposition ) && triplet.p == word_i ) END
} // for I END
} // if( !o_found ) END
if( s_found && p_found && o_found )
{
// TODO: cut the words itself not the whole triplet
// have to cut every word itself
// triplet.cut();
triplet.cut(triplet.s);
triplet.cut(triplet.p);
triplets.push_back( triplet );
s_found = false;
p_found = false;
o_found = false;
}
// ###COPY END###
}
else // only one subject
{
// except Spx!!!
// S left -> subject
// S right -> predicate at first
// if the word next to S right, is an element of Pv*, Pg* PP*, I*, TO, MVi*
// then the new predicate will be that word
std::string current_word;
// search for subject (S_link)
for( int i = 0; i < linkage_get_num_links( linkage ); ++i )
{
// get the linkage's label
std::string l = linkage_get_link_label( linkage, i );
if( std::regex_match( l, subject ) )
{
// subject found
triplet.s = linkage_get_word( linkage, linkage_get_link_lword( linkage, i ) );
s_found = true;
current_word = linkage_get_word( linkage, linkage_get_link_rword( linkage, i ) );
triplet.p = current_word;
#ifdef DEBUG
std::cout << "Subject found: " << triplet.s << std::endl;
#endif
break;
}
}
if( s_found )
{
bool predicate_match = false;
// search for the linkage that has triplet.s as left!
do
{
predicate_match = false;
for( int i = 0; i < linkage_get_num_links( linkage ); ++i )
{
// every linkage's left word
std::string l_word = linkage_get_word( linkage, linkage_get_link_lword( linkage, i ) );
// every linkage's label
std::string l = linkage_get_link_label( linkage, i );
if( std::regex_match( l, predicate ) && l_word == current_word )
{
// found predicate
triplet.p = linkage_get_word( linkage, linkage_get_link_rword( linkage, i ) );
current_word = triplet.p;
predicate_match = true;
break;
}
} // for END
} while( predicate_match );
p_found = true;
#ifdef DEBUG
std::cout << "Predicate found: " << triplet.p << std::endl;
#endif
} // if( s_found ) END
// subject and predicate found
// search for object
// from k to linkage_get_num_links( linkage )
// if there is any of the noun, adjective od preposition object then that
// label's right will give the object.
// !!! search only between labels that has triplet.p as left word !!!!!
// search for noun object or adjective objects
// go through all links
for( int i = 0; i < linkage_get_num_links( linkage ); ++i )
{
// get every linkage label
std::string l = linkage_get_link_label( linkage, i );
// get the left word of every linkage
std::string word_i = linkage_get_word( linkage, linkage_get_link_lword( linkage, i ) );
// if thete is a label that match AND its left word is the predicate
if( std::regex_match( l, noun_adject_object ) && triplet.p == word_i )
{
// then the object is that linkage's right word
triplet.o = linkage_get_word( linkage, linkage_get_link_rword( linkage, i ) );
o_found = true;
triplet.cut(triplet.o);
#ifdef DEBUG
std::cout << "Adjective or noun object found: " << triplet.o << std::endl;
#endif
} // if END
} // for END
// still not found object, then search for preposition
if( !o_found )
{
// go through every linkage
for( int i = 0; i < linkage_get_num_links( linkage ); ++i )
{
// get the linkage's label
std::string l = linkage_get_link_label( linkage, i );
// and left word
std::string word_i = linkage_get_word( linkage, linkage_get_link_lword( linkage, i ) );
// if there is a linkage which is a preposition and its left word is the predicate
if( std::regex_match( l, preposition ) && triplet.p == word_i )
{
// found preposition
// search for prep_object
// then the temp will contain the preposition label's right word
std::string temp = linkage_get_word( linkage, linkage_get_link_rword( linkage, i ) );
#ifdef DEBUG
std::cout << "Preposition found! and its rigth word is: " << temp << std::endl;
#endif
// start search from there
for( int j = 0; j < linkage_get_num_links( linkage ); ++j )
{
// every linkages
std::string m = linkage_get_link_label( linkage, j );
// every left word
std::string word_j = linkage_get_word( linkage, linkage_get_link_lword( linkage, j ) );
#ifdef DEBUG
if( std::regex_match( m, prep_object ) )
std::cout << m << " DOES match to (J.*)|(TI)|(I.*)|(ON)" << std::endl;
#endif
// if there is a label with match and its left is exactly the preposition's right
if( std::regex_match( m, prep_object ) && temp == word_j )
{
triplet.o = linkage_get_word( linkage, linkage_get_link_lword( linkage, j ) );
triplet.cut(triplet.o);
triplet.o += " ";
// save o
std::string temp = triplet.o;
triplet.o = linkage_get_word( linkage, linkage_get_link_rword( linkage, j ) );
triplet.cut(triplet.o);
temp += triplet.o;
triplet.o = temp;
#ifdef DEBUG
std::cout << "Object found: " << triplet.o << std::endl;
#endif
o_found = true;
}
} // for
} // if
} // for
} // if( o_found ) END
if( s_found && p_found && o_found )
{
// TODO: cut the words itself not the whole triplet ###FIXED###
// have to cut every word itself
// triplet.cut();
triplet.cut(triplet.s);
triplet.cut(triplet.p);
triplets.push_back( triplet );
s_found = false;
p_found = false;
o_found = false;
}
} // end else
linkage_delete ( linkage );
} // if( num_linkages > 0 ) END
bool isSatisfied() {
return predicate();
}
/** A syntactic predicate. Returns true/false depending on whether
* the specified grammar fragment matches the current input stream.
* This resets the failed instance var afterwards.
*/
static ANTLR3_BOOLEAN
synpred (pANTLR3_BASE_RECOGNIZER recognizer, void * ctx, void (*predicate)(void * ctx))
{
ANTLR3_UINT64 start;
pANTLR3_PARSER parser;
pANTLR3_TREE_PARSER tparser;
pANTLR3_INT_STREAM is;
switch (recognizer->type)
{
case ANTLR3_TYPE_PARSER:
parser = (pANTLR3_PARSER) (recognizer->super);
tparser = NULL;
is = parser->tstream->istream;
break;
case ANTLR3_TYPE_TREE_PARSER:
tparser = (pANTLR3_TREE_PARSER) (recognizer->super);
parser = NULL;
is = tparser->ctnstream->tnstream->istream;
break;
default:
fprintf(stderr, "Base recognizerfunction 'synPred' called by unknown paresr type - provide override for this function\n");
return ANTLR3_FALSE;
break;
}
/* Begin backtracking so we can get back to where we started after trying out
* the syntactic predicate.
*/
start = is->mark(is);
recognizer->backtracking++;
/* Try the syntactical predicate
*/
predicate(ctx);
/* Reset
*/
is->rewind(is, start);
recognizer->backtracking--;
if (recognizer->failed == ANTLR3_TRUE)
{
/* Predicate failed
*/
recognizer->failed = ANTLR3_FALSE;
return ANTLR3_FALSE;
}
else
{
/* Predicate was succesful
*/
recognizer->failed = ANTLR3_FALSE;
return ANTLR3_TRUE;
}
}
void Scene_combinatorial_map_item::export_current_volume_as_polyhedron() const {
if (volume_to_display==0) return; //no volume selected
Select_volume predicate(volume_to_display);
export_as_polyhedron(predicate,QString("%1_%2").arg(this->name()).arg(volume_to_display-1));
}
void
peep(void)
{
Reg *r, *r1, *r2;
Prog *p, *p1;
int t;
/*
* complete R structure
*/
t = 0;
for(r=firstr; r!=R; r=r1) {
r1 = r->link;
if(r1 == R)
break;
p = r->prog->link;
while(p != r1->prog)
switch(p->as) {
default:
r2 = rega();
r->link = r2;
r2->link = r1;
r2->prog = p;
r2->p1 = r;
r->s1 = r2;
r2->s1 = r1;
r1->p1 = r2;
r = r2;
t++;
case ADATA:
case AGLOBL:
case ANAME:
case ASIGNAME:
p = p->link;
}
}
loop1:
t = 0;
for(r=firstr; r!=R; r=r->link) {
p = r->prog;
if(p->as == ASLL || p->as == ASRL || p->as == ASRA) {
/*
* elide shift into D_SHIFT operand of subsequent instruction
*/
if(shiftprop(r)) {
excise(r);
t++;
}
}
if(p->as == AMOVW || p->as == AMOVF || p->as == AMOVD)
if(regtyp(&p->to)) {
if(p->from.type == D_CONST)
constprop(&p->from, &p->to, r->s1);
else if(regtyp(&p->from))
if(p->from.type == p->to.type) {
if(copyprop(r)) {
excise(r);
t++;
} else
if(subprop(r) && copyprop(r)) {
excise(r);
t++;
}
}
}
}
if(t)
goto loop1;
/*
* look for MOVB x,R; MOVB R,R
*/
for(r=firstr; r!=R; r=r->link) {
p = r->prog;
switch(p->as) {
default:
continue;
case AEOR:
/*
* EOR -1,x,y => MVN x,y
*/
if(p->from.type == D_CONST && p->from.offset == -1) {
p->as = AMVN;
p->from.type = D_REG;
if(p->reg != NREG)
p->from.reg = p->reg;
else
p->from.reg = p->to.reg;
p->reg = NREG;
}
continue;
case AMOVH:
case AMOVHU:
case AMOVB:
case AMOVBU:
if(p->to.type != D_REG)
continue;
break;
}
r1 = r->link;
if(r1 == R)
continue;
p1 = r1->prog;
if(p1->as != p->as)
continue;
if(p1->from.type != D_REG || p1->from.reg != p->to.reg)
continue;
if(p1->to.type != D_REG || p1->to.reg != p->to.reg)
continue;
excise(r1);
}
for(r=firstr; r!=R; r=r->link) {
p = r->prog;
switch(p->as) {
case AMOVW:
case AMOVB:
case AMOVBU:
if(p->from.type == D_OREG && p->from.offset == 0)
xtramodes(r, &p->from);
else if(p->to.type == D_OREG && p->to.offset == 0)
xtramodes(r, &p->to);
else
continue;
break;
case ACMP:
/*
* elide CMP $0,x if calculation of x can set condition codes
*/
if(p->from.type != D_CONST || p->from.offset != 0)
continue;
r2 = r->s1;
if(r2 == R)
continue;
t = r2->prog->as;
switch(t) {
default:
continue;
case ABEQ:
case ABNE:
case ABMI:
case ABPL:
break;
case ABGE:
t = ABPL;
break;
case ABLT:
t = ABMI;
break;
case ABHI:
t = ABNE;
break;
case ABLS:
t = ABEQ;
break;
}
r1 = r;
do
r1 = uniqp(r1);
while (r1 != R && r1->prog->as == ANOP);
if(r1 == R)
continue;
p1 = r1->prog;
if(p1->to.type != D_REG)
continue;
if(p1->to.reg != p->reg)
if(!(p1->as == AMOVW && p1->from.type == D_REG && p1->from.reg == p->reg))
continue;
switch(p1->as) {
default:
continue;
case AMOVW:
if(p1->from.type != D_REG)
continue;
case AAND:
case AEOR:
case AORR:
case ABIC:
case AMVN:
case ASUB:
case ARSB:
case AADD:
case AADC:
case ASBC:
case ARSC:
break;
}
p1->scond |= C_SBIT;
r2->prog->as = t;
excise(r);
continue;
}
}
predicate();
}
bool LoweringVisitor::there_are_reductions(OutlineInfo& outline_info)
{
TL::ObjectList<OutlineDataItem*> reduction_items = outline_info.get_data_items().filter(
predicate(lift_pointer(functor(&OutlineDataItem::is_reduction))));
return !reduction_items.empty();
}
void LoweringVisitor::reduction_initialization_code(
OutlineInfo& outline_info,
Nodecl::NodeclBase ref_tree,
Nodecl::NodeclBase construct)
{
ERROR_CONDITION(ref_tree.is_null(), "Invalid tree", 0);
if (!Nanos::Version::interface_is_at_least("master", 5023))
{
running_error("%s: error: a newer version of Nanos++ (>=5023) is required for reductions support\n",
construct.get_locus_str().c_str());
}
TL::ObjectList<OutlineDataItem*> reduction_items = outline_info.get_data_items().filter(
predicate(lift_pointer(functor(&OutlineDataItem::is_reduction))));
ERROR_CONDITION (reduction_items.empty(), "No reductions to process", 0);
Source result;
Source reduction_declaration,
thread_initializing_reduction_info,
thread_fetching_reduction_info;
result
<< reduction_declaration
<< "{"
<< as_type(get_bool_type()) << " red_single_guard;"
<< "nanos_err_t err;"
<< "err = nanos_enter_sync_init(&red_single_guard);"
<< "if (err != NANOS_OK)"
<< "nanos_handle_error(err);"
<< "if (red_single_guard)"
<< "{"
<< "int nanos_num_threads = nanos_omp_get_num_threads();"
<< thread_initializing_reduction_info
<< "err = nanos_release_sync_init();"
<< "if (err != NANOS_OK)"
<< "nanos_handle_error(err);"
<< "}"
<< "else"
<< "{"
<< "err = nanos_wait_sync_init();"
<< "if (err != NANOS_OK)"
<< "nanos_handle_error(err);"
<< thread_fetching_reduction_info
<< "}"
<< "}"
;
for (TL::ObjectList<OutlineDataItem*>::iterator it = reduction_items.begin();
it != reduction_items.end();
it++)
{
std::string nanos_red_name = "nanos_red_" + (*it)->get_symbol().get_name();
std::pair<OpenMP::Reduction*, TL::Type> reduction_info = (*it)->get_reduction_info();
OpenMP::Reduction* reduction = reduction_info.first;
TL::Type reduction_type = reduction_info.second;
if (reduction_type.is_any_reference())
reduction_type = reduction_type.references_to();
TL::Type reduction_element_type = reduction_type;
if (IS_FORTRAN_LANGUAGE)
{
while (reduction_element_type.is_fortran_array())
reduction_element_type = reduction_element_type.array_element();
}
else
{
while (reduction_element_type.is_array())
reduction_element_type = reduction_element_type.array_element();
}
Source element_size;
if (IS_FORTRAN_LANGUAGE)
{
if (reduction_type.is_fortran_array())
{
// We need to parse this bit in Fortran
Source number_of_bytes;
number_of_bytes << "SIZE(" << (*it)->get_symbol().get_name() << ") * " << reduction_element_type.get_size();
element_size << as_expression(number_of_bytes.parse_expression(construct));
}
else
{
element_size << "sizeof(" << as_type(reduction_type) << ")";
}
}
else
{
element_size << "sizeof(" << as_type(reduction_type) << ")";
}
reduction_declaration
<< "nanos_reduction_t* " << nanos_red_name << ";"
;
Source allocate_private_buffer, cleanup_code;
Source num_scalars;
TL::Symbol basic_reduction_function, vector_reduction_function;
create_reduction_function(reduction, construct, reduction_type, basic_reduction_function, vector_reduction_function);
(*it)->reduction_set_basic_function(basic_reduction_function);
thread_initializing_reduction_info
<< "err = nanos_malloc((void**)&" << nanos_red_name << ", sizeof(nanos_reduction_t), "
<< "\"" << construct.get_filename() << "\", " << construct.get_line() << ");"
<< "if (err != NANOS_OK)"
<< "nanos_handle_error(err);"
<< nanos_red_name << "->original = (void*)"
<< (reduction_type.is_array() ? "" : "&") << (*it)->get_symbol().get_name() << ";"
<< allocate_private_buffer
<< nanos_red_name << "->vop = "
<< (vector_reduction_function.is_valid() ? as_symbol(vector_reduction_function) : "0") << ";"
<< nanos_red_name << "->bop = (void(*)(void*,void*,int))" << as_symbol(basic_reduction_function) << ";"
<< nanos_red_name << "->element_size = " << element_size << ";"
<< nanos_red_name << "->num_scalars = " << num_scalars << ";"
<< cleanup_code
<< "err = nanos_register_reduction(" << nanos_red_name << ");"
<< "if (err != NANOS_OK)"
<< "nanos_handle_error(err);"
;
if (IS_C_LANGUAGE
|| IS_CXX_LANGUAGE)
{
if (reduction_type.is_array())
{
num_scalars << "sizeof(" << as_type(reduction_type) << ") / sizeof(" << as_type(reduction_element_type) <<")";
}
else
{
num_scalars << "1";
}
allocate_private_buffer
<< "err = nanos_malloc(&" << nanos_red_name << "->privates, sizeof(" << as_type(reduction_type) << ") * nanos_num_threads, "
<< "\"" << construct.get_filename() << "\", " << construct.get_line() << ");"
<< "if (err != NANOS_OK)"
<< "nanos_handle_error(err);"
<< nanos_red_name << "->descriptor = " << nanos_red_name << "->privates;"
<< "rdv_" << (*it)->get_field_name() << " = (" << as_type( (*it)->get_private_type().get_pointer_to() ) << ")" << nanos_red_name << "->privates;"
;
thread_fetching_reduction_info
<< "err = nanos_reduction_get(&" << nanos_red_name << ", "
<< (reduction_type.is_array() ? "" : "&") << (*it)->get_symbol().get_name() << ");"
<< "if (err != NANOS_OK)"
<< "nanos_handle_error(err);"
<< "rdv_" << (*it)->get_field_name() << " = (" << as_type( (*it)->get_private_type().get_pointer_to() ) << ")" << nanos_red_name << "->privates;"
;
cleanup_code
<< nanos_red_name << "->cleanup = nanos_free0;"
;
}
else if (IS_FORTRAN_LANGUAGE)
{
Type private_reduction_vector_type;
Source extra_dims;
{
TL::Type t = (*it)->get_symbol().get_type().no_ref();
int rank = 0;
if (t.is_fortran_array())
{
rank = t.fortran_rank();
}
if (rank != 0)
{
// We need to parse this bit in Fortran
Source size_call;
size_call << "SIZE(" << (*it)->get_symbol().get_name() << ")";
num_scalars << as_expression(size_call.parse_expression(construct));
}
else
{
num_scalars << "1";
}
private_reduction_vector_type = fortran_get_n_ranked_type_with_descriptor(
get_void_type(), rank + 1, construct.retrieve_context().get_decl_context());
int i;
for (i = 0; i < rank; i++)
{
Source lbound_src;
lbound_src << "LBOUND(" << (*it)->get_symbol().get_name() << ", DIM = " << (rank - i) << ")";
Source ubound_src;
ubound_src << "UBOUND(" << (*it)->get_symbol().get_name() << ", DIM = " << (rank - i) << ")";
extra_dims
<< "["
<< as_expression(lbound_src.parse_expression(construct))
<< ":"
<< as_expression(ubound_src.parse_expression(construct))
<< "]";
t = t.array_element();
}
}
allocate_private_buffer
<< "@FORTRAN_ALLOCATE@((*rdv_" << (*it)->get_field_name() << ")[0:(nanos_num_threads-1)]" << extra_dims <<");"
<< nanos_red_name << "->privates = &(*rdv_" << (*it)->get_field_name() << ");"
<< "err = nanos_malloc(&" << nanos_red_name << "->descriptor, sizeof(" << as_type(private_reduction_vector_type) << "), "
<< "\"" << construct.get_filename() << "\", " << construct.get_line() << ");"
<< "if (err != NANOS_OK)"
<< "nanos_handle_error(err);"
<< "err = nanos_memcpy(" << nanos_red_name << "->descriptor, "
"&rdv_" << (*it)->get_field_name() << ", sizeof(" << as_type(private_reduction_vector_type) << "));"
<< "if (err != NANOS_OK)"
<< "nanos_handle_error(err);"
;
thread_fetching_reduction_info
<< "err = nanos_reduction_get(&" << nanos_red_name << ", &" << (*it)->get_symbol().get_name() << ");"
<< "if (err != NANOS_OK)"
<< "nanos_handle_error(err);"
<< "err = nanos_memcpy("
<< "&rdv_" << (*it)->get_field_name() << ","
<< nanos_red_name << "->descriptor, "
<< "sizeof(" << as_type(private_reduction_vector_type) << "));"
<< "if (err != NANOS_OK)"
<< "nanos_handle_error(err);"
;
TL::Symbol reduction_cleanup = create_reduction_cleanup_function(reduction, construct);
cleanup_code
<< nanos_red_name << "->cleanup = " << as_symbol(reduction_cleanup) << ";"
;
}
else
{
internal_error("Code unreachable", 0);
}
}
FORTRAN_LANGUAGE()
{
Source::source_language = SourceLanguage::C;
}
ref_tree.replace(result.parse_statement(ref_tree));
FORTRAN_LANGUAGE()
{
Source::source_language = SourceLanguage::Current;
}
}
/*this function takes a pointer to an ordered set, a pointer to a root node, a function pointer and an argument pointer, and inserts
the key of the root node into the ordered set if the predicate called on arg and root->key is not zero*/
static void operateFilter(struct orderedSet *s, struct node *root, int (*predicate)(void *arg, const char *c), void *arg) {
if ((predicate(arg, root->key)) != 0) { /*make sure results of predicate function are not zero*/
orderedSetInsert(s, root->key); /*insert string into orderedSet*/
}
}
inline std::unique_lock<std::mutex> lock_if(std::mutex& mutex, Pred&& predicate)
{
std::unique_lock<std::mutex> lock(mutex, std::defer_lock);
if (predicate()) lock.lock();
return lock;
}
void
sql::write_on(const abstract_predicate &pred) {
write(" ON ");
write_evaluation(predicate(pred));
}
void
sql::write_where(const abstract_predicate &pred) {
assert (! a_priori_true(pred));
write(" WHERE ");
write_evaluation(predicate(pred));
}
template<class PerturbedT> bool perturbed_sign(void(*const predicate)(RawArray<mp_limb_t>,RawArray<const Vector<Exact<1>,PerturbedT::m>>),
const int degree, RawArray<const PerturbedT> X) {
const int m = PerturbedT::m;
typedef Vector<Exact<1>,m> EV;
if (check)
GEODE_WARNING("Expensive consistency checking enabled");
const int n = X.size();
if (verbose)
cout << "perturbed_sign:\n degree = "<<degree<<"\n X = "<<X<<endl;
// Check if the predicate is nonsingular without perturbation
const auto Z = GEODE_RAW_ALLOCA(n,EV);
const int precision = degree*Exact<1>::ratio;
{
for (int i=0;i<n;i++)
Z[i] = EV(to_exact(X[i].value()));
const auto R = GEODE_RAW_ALLOCA(precision,mp_limb_t);
predicate(R,Z);
if (const int sign = mpz_sign(R))
return sign>0;
}
// Check the first perturbation level with specialized code
vector<Vector<ExactInt,m>> Y(n); // perturbations
{
// Compute the first level of perturbations
for (int i=0;i<n;i++)
Y[i] = perturbation<m>(1,X[i].seed());
if (verbose)
cout << " Y = "<<Y<<endl;
// Evaluate polynomial at epsilon = 1, ..., degree
const int scaled_precision = precision+factorial_limbs(degree);
const auto values = GEODE_RAW_ALLOCA(degree*scaled_precision,mp_limb_t).reshape(degree,scaled_precision);
memset(values.data(),0,sizeof(mp_limb_t)*values.flat.size());
for (int j=0;j<degree;j++) {
for (int i=0;i<n;i++)
Z[i] = EV(to_exact(X[i].value())+(j+1)*Y[i]);
predicate(values[j],Z);
if (verbose)
cout << " predicate("<<Z<<") = "<<mpz_str(values[j])<<endl;
}
// Find an interpolating polynomial, overriding the input with the result.
scaled_univariate_in_place_interpolating_polynomial(values);
if (verbose)
cout << " coefs = "<<mpz_str(values)<<endl;
// Compute sign
for (int j=0;j<degree;j++)
if (const int sign = mpz_sign(values[j]))
return sign>0;
}
{
// Add one perturbation level after another until we hit a nonzero polynomial. Our current implementation duplicates
// work from one iteration to the next for simplicity, which is fine since the first interation suffices almost always.
for (int d=2;;d++) {
if (verbose)
cout << " level "<<d<<endl;
// Compute the next level of perturbations
Y.resize(d*n);
for (int i=0;i<n;i++)
Y[(d-1)*n+i] = perturbation<m>(d,X[i].seed());
// Evaluate polynomial at every point in an "easy corner"
const auto lambda = monomials(degree,d);
const Array<mp_limb_t,2> values(lambda.m,precision,uninit);
for (int j=0;j<lambda.m;j++) {
for (int i=0;i<n;i++)
Z[i] = EV(to_exact(X[i].value())+lambda(j,0)*Y[i]);
for (int v=1;v<d;v++)
for (int i=0;i<n;i++)
Z[i] += EV(lambda(j,v)*Y[v*n+i]);
predicate(values[j],Z);
}
// Find an interpolating polynomial, overriding the input with the result.
in_place_interpolating_polynomial(degree,lambda,values);
// Compute sign
int sign = 0;
int sign_j = -1;
for (int j=0;j<lambda.m;j++)
if (const int s = mpz_sign(values[j])) {
if (check) // Verify that a term which used to be zero doesn't become nonzero
GEODE_ASSERT(lambda(j,d-1));
if (!sign || monomial_less(lambda[sign_j],lambda[j])) {
sign = s;
sign_j = j;
}
}
// If we find a nonzero sign, we're done!
if (sign)
return sign>0;
// If we get through two levels without fixing the degeneracy, run a fast, strict identity test to make sure we weren't handed an impossible problem.
if (d==2)
assert_last_nonzero(predicate,values[0],X,"perturbed_sign: identically zero predicate");
}
}
}
int main()
{
typedef PointVector2D<int> Point; //type redefinition
typedef PointVector2D<int> Vector; //type redefinition
typedef ExactRayIntersectableCircle<Point> Circle;
int nbok = 0; //number of tests ok
int nb = 0; //total number of tests
#ifdef DEBUG_VERBOSE
std::cout << " #1 - First Circle " << std::endl;
#endif
{
Point pta = Point(0,5);
Point ptb = Point(-3,3);
Point ptc = Point(4,-3);
Circle circle( pta, ptb, ptc );
#ifdef DEBUG_VERBOSE
std::cout << "-- Disk[ Center : (" << circle.getCenterX() << ", "
<< circle.getCenterY()<< " ), Radius : " << circle.getRadius()
<< std::endl;
std::cout << " ----------- Next predicate ----------- " << std::endl;
std::cout << std::endl;
#endif
for (int k=1; k<=10; k++)
{
CircumcircleRadiusPredicate<> predicate5(20+(3*k),1);
std::cout <<"Predicate = "<< 20+(3*k) << " /"<<1<<std::endl;
if (test(circle, predicate5, ptc))
nbok++;
nb++;
std::cout << "(" << nbok << " tests passed / " << nb << " tests)" << std::endl;
std::cout << std::endl;
}
}
#ifdef DEBUG_VERBOSE
std::cout << " #2 - Random Circle " << std::endl;
#endif
// Test number
int nb_test = 100;
//random value
srand ( time(NULL) );
// Max origin coordinate
int maxPoint = 100;
// Number predicate test
int nbPredicate = 10;
// Circumcircle triangle vertices
Point pta, ptb, ptc;
for (int k = 1; k<= nb_test ; k++)
{
{
// random circumcircle
pta = Point( (rand() % maxPoint) , (rand() % maxPoint) );
ptb = Point( (pta[0]-1- (rand() % maxPoint) ), (pta[1]-1- (rand() % maxPoint)) );
ptc = Point( (ptb[0]+1+ (rand() % maxPoint) ), (ptb[1]-1- (rand() % maxPoint)) );
Circle circle( pta, ptb, ptc );
int Rint = ceil(circle.getRadius());
#ifdef DEBUG_VERBOSE
std::cout << "II - "<<nb_test<<" - Alpha-shape on the circle : " << std::endl;
std::cout << "-- Disk - R : " << circle.getRadius() << ", "
<< " | Points : "<< pta<< ptb<< ptc << std::endl;
#endif
for (int i = 1; i <= nbPredicate; i++)
{
{
#ifdef DEBUG_VERBOSE
std::cout << " ----------- Next predicate ----------- " << std::endl;
std::cout << std::endl;
#endif
CircumcircleRadiusPredicate<> predicate(Rint*Rint + 2*i*Rint, 1);
#ifdef DEBUG_VERBOSE
std::cout << "Radius predicate : Num2 / Den2 : "<<(Rint*Rint + 2*i*Rint)<<"/"
<< 1 << std::endl;
#endif
if (test(circle, predicate, pta))
{
nbok++;
}
nb++;
std::cout << "(" << nbok << " tests passed / " << nb << " tests)" << std::endl;
}
}
}
}
#ifdef DEBUG_VERBOSE
std::cout << " #1 - Circle " << std::endl;
#endif
{
Point pta = Point(0,-38);
Point ptb = Point(38,-19);
Point ptc = Point(-38,-19);
Circle circle( pta, ptb, ptc );
#ifdef DEBUG_VERBOSE
std::cout << "-- Disk[ Center : (" << circle.getCenterX() << ", "
<< circle.getCenterY()<< " ), Radius : " << circle.getRadius()
<< std::endl;
std::cout << " ----------- Next predicate ----------- " << std::endl;
std::cout << std::endl;
#endif
std::vector<Point> v;
convexHull( circle, circle.getConvexHullVertex(), std::back_inserter(v) );
#ifdef DEBUG_VERBOSE
std::cout << "# - Convex Hull" << std::endl;
std::copy(v.begin(), v.end(), std::ostream_iterator<Point>(std::cout, ", ") );
std::cout << std::endl;
#endif
CircumcircleRadiusPredicate<> predicate5(2400,1);
std::cout <<"Predicate = "<< 2400<< " /"<<1<<std::endl;
if (test(circle, predicate5, pta))
nbok++;
nb++;
std::cout << "(" << nbok << " tests passed / " << nb << " tests)" << std::endl;
std::cout << std::endl;
}
//1 if at least one test failed
//0 otherwise
return (nb != nbok);
}
void LoweringVisitor::perform_partial_reduction(OutlineInfo& outline_info, Nodecl::NodeclBase ref_tree)
{
ERROR_CONDITION(ref_tree.is_null(), "Invalid tree", 0);
Source reduction_code;
TL::ObjectList<OutlineDataItem*> reduction_items = outline_info.get_data_items().filter(
predicate(lift_pointer(functor(&OutlineDataItem::is_reduction))));
if (!reduction_items.empty())
{
for (TL::ObjectList<OutlineDataItem*>::iterator it = reduction_items.begin();
it != reduction_items.end();
it++)
{
if (IS_C_LANGUAGE || IS_CXX_LANGUAGE)
{
if ((*it)->get_private_type().is_array())
{
reduction_code
<< "__builtin_memcpy(rdv_" << (*it)->get_field_name() << "[nanos_omp_get_thread_num()],"
<< "rdp_" << (*it)->get_symbol().get_name() << ","
<< " sizeof(" << as_type((*it)->get_private_type()) << "));"
;
}
else
{
reduction_code
<< "rdv_" << (*it)->get_field_name() << "[nanos_omp_get_thread_num()] "
<< "= rdp_" << (*it)->get_symbol().get_name() << ";"
;
}
}
else if (IS_FORTRAN_LANGUAGE)
{
Source extra_dims;
{
TL::Type t = (*it)->get_symbol().get_type().no_ref();
int rank = 0;
if (t.is_fortran_array())
{
rank = t.fortran_rank();
}
int i;
for (i = 0; i < rank; i++)
{
extra_dims << ":,";
}
}
reduction_code
<< "rdv_" << (*it)->get_field_name() << "( " << extra_dims << "nanos_omp_get_thread_num() ) = rdp_" << (*it)->get_symbol().get_name() << "\n"
;
}
else
{
internal_error("Code unreachable", 0);
}
}
}
ref_tree.replace(reduction_code.parse_statement(ref_tree));
}
// Copied from irrlicht
scene::IMesh* MeshTools::createMeshWithTangents(scene::IMesh* mesh, bool(*predicate)(scene::IMeshBuffer*),
bool recalculateNormals, bool smooth, bool angleWeighted, bool calculateTangents)
{
if (!mesh)
return 0;
// copy mesh and fill data into SMeshBufferTangents
scene::SMesh* clone = new scene::SMesh();
const u32 meshBufferCount = mesh->getMeshBufferCount();
bool needsNormalMap = false;
for (u32 b = 0; b < meshBufferCount; ++b)
{
scene::IMeshBuffer* original = mesh->getMeshBuffer(b);
if (predicate(original))
{
needsNormalMap = true;
break;
}
}
if (!needsNormalMap)
{
return mesh;
}
for (u32 b = 0; b<meshBufferCount; ++b)
{
scene::IMeshBuffer* original = mesh->getMeshBuffer(b);
const u32 idxCnt = original->getIndexCount();
const u16* idx = original->getIndices();
if (!predicate(original))
{
clone->addMeshBuffer(original);
continue;
}
scene::SMeshBufferTangents* buffer = new scene::SMeshBufferTangents();
buffer->Material = original->getMaterial();
buffer->Vertices.reallocate(idxCnt);
buffer->Indices.reallocate(idxCnt);
core::map<video::S3DVertexTangents, int> vertMap;
int vertLocation;
// copy vertices
const video::E_VERTEX_TYPE vType = original->getVertexType();
video::S3DVertexTangents vNew;
for (u32 i = 0; i<idxCnt; ++i)
{
switch (vType)
{
case video::EVT_STANDARD:
{
const video::S3DVertex* v =
(const video::S3DVertex*)original->getVertices();
vNew = video::S3DVertexTangents(
v[idx[i]].Pos, v[idx[i]].Normal, v[idx[i]].Color, v[idx[i]].TCoords);
}
break;
case video::EVT_2TCOORDS:
{
const video::S3DVertex2TCoords* v =
(const video::S3DVertex2TCoords*)original->getVertices();
vNew = video::S3DVertexTangents(
v[idx[i]].Pos, v[idx[i]].Normal, v[idx[i]].Color, v[idx[i]].TCoords);
}
break;
case video::EVT_TANGENTS:
{
const video::S3DVertexTangents* v =
(const video::S3DVertexTangents*)original->getVertices();
vNew = v[idx[i]];
}
break;
}
core::map<video::S3DVertexTangents, int>::Node* n = vertMap.find(vNew);
if (n)
{
vertLocation = n->getValue();
}
else
{
vertLocation = buffer->Vertices.size();
buffer->Vertices.push_back(vNew);
vertMap.insert(vNew, vertLocation);
}
// create new indices
buffer->Indices.push_back(vertLocation);
}
buffer->recalculateBoundingBox();
// add new buffer
clone->addMeshBuffer(buffer);
buffer->drop();
}
clone->recalculateBoundingBox();
if (calculateTangents)
recalculateTangents(clone, recalculateNormals, smooth, angleWeighted);
irr_driver->removeMeshFromCache(mesh);
return clone;
}
/**
* @brief Convert a Postgres MergeJoin into a Peloton SeqScanNode.
* @return Pointer to the constructed AbstractPlanNode.
*/
std::unique_ptr<planner::AbstractPlan> PlanTransformer::TransformMergeJoin(
const MergeJoinPlanState *mj_plan_state) {
std::unique_ptr<planner::AbstractPlan> result;
PelotonJoinType join_type =
PlanTransformer::TransformJoinType(mj_plan_state->jointype);
if (join_type == JOIN_TYPE_INVALID) {
LOG_ERROR("unsupported join type: %d", mj_plan_state->jointype);
return std::unique_ptr<planner::AbstractPlan>();
}
LOG_TRACE("Handle merge join with join type: %d", join_type);
std::vector<planner::MergeJoinPlan::JoinClause> join_clauses =
BuildMergeJoinClauses(mj_plan_state->mj_Clauses,
mj_plan_state->mj_NumClauses);
expression::AbstractExpression *join_filter = ExprTransformer::TransformExpr(
reinterpret_cast<ExprState *>(mj_plan_state->joinqual));
expression::AbstractExpression *plan_filter = ExprTransformer::TransformExpr(
reinterpret_cast<ExprState *>(mj_plan_state->qual));
std::unique_ptr<const expression::AbstractExpression> predicate(nullptr);
if (join_filter && plan_filter) {
predicate.reset(expression::ExpressionUtil::ConjunctionFactory(
EXPRESSION_TYPE_CONJUNCTION_AND, join_filter, plan_filter));
} else if (join_filter) {
predicate.reset(join_filter);
} else {
predicate.reset(plan_filter);
}
/* Transform project info */
std::unique_ptr<const planner::ProjectInfo> project_info(nullptr);
std::shared_ptr<const catalog::Schema> project_schema(
SchemaTransformer::GetSchemaFromTupleDesc(
mj_plan_state->tts_tupleDescriptor));
project_info.reset(BuildProjectInfoFromTLSkipJunk(mj_plan_state->targetlist));
bool non_trivial = (project_info.get() != nullptr &&
project_info.get()->isNonTrivial());
if (non_trivial) {
// we have non-trivial projection
LOG_TRACE("We have non-trivial projection");
result = std::unique_ptr<planner::AbstractPlan>(
new planner::ProjectionPlan(std::move(project_info), project_schema));
// set project_info to nullptr
project_info.reset();
} else {
LOG_TRACE("We have direct mapping projection");
}
std::unique_ptr<planner::MergeJoinPlan> plan_node(new planner::MergeJoinPlan(
join_type, std::move(predicate), std::move(project_info), project_schema,
join_clauses));
std::unique_ptr<planner::AbstractPlan> outer{std::move(
PlanTransformer::TransformPlan(outerAbstractPlanState(mj_plan_state)))};
std::unique_ptr<planner::AbstractPlan> inner{std::move(
PlanTransformer::TransformPlan(innerAbstractPlanState(mj_plan_state)))};
/* Add the children nodes */
plan_node->AddChild(std::move(outer));
plan_node->AddChild(std::move(inner));
if (non_trivial) {
result->AddChild(std::move(plan_node));
} else {
result.reset(plan_node.release());
}
LOG_TRACE("Finishing mapping Merge join, JoinType: %d", join_type);
return result;
}
void Scene_combinatorial_map_item::export_B_minus_A_as_polyhedron() const{
Select_B_minus_A predicate(address_of_A);
export_as_polyhedron(predicate,QString("%1_minus_%2").arg("B").arg("A"));
}
void
peep(void)
{
Reg *r, *r1, *r2;
Prog *p, *p1;
int t;
p1 = nil;
USED(p1); // ... in unreachable code...
/*
* complete R structure
*/
for(r=firstr; r!=R; r=r1) {
r1 = r->link;
if(r1 == R)
break;
p = r->prog->link;
while(p != r1->prog)
switch(p->as) {
default:
r2 = rega();
r->link = r2;
r2->link = r1;
r2->prog = p;
r2->p1 = r;
r->s1 = r2;
r2->s1 = r1;
r1->p1 = r2;
r = r2;
case ADATA:
case AGLOBL:
case ANAME:
case ASIGNAME:
p = p->link;
}
}
//dumpit("begin", firstr);
loop1:
t = 0;
for(r=firstr; r!=R; r=r->link) {
p = r->prog;
switch(p->as) {
case ASLL:
case ASRL:
case ASRA:
/*
* elide shift into D_SHIFT operand of subsequent instruction
*/
// if(shiftprop(r)) {
// excise(r);
// t++;
// break;
// }
break;
case AMOVW:
case AMOVF:
case AMOVD:
if(regtyp(&p->from))
if(p->from.type == p->to.type)
if(p->scond == C_SCOND_NONE) {
if(copyprop(r)) {
excise(r);
t++;
break;
}
if(subprop(r) && copyprop(r)) {
excise(r);
t++;
break;
}
}
break;
#ifdef NOTDEF
if(p->scond == C_SCOND_NONE)
if(regtyp(&p->to))
if(isdconst(&p->from)) {
constprop(&p->from, &p->to, r->s1);
}
break;
#endif
}
}
if(t)
goto loop1;
return;
#ifdef NOTDEF
for(r=firstr; r!=R; r=r->link) {
p = r->prog;
switch(p->as) {
// case AEOR:
// /*
// * EOR -1,x,y => MVN x,y
// */
// if(isdconst(&p->from) && p->from.offset == -1) {
// p->as = AMVN;
// p->from.type = D_REG;
// if(p->reg != NREG)
// p->from.reg = p->reg;
// else
// p->from.reg = p->to.reg;
// p->reg = NREG;
// }
// break;
case AMOVH:
case AMOVHU:
case AMOVB:
case AMOVBU:
/*
* look for MOVB x,R; MOVB R,R
*/
if(p->to.type != D_REG)
break;
if(r1 == R)
break;
p1 = r1->prog;
if(p1->as != p->as)
break;
if(p1->from.type != D_REG || p1->from.reg != p->to.reg)
break;
if(p1->to.type != D_REG || p1->to.reg != p->to.reg)
break;
excise(r1);
break;
}
r1 = r->link;
}
// for(r=firstr; r!=R; r=r->link) {
// p = r->prog;
// switch(p->as) {
// case AMOVW:
// case AMOVB:
// case AMOVBU:
// if(p->from.type == D_OREG && p->from.offset == 0)
// xtramodes(r, &p->from);
// else
// if(p->to.type == D_OREG && p->to.offset == 0)
// xtramodes(r, &p->to);
// else
// continue;
// break;
// case ACMP:
// /*
// * elide CMP $0,x if calculation of x can set condition codes
// */
// if(isdconst(&p->from) || p->from.offset != 0)
// continue;
// r2 = r->s1;
// if(r2 == R)
// continue;
// t = r2->prog->as;
// switch(t) {
// default:
// continue;
// case ABEQ:
// case ABNE:
// case ABMI:
// case ABPL:
// break;
// case ABGE:
// t = ABPL;
// break;
// case ABLT:
// t = ABMI;
// break;
// case ABHI:
// t = ABNE;
// break;
// case ABLS:
// t = ABEQ;
// break;
// }
// r1 = r;
// do
// r1 = uniqp(r1);
// while (r1 != R && r1->prog->as == ANOP);
// if(r1 == R)
// continue;
// p1 = r1->prog;
// if(p1->to.type != D_REG)
// continue;
// if(p1->to.reg != p->reg)
// if(!(p1->as == AMOVW && p1->from.type == D_REG && p1->from.reg == p->reg))
// continue;
//
// switch(p1->as) {
// default:
// continue;
// case AMOVW:
// if(p1->from.type != D_REG)
// continue;
// case AAND:
// case AEOR:
// case AORR:
// case ABIC:
// case AMVN:
// case ASUB:
// case ARSB:
// case AADD:
// case AADC:
// case ASBC:
// case ARSC:
// break;
// }
// p1->scond |= C_SBIT;
// r2->prog->as = t;
// excise(r);
// continue;
// }
// }
predicate();
#endif
}
fu_findfiles_t *
fu_find_files(const char *basedir, struct obstack *pool,
size_t nbulk, int flags,
int (*predicate)(const char *, void *), void *data)
{
static const char *saved_cwd = 0;
static const char *dummy_off = 0;
fu_findfiles_t *list = 0;
char *cwd;
char *pathname;
DIR *dir, *auxdir;
struct dirent *ent;
off_t off;
int saved_errno = 0;
//assert(OBSTACK_OBJECT_SIZE(offpool) == 0);
//assert(OBSTACK_OBJECT_SIZE(cwdpool) == 0);
//assert(OBSTACK_OBJECT_SIZE(pool) == 0);
if (pool == 0) {
if (saved_cwd)
OBSTACK_FREE(cwdpool, (void *)saved_cwd);
if (dummy_off)
OBSTACK_FREE(offpool, (void *)dummy_off);
saved_cwd = dummy_off = 0;
return 0;
}
if (basedir) {
if (saved_cwd)
OBSTACK_FREE(cwdpool, (void *)saved_cwd);
if (dummy_off)
OBSTACK_FREE(offpool, (void *)dummy_off);
saved_cwd = OBSTACK_GETCWD(cwdpool);
dummy_off = OBSTACK_ALLOC(offpool, 1);
if (chdir(basedir) < 0)
goto err;
}
cwd = OBSTACK_GETCWD(cwdpool);
if (!cwd)
goto err;
//basename = OBSTACK_BASE(cwdpool) + strlen(cwd);
list = OBSTACK_ALLOC(pool,
sizeof(*list) + (nbulk - 1) * sizeof(const char *));
if (!list)
goto err;
list->nelem = 0;
dir = opendir(cwd);
if (!basedir) {
if (OFFSET_ISEMPTY()) {
closedir(dir);
goto end;
}
seekdir(dir, OFFSET_POP());
}
read_entry:
while ((ent = readdir(dir)) != NULL) {
if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0)
continue;
/* conceptually, this block does
* pathname = pathname + '/' + ent->dname */
pathname = OBSTACK_STR_GROW3(cwdpool, cwd, "/", ent->d_name);
//OBSTACK_BLANK(cwdpool, -1);
//pathname = OBSTACK_STR_GROW2(cwdpool, "/", ent->d_name);
if ((flags & FU_NOFOLLOW) && fu_islink(pathname)) {
OBSTACK_FREE(cwdpool, pathname);
continue;
}
if (fu_isdir(pathname)) { /* If ENT is a direcotry, */
if ((flags & FU_DIRPRED) &&
predicate && predicate(pathname, data) == 0) {
OBSTACK_FREE(cwdpool, pathname);
continue;
}
auxdir = opendir(pathname);
if (auxdir && chdir(pathname) == 0) { /* Entering new directory, */
OFFSET_PUSH(telldir(dir));
closedir(dir);
dir = auxdir;
OBSTACK_FREE(cwdpool, cwd);
cwd = OBSTACK_GETCWD(cwdpool);
}
else { /* If something goes wrong, skip this directory. */
if (auxdir)
closedir(auxdir);
OBSTACK_FREE(cwdpool, pathname);
}
}
else { /* If ENT is a regular file, */
if (predicate && predicate(pathname, data) == 0)
continue;
if (flags & FU_URLFORM)
list->names[list->nelem] = OBSTACK_STR_COPY2(pool, "file://", pathname);
else
list->names[list->nelem] = OBSTACK_STR_COPY(pool, pathname);
list->nelem++;
if (list->nelem >= nbulk) {
OFFSET_PUSH(telldir(dir));
closedir(dir);
OBSTACK_FREE(cwdpool, cwd);
return list;
}
OBSTACK_FREE(cwdpool, pathname);
}
}
closedir(dir);
if (!OFFSET_ISEMPTY()) {
off = OFFSET_POP();
if (chdir("..") < 0) {
/* Unable to traverse back to the parent directory. */
goto err;
}
OBSTACK_FREE(cwdpool, cwd);
cwd = OBSTACK_GETCWD(cwdpool);
dir = opendir(cwd);
if (!dir)
return -1;
seekdir(dir, off);
goto read_entry;
}
end:
if (dummy_off) {
OBSTACK_FREE(offpool, (void *)dummy_off);
dummy_off = 0;
}
if (saved_cwd) {
if (chdir(saved_cwd) < 0)
goto err;
OBSTACK_FREE(cwdpool, (void *)saved_cwd);
saved_cwd = 0;
}
if (list->nelem == 0) {
OBSTACK_FREE(pool, list);
list = 0;
}
return list;
err:
saved_errno = errno;
if (dummy_off) {
OBSTACK_FREE(offpool, (void *)dummy_off);
dummy_off = 0;
}
if (saved_cwd) {
chdir(saved_cwd);
OBSTACK_FREE(cwdpool, (void *)saved_cwd);
saved_cwd = 0;
}
if (list) {
OBSTACK_FREE(pool, list);
}
return 0;
}
static long
subexpr(register int precedence, int* pun)
{
register int c;
register long n;
register long x;
register int operand = 1;
int un = 0;
int xn;
switch (lex(c))
{
case 0:
case '\n':
unlex(c);
if (!errmsg && !(pp.mode & INACTIVE)) errmsg = "more tokens expected";
return 0;
case '-':
n = -subexpr(13, &un);
break;
case '+':
n = subexpr(13, &un);
break;
case '!':
n = !subexpr(13, &un);
break;
case '~':
n = ~subexpr(13, &un);
break;
default:
unlex(c);
n = 0;
operand = 0;
break;
}
un <<= 1;
for (;;)
{
switch (lex(c))
{
case 0:
case '\n':
goto done;
case ')':
if (!precedence)
{
if (!errmsg && !(pp.mode & INACTIVE)) errmsg = "too many )'s";
return 0;
}
goto done;
case '(':
n = subexpr(1, &un);
if (lex(c) != ')')
{
unlex(c);
if (!errmsg && !(pp.mode & INACTIVE)) errmsg = "closing ) expected";
return 0;
}
gotoperand:
if (operand)
{
if (!errmsg && !(pp.mode & INACTIVE)) errmsg = "operator expected";
return 0;
}
operand = 1;
un <<= 1;
continue;
case '?':
if (precedence > 1) goto done;
un = 0;
if (lex(c) == ':')
{
if (!n) n = subexpr(2, &un);
else
{
x = pp.mode;
pp.mode |= INACTIVE;
subexpr(2, &xn);
pp.mode = x;
}
}
else
{
unlex(c);
x = subexpr(2, &xn);
if (lex(c) != ':')
{
unlex(c);
if (!errmsg && !(pp.mode & INACTIVE)) errmsg = ": expected for ? operator";
return 0;
}
if (n)
{
n = x;
un = xn;
subexpr(2, &xn);
}
else n = subexpr(2, &un);
}
break;
case ':':
goto done;
case T_ANDAND:
case T_OROR:
xn = (c == T_ANDAND) ? 4 : 3;
if (precedence >= xn) goto done;
if ((n != 0) == (c == T_ANDAND)) n = subexpr(xn, &un) != 0;
else
{
x = pp.mode;
pp.mode |= INACTIVE;
subexpr(xn, &un);
pp.mode = x;
}
un = 0;
break;
case '|':
if (precedence > 4) goto done;
n |= subexpr(5, &un);
break;
case '^':
if (precedence > 5) goto done;
n ^= subexpr(6, &un);
break;
case '&':
if (precedence > 6) goto done;
n &= subexpr(7, &un);
break;
case T_EQ:
case T_NE:
if (precedence > 7) goto done;
n = (n == subexpr(8, &un)) == (c == T_EQ);
un = 0;
break;
case '<':
case T_LE:
case T_GE:
case '>':
if (precedence > 8) goto done;
x = subexpr(9, &un);
switch (c)
{
case '<':
switch (un)
{
case 01:
n = n < (unsigned long)x;
break;
case 02:
n = (unsigned long)n < x;
break;
case 03:
n = (unsigned long)n < (unsigned long)x;
break;
default:
n = n < x;
break;
}
break;
case T_LE:
switch (un)
{
case 01:
n = n <= (unsigned long)x;
break;
case 02:
n = (unsigned long)n <= x;
break;
case 03:
n = (unsigned long)n <= (unsigned long)x;
break;
default:
n = n <= x;
break;
}
break;
case T_GE:
switch (un)
{
case 01:
n = n >= (unsigned long)x;
break;
case 02:
n = (unsigned long)n >= x;
break;
case 03:
n = (unsigned long)n >= (unsigned long)x;
break;
default:
n = n >= x;
break;
}
break;
case '>':
switch (un)
{
case 01:
n = n > (unsigned long)x;
break;
case 02:
n = (unsigned long)n > x;
break;
case 03:
n = (unsigned long)n > (unsigned long)x;
break;
default:
n = n > x;
break;
}
break;
}
un = 0;
break;
case T_LSHIFT:
case T_RSHIFT:
if (precedence > 9) goto done;
x = subexpr(10, &un);
if (c == T_LSHIFT) n <<= x;
else n >>= x;
un >>= 1;
break;
case '+':
case '-':
if (precedence > 10) goto done;
x = subexpr(11, &un);
if (c == '+') n += x;
else n -= x;
break;
case '*':
case '/':
case '%':
if (precedence > 11) goto done;
x = subexpr(12, &un);
if (c == '*') n *= x;
else if (x == 0)
{
if (!errmsg && !(pp.mode & INACTIVE)) errmsg = "divide by zero";
return 0;
}
else if (c == '/') n /= x;
else n %= x;
break;
case '#':
pp.state |= DISABLE;
c = pplex();
pp.state &= ~DISABLE;
if (c != T_ID)
{
if (!errmsg && !(pp.mode & INACTIVE)) errmsg = "# must precede a predicate identifier";
return 0;
}
n = predicate(0);
goto gotoperand;
case T_ID:
n = predicate(1);
goto gotoperand;
case T_CHARCONST:
c = *(pp.toknxt - 1);
*(pp.toknxt - 1) = 0;
n = chrtoi(pp.token + 1);
*(pp.toknxt - 1) = c;
if (n & ~((1<<CHAR_BIT)-1))
{
if (!(pp.mode & HOSTED))
error(1, "'%s': multi-character character constants are not portable", pp.token);
}
#if CHAR_MIN < 0
else n = (char)n;
#endif
goto gotoperand;
case T_DECIMAL_U:
case T_DECIMAL_UL:
case T_OCTAL_U:
case T_OCTAL_UL:
case T_HEXADECIMAL_U:
case T_HEXADECIMAL_UL:
un |= 01;
/*FALLTHROUGH*/
case T_DECIMAL:
case T_DECIMAL_L:
case T_OCTAL:
case T_OCTAL_L:
case T_HEXADECIMAL:
case T_HEXADECIMAL_L:
n = strtoul(pp.token, NiL, 0);
if ((unsigned long)n > LONG_MAX) un |= 01;
goto gotoperand;
case T_WCHARCONST:
n = chrtoi(pp.token);
goto gotoperand;
default:
if (!errmsg && !(pp.mode & INACTIVE)) errmsg = "invalid token";
return 0;
}
if (errmsg) return 0;
if (!operand) goto nooperand;
}
done:
unlex(c);
if (!operand)
{
nooperand:
if (!errmsg && !(pp.mode & INACTIVE)) errmsg = "operand expected";
return 0;
}
if (un) *pun |= 01;
return n;
}
