int analyse_state_i(Slice *psl, Replica *prep, int len, int state_index) {
int i,visitedA,visited2;
visitedA=visited2 =0;
if (in_upper_window(&psl[0], prep,state_index)){
for (i=1;i<len;i++) {
if (in_state(&psl[i])==state_index){
visitedA =1;
}
if ((visitedA) && (in_upper_window(&psl[i], prep,state_index))) {
visited2 =1;
}
}
if ((visitedA) && (in_upper_window(&psl[len-1], prep,state_index))){
//printf("path OK\n");
return 1;
}
if ((visitedA) && (visited2) ) {
printf ("path starts in 1, visits A and then 1 but doesn't end in 1\n");
return 1;
}
}
for(i=0;i<prep->pathlen;i++) {
print_rc(&slice[i],state_index);
printf(" lambda = %g ",prep->lambda );
dprint(in_state(&slice[i]));
}
printf("analyse i: path corrupted in replica %d \n",prep->index);
dprint(path.initial_state);
return 0;
}
int analyse ( Slice *psl, Replica *prep, int len, int state_index) {
int i,initial_state,final_state;
initial_state=in_state(&psl[0]);
final_state=in_state(&psl[len-1]);
if (initial_state==state_index) {
if (final_state==state_index) {
for (i=0;i<len;i++) {
if (in_upper_window(&psl[i], prep,state_index)){
return 1;
}
}
//printf("path did not reach lambda %g\n",prep->lambda);
//print_rc(&psl[0],state_index);
//print_rc(&psl[len-1],state_index);
return 0;
}
else {
if (final_state==0) {
printf("final state unknown\n");
print_rc(&psl[0],state_index);
print_rc(&psl[len-1],state_index);
return 0;
}
for (i=0;i<len;i++) {
if (in_upper_window(&psl[i], prep,state_index)) {
//printf("intermediate slice %d is larger than lambda %g \n",i,prep->lambda);
return 2;
}
}
//printf("warning: type 2 but path did not reach lambda\n");
//dprint(initial_state);
//dprint(final_state);
//dprint(path.current_replica);
//for(i=0; i<prep->pathlen; i++) {
// print_rc(&(trial[i]),state_index);
// }
return 0;
}
}
printf("analyse: path of length %d corrupted in replica %d, initial %d final %d, state index %d \n",len, prep->index,initial_state,final_state,state_index);
print_rc(&psl[0],state_index);
print_rc(&psl[len-1],state_index);
return 0;
}
// narrow to wide
intern_string_type ntow(const extern_string_type& src) const {
// preparations
// a size of src string
const std::size_t size = src.length();
// no more task
if (size == 0) return intern_string_type();
// buffers
std::vector<intern_type> dst_vctr(size);
intern_type* const dst = &dst_vctr[0];
// a dummy variable and a pointer to the next position
const extern_type* dummy;
intern_type* next;
// cache the first position of c style characters
const extern_type* const s = src.c_str();
// do it
if (codecvt().in(
in_state(),
s, s + size, dummy,
dst, dst + size, next) == codecvt_type::ok) {
return std::wstring(dst, next - dst);
}
std::string errmsg("failed: ");
errmsg.append(src);
throw std::logic_error(errmsg);
}
bool parse(std::string phrase, ValueRef::ValueRefBase<int>*& result) {
parse::value_ref_parser_rule<int>::type& rule = parse::value_ref_parser<int>();
const parse::lexer& lexer = lexer.instance();
boost::spirit::qi::in_state_type in_state;
boost::spirit::qi::eoi_type eoi;
boost::spirit::qi::_1_type _1;
std::string::const_iterator begin_phrase = phrase.begin();
std::string::const_iterator end_phrase = phrase.end();
return boost::spirit::qi::phrase_parse(
lexer.begin(begin_phrase, end_phrase),
lexer.end(),
rule[boost::phoenix::ref(result) = _1] > eoi,
in_state("WS")[lexer.self]
);
}
int trajectory(Slice *psl, int maxlength) {
int i,istate;
for (i=1;i<maxlength;i++) {
psl[i] = psl[i-1];
propagate_bd(&psl[i]);
create_all_rc(&(psl[i]));
if (in_state(&psl[i])>0) {
return i;
}
}
printf("maxlength %d reached ",maxlength);
printf("psl %d energy %lf order_parameter %lf mindist %lf\n",i,psl[i-1].energy,psl[i-1].order_parameter,psl[i-1].rijdist);
return 0;
}
bool parse(std::string phrase, ValueRef::ValueRefBase<std::string>*& result) {
const parse::lexer& lexer = lexer.instance();
boost::spirit::qi::in_state_type in_state;
boost::spirit::qi::eoi_type eoi;
boost::spirit::qi::_1_type _1;
std::string::const_iterator begin_phrase = phrase.begin();
std::string::const_iterator end_phrase = phrase.end();
auto begin = lexer.begin(begin_phrase, end_phrase);
auto end = lexer.end();
bool matched = boost::spirit::qi::phrase_parse(
begin, end,
string_grammar[boost::phoenix::ref(result) = _1] > eoi,
in_state("WS")[lexer.self]
);
return matched && begin == end;
}
int main(void)
{
QUEUE queue;
int value;
init(&queue);
in_state(en_queue(&queue, 1));
in_state(en_queue(&queue, 3));
in_state(en_queue(&queue, 6));
in_state(en_queue(&queue, 4));
in_state(en_queue(&queue, 9));
in_state(en_queue(&queue, 10));
in_state(en_queue(&queue, 19));
traverse(&queue);
out_state(out(&queue, &value));
printf("出队元素：%d\n", value);
traverse(&queue);
return ;
}
void test_plan() {
cout<<"********************************"<<endl;
cout<<" libPRADA plan demo"<<endl;
cout<<" Domain: Robot Manipulation"<<endl;
cout<<" This demo shows how to set up a planning problem and solve it."<<endl
<<" It uses the robot manipulation domain of the experiments in"<<endl
<<" the paper Lang & Toussaint, JAIR (2010)."<<endl;
cout<<"********************************"<<endl;
// -------------------------------------
// READ CONFIG
// -------------------------------------
cout<<endl<<"READ CONFIG:"<<endl;
uint randSeed;
MT::getParameter(randSeed, "randSeed");
rnd.seed(randSeed);
PRINT(randSeed);
uint plan_type;
MT::getParameter(plan_type, "plan_type");
PRINT(plan_type);
double discountFactor;
MT::getParameter(discountFactor, "discountFactor");
PRINT(discountFactor);
double SST_noise_scaling_factor;
MT::getParameter(SST_noise_scaling_factor, "noise_scaling_factor");
PRINT(SST_noise_scaling_factor);
uint SST_branch;
MT::getParameter(SST_branch, "SST_branch");
PRINT(SST_branch);
uint SST_horizon;
MT::getParameter(SST_horizon, "SST_horizon");
PRINT(SST_horizon);
uint PRADA_horizon;
MT::getParameter(PRADA_horizon, "PRADA_horizon");
PRINT(PRADA_horizon);
uint PRADA_num_samples;
MT::getParameter(PRADA_num_samples, "PRADA_num_samples");
PRINT(PRADA_num_samples);
double PRADA_noise_softener;
MT::getParameter(PRADA_noise_softener, "PRADA_noise_softener");
PRINT(PRADA_noise_softener);
uint UCT_horizon;
MT::getParameter(UCT_horizon, "UCT_horizon");
PRINT(UCT_horizon);
uint UCT_c;
MT::getParameter(UCT_c, "UCT_c");
PRINT(UCT_c);
uint UCT_numEpisodes;
MT::getParameter(UCT_numEpisodes, "UCT_numEpisodes");
PRINT(UCT_numEpisodes);
uint horizon;
if (plan_type == PLAN_TYPE__SST) horizon = SST_horizon;
else if (plan_type == PLAN_TYPE__UCT) horizon = UCT_horizon;
else horizon = PRADA_horizon;
PRINT(horizon);
MT::String rulesFile_name;
MT::getParameter(rulesFile_name, "file_rules");
PRINT(rulesFile_name);
MT::String stateFile_name;
MT::getParameter(stateFile_name, "file_state");
PRINT(stateFile_name);
MT::String rewardFile_name;
MT::getParameter(rewardFile_name, "file_reward");
PRINT(rewardFile_name);
MT::String symbolsFile_name;
MT::getParameter(symbolsFile_name, "file_symbols");
PRINT(symbolsFile_name);
// -------------------------------------
// SET UP LOGIC
// -------------------------------------
cout<<endl<<endl;
cout<<"SYMBOLS:"<<endl;
cout<<"Reading symbols from file \""<<symbolsFile_name<<"\"..."<<flush;
relational::SymL symbols;
relational::ArgumentTypeL types;
relational::readSymbolsAndTypes(symbols, types, symbolsFile_name);
cout<<"done!"<<endl;
relational::writeSymbolsAndTypes("used_symbols.dat");
// -------------------------------------
// STATE
// -------------------------------------
cout<<endl<<endl;
cout<<"STARTING STATE:"<<endl;
cout<<"Reading state from file \""<<stateFile_name<<"\"... "<<flush;
relational::SymbolicState s;
ifstream in_state(stateFile_name);
s.read(in_state);
cout<<"done!"<<endl<<endl;
cout<<"State:"<<endl<<s<<endl<<endl;
relational::reason::setConstants(s.state_constants);
cout<<"CONSTANTS:"<<endl; PRINT(relational::reason::getConstants());
// -------------------------------------
// REWARD
// -------------------------------------
cout<<endl<<endl;
cout<<"REWARD: "<<endl;
relational::Reward* reward = NULL;
// (1) SIMPLE REWARD FOR TOWER
// Create here by hand
// (1a) LiteralReward
// relational::Literal* lit = relational::Literal::get(relational::Symbol::get("on"), TUP(66, 67), 1.);
// reward = new relational::LiteralReward(lit);
// (1b) LiteralListReward
relational::LitL lits_reward;
relational::Literal::get(lits_reward, MT::String("on(66 69) on(69 67)"));
reward = new relational::LiteralListReward(lits_reward);
// (2) STACKING REWARD
// Use specification in robotManipulationInterface
// reward = relational::RobotManipulationSymbols::RewardLibrary::stack();
reward->write();
// -------------------------------------
// RULES
// -------------------------------------
cout<<endl<<endl;
cout<<"RULES:"<<endl;
relational::RuleSet rules;
relational::RuleSet::read(rulesFile_name, rules);
cout<<"Rules successfully read from file \""<<rulesFile_name<<"\"."<<endl;
cout<<"Rules ("<<rules.num()<<"):"<<endl; rules.write(cout);
#if 1
// Manually create "doNothing"-rule if desired
relational::Rule* rule_doNothing = relational::Rule::getDoNothingRule();
rules.append(rule_doNothing);
rule_doNothing->write();
#endif
// Example: check which rules cover the current state
relational::RuleSet coveringGroundRules;
relational::reason::calc_coveringRules(coveringGroundRules, rules, s);
// cout<<endl<<endl<<"COVERING RULE GROUNDINGS FOR START STATE (#="<<coveringGroundRules.num()<<"):"<<endl;
// coveringGroundRules.write();
// if (coveringGroundRules.num() == 0
// || (coveringGroundRules.num() == 1 && relational::Rule::isDefaultRule(coveringGroundRules.elem(0)))) {
// cout<<"No covering rules for current state!"<<endl;
// }
// cout<<endl<<endl<<endl;
cout<<endl<<endl<<"Ground actions with unique covering rules:"<<endl;
uint i;
FOR1D_(coveringGroundRules, i) {
cout<<*coveringGroundRules.elem(i)->action<<" ";
}
FeatureFunction::StateModifications
*SelectedWordSlowLM<M>::estimateScoreUpdate(
const DocumentState &doc,
const SearchStep &step,
const State *state,
Scores::const_iterator psbegin,
Scores::iterator sbegin
) const {
const SelectedWordSlowLMState *prevstate =
dynamic_cast<const SelectedWordSlowLMState *>(state);
SelectedWordSlowLMState *s = prevstate->clone();
uint sentNo = 0;
uint lastPos = 0;
// run through all modifications and check if we need to update the word list
const std::vector<SearchStep::Modification>
&mods = step.getModifications();
std::vector<SearchStep::Modification>::const_iterator
it = mods.begin();
while(it != mods.end()) {
PhraseSegmentation::const_iterator from_it = it->from_it;
PhraseSegmentation::const_iterator to_it = it->to_it;
const PhraseSegmentation ¤t = doc.getPhraseSegmentation(it->sentno);
if(sentNo != it->sentno) {
sentNo = it->sentno;
s->sentWords[sentNo].clear();
for(PhraseSegmentation::const_iterator
pit = current.begin();
pit != from_it;
++pit
) {
s->AddWord(sentNo, *pit, maxWordLength);
}
lastPos = 0;
}
if(lastPos > std::distance(current.begin(), from_it) ) {
LOG(logger_, debug, "WARNING! Modifications are not in target sentence order! "
<< lastPos << " " << std::distance(current.begin(), from_it)
);
}
lastPos = std::distance(current.begin(), from_it);
// record the words in the proposed modification (and compare to current word list)
BOOST_FOREACH(const AnchoredPhrasePair &app, it->proposal) {
s->AddWord(sentNo, app, maxWordLength);
}
it++;
if(it != mods.end()) {
if(sentNo != it->sentno) {
for(PhraseSegmentation::const_iterator pit=to_it; pit!=current.end(); pit++) {
s->AddWord(sentNo, *pit, maxWordLength);
}
}
}
}
// TODO: this is stupid: re-score the entire document!
StateType_ in_state(model_->BeginSentenceState()), out_state;
const VocabularyType_ &vocab = model_->GetVocabulary();
Float score;
for(uint i = 0; i < s->sentWords.size(); ++i) {
for(uint j = 0; j < s->sentWords[i].size(); ++j) {
score += model_->Score(in_state,vocab.Index(s->sentWords[i][j]),out_state);
// LOG(logger_, debug, "add score for " << s->sentWords[i][j] << " = " << score);
in_state = out_state;
}
}
LOG(logger_, debug, "new LM score " << score);
s->currentScore = score;
*sbegin = s->score();
return s;
}
int swap_states(int irep,int jrep) {
Replica *prepi,*prepj;
int i,j,initial_state,final_state,pathlen,type,start,index,maxlength,len;
double aux;
if(path.current_replica!=(state[path.initial_state-1].nrep-1)) {
return 0;
}
if(path.stateswapbias==2) {
state[path.initial_state-1].dos+=path.scalefactor;
}
prepi=replica[irep];
if (prepi->type!=2) {
return 0;
}
pathlen =prepi->pathlen;
initial_state=in_state(&slice[0]);
final_state=in_state(&slice[pathlen-1]);
if(final_state==initial_state) {
printf("Warning swap states: final state is not initial state despite being type 2\n");
return 0;
}
if (initial_state != path.initial_state ) {
printf("error: initial state not correct\n");
return 0;
}
if(final_state==0) {
printf("error state swap: final state unknown\n");
return 0;
}
if(initial_state==0) {
printf("error state swap: initial state unknown\n");
return 0;
}
path.block_stats[path.initial_state-1][prepi->index].mcacc[2].tries++;
////pick random replica of the final state;
//jrep = (int)(RandomNumber()*(state[final_state-1].nrep-1)) +1;
//if(jrep==0) {
// printf("Warning swap states: jrep is 0, should at least be 1\n");
//}
//prepj=&state[final_state-1].srep[jrep];
jrep = state[final_state-1].nrep-1;
prepj =&state[final_state-1].srep[jrep];
double nrepratio;
//nrepratio = (double)(state[final_state-1].nrep-1.)/(double)(state[initial_state-1].nrep-1.);
nrepratio=1;
if(path.stateswapbias==1) {
aux = prepi->dos - prepj->dos;
if (RandomNumber() > (nrepratio*exp(aux))) {
return 0;
}
}
else if(path.stateswapbias==2) {
aux = state[initial_state-1].dos-state[final_state-1].dos;
if (RandomNumber() > (nrepratio*exp(aux))) {
return 0;
}
}
else {
if (RandomNumber() > nrepratio) {
return 0;
}
}
//printf("Rejected state swap I %d J %d: nrepratio: %lf dosdiff: %lf\n",initial_state,final_state,nrepratio,aux);
if (final_state == 1 || final_state == 2 ) {
path.current_gsen = state[final_state-1].target.energy;
}
if (final_state == 3) {
path.current_gsen = -2.0*sqrt(sys.site[slice[pathlen-1].minisite].eps*sys.site[slice[pathlen-1].minjsite].eps);
}
path.initial_state = final_state;
path.final_state = initial_state;
for(i=0;i< pathlen;i++) {
trial[i]= slice[pathlen - 1 - i];
create_all_rc(&(trial[i]));
}
type = analyse(trial,prepj,pathlen,final_state);
if ( type!=2 ) {
//printf("Rejected state swap:wrong type -1 \n");
//if(initial_state==6) {
// printf("this happens when final_state = 7\n");
// printf("not right type after swap\n");
// dprint(type);
// dprint(path.initial_state);
// dprint(initial_state);
// dprint(final_state);
// dprint(irep);
// dprint(jrep);
// gprint(path.current_gsen);
// gprint(state[initial_state-1].target.energy);
// gprint(state[final_state-1].target.energy);
// print_rc(&trial[0],path.initial_state);
// print_rc(&trial[len-1],path.initial_state);
// print_rc(&slice[0],path.initial_state);
// print_rc(&slice[len-1],path.initial_state);
// }
if (initial_state == 3) {
path.current_gsen = -2.0*sqrt(sys.site[slice[0].minisite].eps*sys.site[slice[0].minjsite].eps);
}
else {
path.current_gsen = state[initial_state-1].target.energy;
}
path.initial_state = initial_state;
path.final_state = final_state;
return 0;
}
path.nreplica = state[final_state-1].nrep;
for(i=0; i<path.nreplica; i++) {
replica[i] = &state[path.initial_state-1].srep[i];
}
prepj->pathlen = pathlen;
for(j=0; j<pathlen; j++) {
slice[j] = trial[j];
//create_all_rc(&(slice[j]));
}
type = analyse(slice,prepj, prepj->pathlen, path.initial_state);
prepj->type = type;
path.current_replica=jrep;
path.block_stats[path.initial_state-1][prepi->index].mcacc[2].acc++;
return 1;
}
int swap_replica_0(int irep, int jrep) {
Replica *prep;
Slice *trial0;
Slice *trial1;
int i,j,pathlen0,pathlen1,inA,in1,index,maxlength,start,len,type,type0,type1,reversal;
int final_state;
trial0=fwtrial;
trial1=bwtrial;
if (irep ==0) {
prep =replica[0];
type =analyse_state_i(slice,prep,path.nslices, path.initial_state);
if (prep->type!=type) {
printf("swap 0->1 error : type %d and replica type %d do not match\n", type, prep->type);
return 0;
}
if(type==0) {
printf("error: replica 0 has wrong type\n");
return 0;
}
reversal = (RandomNumber()<0.5) ? 1 : 0;
if (reversal) {
pathlen0 = path.nslices;
for(j=0;j<pathlen0;j++) {
trial1[j]= slice[pathlen0 - 1 - j];// use trial1 for temp storage, to not affect slice
}
}
else {
for(i=0;i< path.nslices;i++) {
trial1[i]= slice[i];// use trial1 for temp storage, to not affect slice
}
}
for(i=path.nslices-1;i>=0;i--) {
if (in_state(&trial1[i])) {
start = i;
break;
}
}
for(i=start;i<path.nslices;i++) {
trial0[i-start]=trial1[i];
}
index = path.nslices - start - 1;
maxlength = MAXSLICES-index;
len = trajectory(&trial0[index],maxlength);
if (len==0) {
printf(" Swap replica 0: trajectory too long\n");
return 0;
}
pathlen0 = index +len+1;
if (pathlen0> MAXSLICES) {
printf("error: pathlen = %d\n",pathlen0);
return 0;
}
type= analyse(trial0,replica[1],pathlen0,path.initial_state );
if (type==0) {
return 0;
}
type0=type;
for(i=0;i<pathlen0;i++) {
slice[i]=trial0[i];
}
replica[1]->pathlen= pathlen0;
replica[1]->type = type0;
path.current_replica=jrep;
path.nslices = pathlen0;
prep = replica[1];
type = analyse(slice,prep,prep->pathlen, path.initial_state);
if (prep->type!=type) {
printf("swap 0->1 : type %d and replica type %d do not match\n", type, prep->type);
return 0;
}
if(type==0) {
printf("swap 0->1: replica 0 has wrong type\n");
return 0;
}
final_state=in_state(&slice[path.nslices-1]);
path.final_state = final_state;
}
if (jrep==0) {
prep =replica[1];
type =analyse(slice, prep, path.nslices, path.initial_state);
if (prep->type!=type) {
printf("error 1->0 : type %d and replica type %d do not match\n", type, prep->type);
return 0;
}
if(type==0) {
//printf("reject: replica 1 has wrong type\n");
return 0;
}
reversal = (RandomNumber()<0.5) ? 1 : 0;
if ((type == 2) && (reversal ==0)) {
reversal = 1;
//printf("type is 2, and reversal =0, still accept\n");
//return 0;
}
if (reversal) {
pathlen1 =path.nslices;
for(j=0;j< pathlen1;j++) {
trial0[j]= slice[pathlen1 - 1 - j]; // use trial0 for temp storage
}
}
else {
for(i=0; i<path.nslices; i++) {
trial0[i]= slice[i];// use trial0 for temp storage, to not affect slice
}
}
for(i=path.nslices-1;i>=0;i--) {
if (in_upper_window(&trial0[i],replica[0],path.initial_state)) {
start = i;
break;
}
}
for(i=start;i<path.nslices;i++) {
trial1[i-start]=trial0[i];
}
index= path.nslices - start-1;
maxlength= MAXSLICES-index;
len = trajectory_state_i(&trial1[index],prep,maxlength,path.initial_state);
if (len==0) {
printf(" Swap replica 0: trajectory too long\n");
return 0;
}
pathlen1 = index +len+1;
if (pathlen1 > MAXSLICES) {
//printf("error: pathlen = %d\n",pathlen1);
return 0;
}
type =analyse_state_i(trial1,replica[0],pathlen1, path.initial_state);
if ( type==0) {
printf(" Swap replica 0: trajectory too long\n");
return 0;
}
type1=type;
for(i=0;i<pathlen1;i++) {
slice[i]=trial1[i];
}
replica[0]->pathlen= pathlen1;
replica[0]->type = type1;
path.current_replica=jrep;
path.nslices=pathlen1;
prep = replica[0];
type =analyse_state_i(slice,prep,prep->pathlen, path.initial_state);
if (prep->type!=type) {
printf("swap 1->0 : type %d and replica type %d do not match\n", type, prep->type);
return 0;
}
if(type==0) {
printf("swap 1->0: replica 0 has wrong type\n");
return 0;
}
}
SWAP(replica[irep]->swapindex,replica[jrep]->swapindex,i);
path.block_stats[path.initial_state-1][prep->index].mcacc[1].acc++;
return 1;
}
int shoot_oneway(Replica *prep)
{
int i,j,index,len,pathlen,maxlength,trial_pathlen,type;
int initial_state,final_state;
if (prep->index==0) {
return 0;
}
//do not want to keep minus interface statistics for shooting
path.block_stats[path.initial_state-1][prep->index].mcacc[0].tries++;
index =0;
for (i=0;i<path.nslices;i++) {
if (in_upper_window(&slice[i], prep, path.initial_state)) {
index = i;
i = path.nslices;
}
}
//sanity check
if (in_upper_window(&slice[index], prep, path.initial_state)==0) {
return 0;
}
for(i=0;i<=index;i++) {
trial[i]=slice[i];
}
maxlength= MAXSLICES-index;
len = trajectory(&trial[index],maxlength);
if (len==0) {
printf("Shoot oneway: trajectory too long. State %d\n",path.initial_state);
return 0;
}
trial_pathlen = index+len+1;
if(trial_pathlen<3) {
printf("path is too short: %d, state %d\n",trial_pathlen,path.initial_state);
for(i=0; i<path.nslices; i++) {
print_rc(&slice[i],path.initial_state);
}
return 0;
}
type = analyse(trial,prep,trial_pathlen, path.initial_state);
if ( type==0 ) {
printf("Shoot Oneway: wrong type after shooting.\n");
dprint(path.initial_state);
initial_state = in_state(&(trial[0]));
gprint(trial[0].energy);
dprint(initial_state);
dprint(final_state);
dprint(prep->index);
return 0;
}
for(i=index+1;i<trial_pathlen;i++) {
slice[i] = trial[i];
}
final_state=in_state(&slice[trial_pathlen-1]);
path.final_state = final_state;
prep->pathlen= trial_pathlen;
path.nslices = trial_pathlen;
prep->type =type;
path.block_stats[path.initial_state-1][prep->index].mcacc[0].acc++;
return 1;
}
int main(int argc, char* argv[])
{
parse::report_error_::send_error_string = &send_error_string;
if (argc < 3) {
print_help();
exit(1);
}
const std::string test_str = argv[1];
test_type test = unknown;
#define CASE(x) if (test_str == #x) test = x
CASE(lexer);
CASE(double_value_ref_parser);
CASE(string_value_ref_parser);
CASE(planet_size_value_ref_parser);
CASE(planet_type_value_ref_parser);
CASE(planet_environment_value_ref_parser);
CASE(star_type_value_ref_parser);
CASE(condition_parser);
CASE(effect_parser);
CASE(buildings_parser);
CASE(specials_parser);
CASE(species_parser);
CASE(techs_parser);
CASE(items_parser);
CASE(ship_parts_parser);
CASE(ship_hulls_parser);
CASE(ship_designs_parser);
CASE(fleet_plans_parser);
CASE(monster_fleet_plans_parser);
CASE(alignments_parser);
#undef CASE
if (test == unknown) {
print_help();
exit(1);
}
std::string str;
if (4 <= argc && argc <= 5) {
if (std::string(argv[2]) != "-f") {
print_help();
exit(1);
}
std::ifstream ifs(argv[3]);
while (ifs) {
str += ifs.get();
}
// Get rid of terminating FF char.
if (!str.empty())
str.resize(str.size() - 1);
} else {
str = argv[2];
}
const bool fail = argc == 5 && argv[4] == std::string("--fail");
const parse::lexer& l = parse::lexer::instance();
parse::init();
unsigned int failures = 0;
unsigned int iterations = 0;
std::vector<std::string> strings;
if (!fail && buildings_parser <= test && test <= alignments_parser) {
assert(std::string(argv[2]) == "-f");
bool success = false;
try {
switch (test) {
case buildings_parser: {
std::map<std::string, BuildingType*> building_types;
success = parse::buildings(boost::filesystem::path(argv[3]), building_types);
break;
}
case specials_parser: {
std::map<std::string, Special*> specials;
success = parse::specials(boost::filesystem::path(argv[3]), specials);
break;
}
case species_parser: {
std::map<std::string, Species*> species;
success = parse::species(boost::filesystem::path(argv[3]), species);
break;
}
case techs_parser: {
TechManager::TechContainer techs;
std::map<std::string, TechCategory*> tech_categories;
std::set<std::string> categories_seen_in_techs;
success = parse::techs(boost::filesystem::path(argv[3]), techs, tech_categories, categories_seen_in_techs);
break;
}
case items_parser: {
std::vector<ItemSpec> items;
success = parse::items(boost::filesystem::path(argv[3]), items);
break;
}
case ship_parts_parser: {
std::map<std::string, PartType*> parts;
success = parse::ship_parts(boost::filesystem::path(argv[3]), parts);
break;
}
case ship_hulls_parser: {
std::map<std::string, HullType*> hulls;
success = parse::ship_hulls(boost::filesystem::path(argv[3]), hulls);
break;
}
case ship_designs_parser: {
std::map<std::string, ShipDesign*> designs;
success = parse::ship_designs(boost::filesystem::path(argv[3]), designs);
break;
}
case fleet_plans_parser: {
std::vector<FleetPlan*> fleet_plans;
success = parse::fleet_plans(boost::filesystem::path(argv[3]), fleet_plans);
break;
}
case monster_fleet_plans_parser: {
std::vector<MonsterFleetPlan*> monster_fleet_plans;
success = parse::monster_fleet_plans(boost::filesystem::path(argv[3]), monster_fleet_plans);
break;
}
case alignments_parser: {
std::vector<Alignment> alignments;
std::vector<boost::shared_ptr<const Effect::EffectsGroup> > effects_groups;
success = parse::alignments(boost::filesystem::path(argv[3]), alignments, effects_groups);
break;
}
default:
break;
}
if (success) {
std::cout << "Successful parse." << std::endl;
} else {
std::cout << "Failed parse of \"" << argv[3] << "\"." << std::endl;
++failures;
}
} catch (const boost::spirit::qi::expectation_failure<parse::token_iterator>&) {
std::cout << "Failed parse of \"" << argv[3] << "\" (qi::expectation_failure<> exception)." << std::endl;
++failures;
}
} else {
boost::algorithm::split(strings,
str,
boost::algorithm::is_any_of("\n\r"),
boost::algorithm::token_compress_on);
lexer_test_rules lexer_rules;
boost::spirit::qi::_1_type _1;
boost::spirit::qi::_2_type _2;
boost::spirit::qi::_3_type _3;
boost::spirit::qi::_4_type _4;
switch (test) {
case lexer: boost::spirit::qi::on_error<boost::spirit::qi::fail>(lexer_rules.lexer, parse::report_error(_1, _2, _3, _4)); break;
case double_value_ref_parser: boost::spirit::qi::on_error<boost::spirit::qi::fail>(parse::value_ref_parser<double>(), parse::report_error(_1, _2, _3, _4)); break;
case string_value_ref_parser: boost::spirit::qi::on_error<boost::spirit::qi::fail>(parse::value_ref_parser<std::string>(), parse::report_error(_1, _2, _3, _4)); break;
case planet_size_value_ref_parser: boost::spirit::qi::on_error<boost::spirit::qi::fail>(parse::value_ref_parser<PlanetSize>(), parse::report_error(_1, _2, _3, _4)); break;
case planet_type_value_ref_parser: boost::spirit::qi::on_error<boost::spirit::qi::fail>(parse::value_ref_parser<PlanetType>(), parse::report_error(_1, _2, _3, _4)); break;
case planet_environment_value_ref_parser: boost::spirit::qi::on_error<boost::spirit::qi::fail>(parse::value_ref_parser<PlanetEnvironment>(), parse::report_error(_1, _2, _3, _4)); break;
case star_type_value_ref_parser: boost::spirit::qi::on_error<boost::spirit::qi::fail>(parse::value_ref_parser<StarType>(), parse::report_error(_1, _2, _3, _4)); break;
case condition_parser: boost::spirit::qi::on_error<boost::spirit::qi::fail>(parse::condition_parser(), parse::report_error(_1, _2, _3, _4)); break;
case effect_parser: boost::spirit::qi::on_error<boost::spirit::qi::fail>(parse::effect_parser(), parse::report_error(_1, _2, _3, _4)); break;
default: break;
}
for (std::size_t i = 0; i < strings.size(); ++i) {
const std::string& string = strings[i];
if (string.empty())
continue;
++iterations;
parse::text_iterator first(string.begin());
const parse::text_iterator last(string.end());
bool success = false;
parse::detail::s_text_it = &first;
parse::detail::s_begin = first;
parse::detail::s_end = last;
parse::detail::s_filename = argc == 4 ? argv[3] : "command-line";
parse::token_iterator it = l.begin(first, last);
const parse::token_iterator end_it = l.end();
boost::spirit::qi::in_state_type in_state;
boost::filesystem::path file_parser_path;
if (buildings_parser <= test && test <= alignments_parser) {
file_parser_path = "tmp";
boost::filesystem::ofstream ofs(file_parser_path);
ofs << string;
}
try {
switch (test) {
case lexer: {
success = boost::spirit::qi::phrase_parse(it, end_it, lexer_rules.lexer, in_state("WS")[l.self]);
break;
}
case double_value_ref_parser: {
success = boost::spirit::qi::phrase_parse(it, end_it, parse::value_ref_parser<double>(), in_state("WS")[l.self]);
break;
}
case string_value_ref_parser: {
success = boost::spirit::qi::phrase_parse(it, end_it, parse::value_ref_parser<std::string>(), in_state("WS")[l.self]);
break;
}
case planet_size_value_ref_parser: {
success = boost::spirit::qi::phrase_parse(it, end_it, parse::value_ref_parser<PlanetSize>(), in_state("WS")[l.self]);
break;
}
case planet_type_value_ref_parser: {
success = boost::spirit::qi::phrase_parse(it, end_it, parse::value_ref_parser<PlanetType>(), in_state("WS")[l.self]);
break;
}
case planet_environment_value_ref_parser: {
success = boost::spirit::qi::phrase_parse(it, end_it, parse::value_ref_parser<PlanetEnvironment>(), in_state("WS")[l.self]);
break;
}
case star_type_value_ref_parser: {
success = boost::spirit::qi::phrase_parse(it, end_it, parse::value_ref_parser<StarType>(), in_state("WS")[l.self]);
break;
}
case condition_parser: {
success = boost::spirit::qi::phrase_parse(it, end_it, parse::condition_parser(), in_state("WS")[l.self]);
break;
}
case effect_parser: {
success = boost::spirit::qi::phrase_parse(it, end_it, parse::effect_parser(), in_state("WS")[l.self]);
break;
}
case buildings_parser: {
std::map<std::string, BuildingType*> building_types;
success = parse::buildings(file_parser_path, building_types);
break;
}
case specials_parser: {
std::map<std::string, Special*> specials;
success = parse::specials(file_parser_path, specials);
break;
}
case species_parser: {
std::map<std::string, Species*> species;
success = parse::species(file_parser_path, species);
break;
}
case techs_parser: {
TechManager::TechContainer techs;
std::map<std::string, TechCategory*> tech_categories;
std::set<std::string> categories_seen_in_techs;
success = parse::techs(file_parser_path, techs, tech_categories, categories_seen_in_techs);
break;
}
case items_parser: {
std::vector<ItemSpec> items;
success = parse::items(file_parser_path, items);
break;
}
case ship_parts_parser: {
std::map<std::string, PartType*> parts;
success = parse::ship_parts(file_parser_path, parts);
break;
}
case ship_hulls_parser: {
std::map<std::string, HullType*> hulls;
success = parse::ship_hulls(file_parser_path, hulls);
break;
}
case ship_designs_parser: {
std::map<std::string, ShipDesign*> designs;
success = parse::ship_designs(file_parser_path, designs);
break;
}
case fleet_plans_parser: {
std::vector<FleetPlan*> fleet_plans;
success = parse::fleet_plans(file_parser_path, fleet_plans);
break;
}
case monster_fleet_plans_parser: {
std::vector<MonsterFleetPlan*> monster_fleet_plans;
success = parse::monster_fleet_plans(file_parser_path, monster_fleet_plans);
break;
}
case alignments_parser: {
std::vector<Alignment> alignments;
std::vector<boost::shared_ptr<const Effect::EffectsGroup> > effects_groups;
success = parse::alignments(file_parser_path, alignments, effects_groups);
break;
}
default:
break;
}
if (success && it == end_it) {
if (fail)
std::cout << "Successful parse of \"" << string << "\" (that's bad -- it should fail)." << std::endl;
else
std::cout << "Successful parse." << std::endl;
} else {
if (fail)
std::cout << "Failed parse, as expected." << std::endl;
else
std::cout << "Failed parse of \"" << string << "\"." << std::endl;
++failures;
}
} catch (const boost::spirit::qi::expectation_failure<parse::token_iterator>&) {
std::cout << "Failed parse of \"" << string << "\" (qi::expectation_failure<> exception)." << std::endl;
++failures;
}
}
}
if(test == lexer && !lexer_test_rules::unchecked_tokens.empty())
{
std::cout << "There were unhandled tokens: " << std::endl;
for(std::set<adobe::name_t>::iterator it = lexer_test_rules::unchecked_tokens.begin(); it != lexer_test_rules::unchecked_tokens.end(); ++it)
{
std::cout << *it << std::endl;
++failures;
}
}
if (1u < strings.size()) {
if (fail) {
if (failures != iterations)
std::cout << (strings.size() - failures) << " successful parses total (that's bad -- all should fail)." << std::endl;
else
std::cout << "All parses failed, as expected." << std::endl;
} else {
if (failures)
std::cout << failures << " failures total." << std::endl;
else
std::cout << "All parses successful." << std::endl;
}
}
return fail ? failures != iterations : failures;
}
