bool parse_dasharray(Iterator first, Iterator last, std::vector<double>& dasharray)
{
using qi::double_;
using qi::phrase_parse;
using qi::_1;
using qi::lit;
using qi::char_;
#if BOOST_VERSION > 104200
using qi::no_skip;
#else
using qi::lexeme;
#endif
using phoenix::push_back;
// SVG
// dasharray ::= (length | percentage) (comma-wsp dasharray)?
// no support for 'percentage' as viewport is unknown at load_map
//
bool r = phrase_parse(first, last,
(double_[push_back(phoenix::ref(dasharray), _1)] %
#if BOOST_VERSION > 104200
no_skip[char_(", ")]
#else
lexeme[char_(", ")]
#endif
| lit("none")),
qi::ascii::space);
if (first != last)
{
return false;
}
return r;
}
int main()
{
int kase,F,T,d[10009],u,i;
sieve(10002);
scanf("%d",&kase);
while(kase--)
{
scanf("%d %d",&F,&T);
bool vis[10009]={0};
q.push(F);
d[F]=0;
vis[F]=1;
while(!q.empty())
{
u=q.front();
q.pop();
for(i=0;i<c;i++)
{
if(!vis[a[i]])
if(check(u,a[i]))
d[a[i]]=d[u]+1,q.push(a[i]),vis[a[i]]=1;
}
}
if(vis[T])
printf("%d\n",d[T]);
else
printf("Impossible\n");
}
return 0;
}
Event_Bool_No_Param ()
: Event_Bool_No_Param::base_type(start)
{
using qi::lit;
start =
lit("STATE_TIMEOUT") | lit("RAMPING_COMPLETED") | lit("PASSIVE_MEAS_COMPLETED")
;
}
bool Compiler::execute() {
using phoenix::ref;
using qi::lit;
using qi::no_skip;
// iterate over stream input
typedef std::istreambuf_iterator<char> base_iterator_type;
base_iterator_type in_begin(m_input);
// convert input iterator to forward iterator, usable by spirit parser
typedef spirit::multi_pass<base_iterator_type> forward_iterator_type;
forward_iterator_type fwd_begin = spirit::make_default_multi_pass(in_begin);
forward_iterator_type fwd_end;
// Initialize global scope
Scope globalScope;
StdLib::Init(globalScope);
// Parsers
ExpParser<forward_iterator_type> exp_;
CmdParser<forward_iterator_type> cmd_(exp_);
CodeParser<forward_iterator_type> code_(exp_);
typedef qi::rule<forward_iterator_type, std::string(), ascii::space_type> StringRule;
typedef qi::rule<forward_iterator_type, ascii::space_type> VoidRule;
StringRule cmdline_ =
lit('[')
> (cmd_(ref(globalScope)) | code_(ref(globalScope)))
> lit(']')
;
VoidRule program_ = +(
cmdline_[ref(m_output) << qi::_1]
> -no_skip[ lit("\n")[ref(m_output) << endl] ]
);
//BOOST_SPIRIT_DEBUG_NODE(cmdline_);
//BOOST_SPIRIT_DEBUG_NODE(program_);
bool r = qi::phrase_parse(
fwd_begin, fwd_end,
program_,
ascii::space
);
if (!r || fwd_begin != fwd_end) {
return false;
}
// Cleanup the global scope :)
m_output << globalScope.bytecode() << endl;
return r;
}
word_count_grammar(TokenDef const&)
: word_count_grammar::base_type(start)
, w(0), c(0), a(0)
{
using boost::phoenix::ref;
using qi::token;
start = *( token(IDWORD) [++ref(w)]
| token(IDCHAR) [++ref(c)]
| token(IDANY) [++ref(a)]
)
;
}
repeat_remove_cmd_parser< Iterator >::repeat_remove_cmd_parser():
repeat_remove_cmd_parser::base_type(start)
{
using qi::lit;
using qi::uint_;
using qi::_val;
using qi::_1;
start =
(lit("remove") | lit("rm") | lit("r")) >>
uint_
[
_val = phx::construct< repeat_remove_cmd >(_1 - phx::val(1u))
]
;
}
int main()
{
namespace spirit = boost::spirit;
namespace qi = spirit::qi;
namespace phoenix = boost::phoenix;
namespace ascii = spirit::ascii;
using qi::rule;
using qi::int_;
using qi::_1;
using qi::_val;
using qi::phrase_parse;
using boost::shared_ptr;
using boost::make_shared;
shared_ptr<int> x = make_shared<int>(123);
std::cout << *x << std::endl;
rule<
std::string::const_iterator
, shared_ptr<int>()
, ascii::space_type
> int_rule_ = int_[_val = new int(_1)];
shared_ptr<int> subject_;
std::string text_ = "12345";
auto result_ = phrase_parse(text_.cbegin(), text_.cend(), int_rule_, ascii::space, subject_);
std::cout << (result_ ? "passed" : "failed") << *subject_ << std::endl;
}
int parse_int_number_main()
{
namespace qi = boost::spirit::qi;
using qi::parse;
using qi::phrase_parse;
using qi::int_;
using qi::double_;
using qi::ascii::space;
using qi::_1;
using boost::phoenix::ref;
using boost::phoenix::push_back;
char * a = "(12e2,12223)";
char * a_end = a+strlen(a) ;
char * b = "(1233)";
char * b_end = b+strlen(b);
char * c = "1 , 2,3,4,5,6,7,8,10,13";
char * c_end = b+strlen(b) ;
int n = 0;
std::vector<int> iv;
phrase_parse(c,c_end, int_%',', space, iv);
std::ostream_iterator <int> oi(std::cout, ",");
boost::copy(iv,oi);
std::cout<<"\n";
return 0;
}
best_cmd_parser< Iterator >::best_cmd_parser():
best_cmd_parser::base_type(start)
{
using qi::lit;
start =
lit("best")[phx::nothing]
;
}
chart_cmd_parser< Iterator >::chart_cmd_parser():
chart_cmd_parser::base_type(start)
{
using qi::lit;
start =
lit("chart")
[phx::nothing]
// >> enum_vals
;
}
void bfs(long start)
{
long i,next,u;
d[start]=0;
vis[start]=1;
q.push(start);
while(!q.empty())
{
u=q.front();
q.pop();
for(i=0;i<gr[u].size();i++)
{
next=gr[u][i];
if(!vis[next])
{
q.push(next);
vis[next]=1;
d[next]=d[u]+1;
}
}
}
}
vista_header_grammer() : vista_header_grammer::base_type ( vista_header ) {
using qi::lit;
using qi::lexeme;
using ascii::char_;
using ascii::string;
using namespace qi::labels;
using phoenix::at_c;
using phoenix::push_back;
start_tag = lit ( "V-data 2 {" );
}
repeat_add_cmd_parser< Iterator >::repeat_add_cmd_parser():
repeat_add_cmd_parser::base_type(start)
{
using qi::lit;
using qi::_val;
start =
lit("add")
[
_val = phx::val(repeat_add_cmd{})
]
;
}
debug_cmd_parser< Iterator >::debug_cmd_parser():
debug_cmd_parser::base_type(start)
{
using qi::lit;
using qi::_val;
start =
lit("dbg")
[
_val = phx::val(debug_cmd{})
]
;
}
bool parse_numbers(Iterator first, Iterator last, std::vector<double>& v)
{
using qi::char_;
using qi::double_;
using qi::phrase_parse;
using qi::_1;
using ascii::space;
const char c = ';';
bool r = phrase_parse(first, last,
// Begin grammar
(
double_ % char_(',')
)
,
// End grammar
space, v);
if (first != last) // fail if we did not get a full match
return false;
return r;
}
tagger(F f_ = F()) : tagger::base_type(start), f(f_)
{
using qi::omit;
using qi::raw;
using qi::eps;
using qi::lit;
using qi::_1;
using qi::_r1;
using qi::_r2;
start = omit[raw[lit(_r2)] [f(_r1, _1)]];
epsilon = omit[raw[eps] [f(_r1, _1)]];
}
long bfs(long start)
{
long i,u,next,count=0;
vis[start]=true;
q.push(start);
while(!q.empty())
{
count++;
u=q.front();
q.pop();
for(i=0; i<gr[u].size(); i++)
{
next=gr[u][i];
if(vis[next]==false)
{
q.push(next);
vis[next]=true;
}
}
}
return count;
}
bool parse_numbers( Iterator first, Iterator last, vector<double> &v )
{
using qi::double_;
using qi::phrase_parse;
using qi::_1;
using ascii::space;
using phoenix::push_back;
bool r( phrase_parse( first, last,
(
double_[ push_back( phoenix::ref( v ), _1 ) ] % ','
),
space ) );
return ( first == last ? r : false );
}
function<Iterator, Lexer>::function(
error_handler<typename Lexer::base_iterator_type, Iterator>& error_handler
, Lexer const& l)
: function::base_type(start), body(error_handler, l)
{
qi::_1_type _1;
qi::_2_type _2;
qi::_3_type _3;
qi::_4_type _4;
qi::_val_type _val;
using qi::on_error;
using qi::on_success;
using qi::fail;
using boost::phoenix::function;
typedef client::error_handler<typename Lexer::base_iterator_type, Iterator>
error_handler_type;
typedef function<error_handler_type> error_handler_function;
typedef function<client::annotation<Iterator> > annotation_function;
identifier = body.expr.identifier;
argument_list = -(identifier % ',');
start = (l.token("void") | l.token("int"))
> identifier
> '(' > argument_list > ')'
> (';' | '{' > body > '}')
;
// Debugging and error handling and reporting support.
BOOST_SPIRIT_DEBUG_NODES(
(identifier)
(argument_list)
(start)
);
// Error handling: on error in start, call error_handler.
on_error<fail>(start,
error_handler_function(error_handler)(
"Error! Expecting ", _4, _3));
// Annotation: on success in start, call annotation.
on_success(identifier,
annotation_function(error_handler.iters)(_val, _1));
}
optional< p_value_test_case >
parse_IC_line( Iterator first, Iterator last )
{
using qi::double_;
using qi::_1;
using qi::uint_;
using qi::phrase_parse;
using ascii::space;
using boost::phoenix::ref;
optional< p_value_test_case > result;
/// Will look like "N=2; IC=1.57184,1.57184,1.57184,1.22985,1.22985,1.57184,1.57184,1.22985"
size_t N;
if( phrase_parse( first, last, "N=" >> uint_ >> "; IC=", space, N ) ) {
result.reset( p_value_test_case( N ) );
if( ! phrase_parse( first, last, double_ % ",", space, result->ICs ) ) {
result = optional< p_value_test_case >(); // reset
}
}
return result;
}
int
main()
{
using spirit_test::test_attr;
namespace qi = boost::spirit::qi;
using qi::attr;
using qi::double_;
{
double d = 0.0;
BOOST_TEST(test_attr("", attr(1.0), d) && d == 1.0);
double d1 = 1.0;
BOOST_TEST(test_attr("", attr(d1), d) && d == 1.0);
std::pair<double, double> p;
BOOST_TEST(test_attr("1.0", double_ >> attr(1.0), p) &&
p.first == 1.0 && p.second == 1.0);
char c = '\0';
BOOST_TEST(test_attr("", attr('a'), c) && c == 'a');
std::string str;
BOOST_TEST(test_attr("", attr("test"), str) && str == "test");
}
{ // testing lazy constructs
using boost::phoenix::val;
using boost::phoenix::ref;
double d = 0.0;
BOOST_TEST(test_attr("", attr(val(1.0)), d) && d == 1.0);
double d1 = 2.0;
BOOST_TEST(test_attr("", attr(ref(d1)), d) && d == 2.0);
}
{
std::string s;
BOOST_TEST(test_attr("s", "s" >> qi::attr(std::string("123")), s) &&
s == "123");
}
return boost::report_errors();
}
bool parse_numbers(Iterator first, Iterator last, std::vector<double>& v)
{
using qi::double_;
using qi::phrase_parse;
using qi::_1;
using ascii::space;
using phoenix::push_back;
using phoenix::ref;
bool r = phrase_parse(first, last,
// Begin grammar
(
double_[push_back(ref(v), _1)] % ','
)
,
// End grammar
space);
if (first != last) // fail if we did not get a full match
return false;
return r;
}
statement<Iterator, Lexer>::statement(
error_handler<typename Lexer::base_iterator_type, Iterator>& error_handler
, Lexer const& l)
: statement::base_type(statement_list), expr(error_handler, l)
{
qi::_1_type _1;
qi::_2_type _2;
qi::_3_type _3;
qi::_4_type _4;
qi::_val_type _val;
qi::tokenid_mask_type tokenid_mask;
using qi::on_error;
using qi::on_success;
using qi::fail;
using boost::phoenix::function;
typedef client::error_handler<typename Lexer::base_iterator_type, Iterator>
error_handler_type;
typedef function<error_handler_type> error_handler_function;
typedef function<client::annotation<Iterator> > annotation_function;
statement_list =
+statement_
;
statement_ =
variable_declaration
| assignment
| compound_statement
| if_statement
| while_statement
| return_statement
| expr
| ';'
;
variable_declaration =
l("int")
> expr.identifier
> -(l("=") > expr)
> ';'
;
assignment =
expr.identifier
> tokenid_mask(token_ids::op_assign)
> expr
> ';'
;
if_statement =
l("if")
> '('
> expr
> ')'
> statement_
>
-(
l("else")
> statement_
)
;
while_statement =
l("while")
> '('
> expr
> ')'
> statement_
;
compound_statement =
'{' >> -statement_list >> '}'
;
return_statement =
l("return")
> -expr
> ';'
;
// Debugging and error handling and reporting support.
BOOST_SPIRIT_DEBUG_NODES(
(statement_list)
(statement_)
(variable_declaration)
(assignment)
(if_statement)
(while_statement)
(compound_statement)
(return_statement)
);
// Error handling: on error in statement_list, call error_handler.
on_error<fail>(statement_list,
error_handler_function(error_handler)(
"Error! Expecting ", _4, _3));
// Annotation: on success in variable_declaration,
// assignment and return_statement, call annotation.
on_success(variable_declaration,
annotation_function(error_handler.iters)(_val, _1));
on_success(assignment,
annotation_function(error_handler.iters)(_val, _1));
on_success(return_statement,
annotation_function(error_handler.iters)(_val, _1));
}
bool solve(qi &l)
{
int t;
si r;
int i=1;
bool found=false;
while(!l.empty())
{
t=l.front();
if(t==i) { found=true; break; }
r.push(t);
l.pop();
}
if(!found) return false;
l.pop();
i+=1;
while(!l.empty() && !r.empty())
{
if(l.front()==i)
l.pop();
else if(r.top()==i)
r.pop();
else
{
found=false;
while(!l.empty())
{
t=l.front();
if(t==i) { found=true; break; }
r.push(t);
l.pop();
}
if(!found) return false;
l.pop();
}
i+=1;
}
return true;
}