R operator()(T& t, M, const V& v, R r)
 {
   typedef typename M::first_target first_target;
   typedef typename M::second_target second_target;
   
   typedef typename first_target::serializer_tag first_tag;
   typedef typename second_target::serializer_tag second_tag;
   
   if ( t.get_aspect().template get<first_tag>().check(t, first_target(), v) )
   {
     r = t.get_aspect().template get<first_tag>()(t, first_target(), v, r);
     
     if ( !try_(t) )
       return r;
     
     if ( t.get_aspect().template get<second_tag>().check(t, second_target(), v) )
     {
       if ( !try_(t) )
         return r;
       
       if ( !r )
         return throw_(t, out_of_range(), r);
       
       *(r++)=',';
     }
   }
   
   r = t.get_aspect().template get<second_tag>()(t, second_target(), v, r);
   return r;
 }
void parse(lexer& lexer)
{
 //clear
 
 clear();

 //empty

 if(lexer.is_empty())
  return;

 //string

 if(try_(lexer,&self::extract_string<fake>))
  return;

 //character

 if(try_(lexer,&self::extract_character<fake>))
  return;

 //c comment

 if(try_(lexer,&self::extract_c_comment<fake>))
  return;
  
 //cpp comment

 if(try_(lexer,&self::extract_cpp_comment<fake>))
  return;
  
 //unit
 
 check(try_(lexer,&self::extract_unit<fake>));
}
  R operator()(T& t, R r)
  {
    if (!r)
      return throw_( t, unexpected_end_fragment(), r );

    if (*r!='{') 
      return throw_( t, expected_of("{",  distance(r) ), r );

    r = t.get_aspect().template get<_space_>()(t, ++r);
    
    if ( !try_(t) )
      return r;
    
    for ( ; r && *r!='}'; )
    {
      r = t.get_aspect().template get<_field_>()(t, r);
      
      if ( !try_(t) )
        return r;
      
      r = t.get_aspect().template get<_space_>()(t, r);
      
      if ( !try_(t) )
        return r;
      
      if (!r)
        return throw_( t, unexpected_end_fragment(), r );
      
      if (*r == ',')
      {
        ++r;
        
        r = t.get_aspect().template get<_space_>()(t, r);
        
        if ( !try_(t) )
          return r;
      }
      else if (*r != '}')
        return throw_( t, expected_of("}",  distance(r) ), r );
    }

    if (!r)
      return throw_( t, unexpected_end_fragment(), r );

    return ++r;
  }
Exemple #4
0
int main( int argc, char* argv[] )
{
	try_( tty );
	try_( personality );
	try_( clock );
	try_( getrusage );

	if ( fork() )
	{
		printf( "Attention! This is mom speaking.\n" );
		try_1( getrusage, RUSAGE_CHILDREN );
	} else {
		printf( "Attention! This is child speaking.\n" );
		try_( gettimeofday );
	}

	return 0;
}
void try_(int cul){
	int i;
	for(i=0;i<8;i++)
		if(IS_SAFE(i,cul)){
			SET(i,cul);
			if(cul==7)
				get_result();
			else
				try_(cul+1);
			REMOVE(i,cul);
		}
}
void parse(tokenizer& tokenizer)
{
 //clear
 
 clear();

 //empty
 
 if(tokenizer.is_empty())
  return;

 //escape

 if(try_(tokenizer,&self::extract_escape<fake>))
  return;

 //number

 if(try_(tokenizer,&self::extract_number<fake>))
  return;

 //identifier

 if(try_(tokenizer,&self::extract_identifier<fake>))
  return;  

 //delimiter

 if(try_(tokenizer,&self::extract_delimiter<fake>))
  return;  

 //word

 if(try_(tokenizer,&self::extract_word<fake>))
  return;  
  
 //control

 if(try_(tokenizer,&self::extract_control<fake>))
  return;  

 //blank

 if(try_(tokenizer,&self::extract_blank<fake>))
  return;  
  
 //unit
 
 check(try_(tokenizer,&self::extract_unit<fake>));
}
int main(){
	int n;
	scanf("%d",&n);
	while(n--){
		int i,j;
		for(i=0;i<8;i++)
			for(j=0;j<8;j++)
				scanf("%d",&table[i][j]);
		initial();
		try_(0);
		printf("%5d\n",max);
	}
	return 0;
}
  R operator()(T& t, M, const V& v, R r)
  {
    typedef typename M::target target;
    typedef typename target::serializer_tag serializer_tag;

    if ( !r )
      return throw_(t, out_of_range(), r);

    *(r++)='{';
    
    r = t.get_aspect().template get<serializer_tag>()(t, target(), v, r);

    if ( !try_(t) )
      return r;
    
    if ( !r )
      return throw_(t, out_of_range(), r);
    
    *(r++)='}';
    
    return r;
  }
  std::pair<R, RD> operator()(T& t, R r, RD rd)
  {
    std::pair<R, RD> rr(r, rd);
    if (!rr.first)
      return throw_( t, unexpected_end_fragment(), rr.first, rr.second );
      

    if (*rr.first!='{') 
      return throw_( t, expected_of("{",  distance(rr.first) ), rr.first, rr.second );

    if ( !rr.second )
      return throw_( t, out_of_range( distance(rr.first) ), rr.first, rr.second );
    
    *(rr.second++) = *(rr.first++);
    
    rr = t.get_aspect().template get<_space_>()(t, rr.first, rr.second);
    
    if ( !try_(t) )
      return rr;
    
    for ( ; rr.first && *rr.first!='}'; )
    {
      rr = t.get_aspect().template get<_field_>()(t, rr.first, rr.second);
      
      if ( !try_(t) )
        return rr;
      
      rr = t.get_aspect().template get<_space_>()(t, rr.first, rr.second);
      
      if ( !try_(t) )
        return rr;
      
      if (!rr.first)
        return throw_( t, unexpected_end_fragment(), rr.first, rr.second );
      
      if (*rr.first == ',')
      {
        if ( !rr.second )
          return throw_( t, out_of_range( distance(rr.first) ), rr.first, rr.second );
        
        *(rr.second++) = *(rr.first++);
        
        rr = t.get_aspect().template get<_space_>()(t, rr.first, rr.second);
        
        if ( !try_(t) )
          return rr;
      }
      else if (*rr.first != '}')
        return throw_( t, expected_of("}",  distance(rr.first) ), rr.first, rr.second );
    }

    if (!rr.first)
      return throw_( t, unexpected_end_fragment(), rr.first, rr.second );

    if ( !rr.second )
      return throw_( t, out_of_range( distance(rr.first) ), rr.first, rr.second );

    *(rr.second++) = *(rr.first++);
    
    return rr;
  }