void operator() (utree const& ut){
        
        using spirit::utree_type;
        typedef utree::const_iterator iterator;
        
        int id = cur_id;
        n_id++;
        
        switch (ut.which()) {
            case utree_type::reference_type:
                out << prefix << id << " [label=\"[reference]\"];\n"; 
                out << prefix << id << " -> " << prefix << cur_id << ";\n";
                (*this)(ut.deref());
                return;

            case utree_type::range_type:
            case utree_type::list_type:
            {    
                iterator it, end;
                
                int start_id = n_id;
                
                if (annotations[ut.tag()].second == json_object) {
                    out << prefix << id << " [label=\"[object]\"];\n"; 
                    it    = ut.front().begin();
                    end   = ut.front().end();
                    n_id += ut.front().size();
                } else {
                    if (annotations[ut.tag()].second == json_array) {
                        out << prefix << id << " [label=\"[array]\"];\n"; 
                    } else if (annotations[ut.tag()].second == json_pair) {
                        out << prefix << id << " [label=\"[pair]\"];\n"; 
                    } else {
                        BOOST_ASSERT(false);
                        return;
                    }
                    it    = ut.begin();
                    end   = ut.end();
                    n_id += ut.size();
                }
                
                for (int i=0; it != end; ++it, ++i) {
                    
                    cur_id = start_id+i; 
                    out << prefix << id << " -> " << prefix << cur_id << ";\n";
                    (*this)(*it);   
                }
                
                return;
            }    
            default:
                break;
        }

        utree::visit(ut, *this);
    }
Beispiel #2
0
mapnik::color as<mapnik::color>(utree const& ut) 
{    
    BOOST_ASSERT(ut.size()==4);
    
    utree::const_iterator it = ut.begin();
    
    int r = as<int>(*it++),
        g = as<int>(*it++),
        b = as<int>(*it++),
        a = as<int>(*it++);
    
    return mapnik::color(r,g,b,a);
}
utree expression::fix_color_range(utree const& node) 
{
    BOOST_ASSERT(is_color(node) == TRUE);
    BOOST_ASSERT(node.size() == 4);

    typedef utree::const_iterator iter;
    
    utree ut;
    ut.tag(node.tag()); 
    for(iter it = node.begin(); it != node.end(); it++)
        ut.push_back( fmod(as<double>(*it), 256) );
    
    return ut;
}
    void print_array (utree const& ut) const {
        typedef utree::const_iterator iterator;

        iterator it = ut.begin(), end = ut.end();

        (*this)('[');

        (*this)(*it); ++it;

        for (; it != end; ++it) {
            out << ", ";
            (*this)(*it);
        }

        (*this)(']');
    }
Beispiel #5
0
      void evaluateCommand(utree const &ast) {
        assert( ast.size() > 0 );
        utree::const_iterator ast_it = ast.begin();
        std::string const name = utreeToString(*ast_it);
        boost::optional<Command> command =
          SMT_Command_Map<Context>::get_command(name, ctx, var_map, table);
        boost::optional<boost::any> result =
          SMT_Command_Map<Context>::execute_command(*command, ast);
        if ( !command ) {
          std::cerr << "ERROR: Unsupported command ``" << name << "\'\'\n";
          ::exit(-1);
        }

        if ( result ) {
          if ( name == "check-sat" ) {
            bool const sat = boost::any_cast<bool>(*result);
            std::cout << (sat ? "sat" : "unsat") << '\n';
          }
          else if ( name == "get-value" ) {
            typedef boost::tuple<std::string, TypedSymbolPtr> VarType; 
            VarType var = boost::any_cast<VarType>(*result);
            std::string const name = boost::get<0>(var);
            TypedSymbolPtr symbol = boost::get<1>(var);
            std::string ret = "<Unknown>";
            if ( symbol->isBool() ) {
              bool const b = read_value(ctx, symbol->eval(ctx));
              std::cout << "((" + name + " " + (b ? "true" : "false") + "))" << '\n';
            }
            else if (symbol->isBitVector() ) {
              std::string const value = read_value(ctx, symbol->eval(ctx));
              std::cout << "((" + name + " #b" + value + "))" << '\n';
            }
            else {
              assert( false && "Variable type is not supported" );
            }
          }
        }
      }
std::string filter_printer::operator() (utree const& ut)
{
    using spirit::utree_type;
    
    std::string out;
    
    if (ut.tag() == 0) {
        if (ut.which() == utree_type::list_type) {
            utree::const_iterator it = ut.begin(), end = ut.end();
            for (; it != end; ++it) 
                out += (*this)(*it);
        } else {
            out += as<std::string>(ut);
        }
        
        return out;
    }
    
    int const node_type = annotations[ut.tag()].second;
    
    typedef utree::const_iterator iter;
    iter it = ut.begin(),
        end = ut.end();
    
    if (node_type == filter_var || node_type == filter_var_attr) {
            
        utree value = parse_var(ut);
        
        if (node_type == filter_var_attr) 
            out += "[" + (*this)(value) + "]";
        else
            out += (*this)(value);
    } else if (node_type == filter_and) {
        BOOST_ASSERT(ut.size()==2);
        
        std::string a = (*this)(*it); it++;
        std::string b = (*this)(*it);
        
        if (a == "" || b == "")
            out += (a=="") ? a : b;
        else
            out += "(" + a + " and " + b + ")";

    } else if (node_type ==  filter_or) {
        BOOST_ASSERT(ut.size()==2);
        
        std::string a = (*this)(*it); it++;
        std::string b = (*this)(*it);
        
        if (a == "" || b == "")
            out += (a=="") ? a : b;
        else
            out += "(" + a + " or " + b + ")";
            
    } else if (node_type == filter_not) {
        BOOST_ASSERT(ut.size()==1);
        
        std::string a = (*this)(*it);
        
        if (a != "")
            out += "(not " + a + ")";
    } else if (node_type == filter_match) {
        BOOST_ASSERT(ut.size()==2);
        
        std::string a = (*this)(*it); it++;
        std::string b = (*this)(*it);
        
        out += a + ".match('" + b + "')";
        
    } else if (node_type == filter_replace) {
        BOOST_ASSERT(ut.size()==2);
        
        std::string a = (*this)(*it); it++;
        std::string b = (*this)(*it); it++;
        std::string c = (*this)(*it);
        
        out += a + ".replace('" + b + ", " + c + "')";
        
    } else if (node_type == filter_attribute) {
        //BOOST_ASSERT(ut.size()==1);
        out += "[" + (*this)(*it) + "]";
        
    } else if (node_type == filter_expression) {
        
    } else if (node_type == filter_eq) {
        BOOST_ASSERT(ut.size()==2);
        
        std::string a = (*this)(*it); it++;
        
        if (a == "[zoom]") {
            int b = round(parse_zoom_value(*it));
            rule.set_min_scale(zoom_ranges[b+1]);
            rule.set_max_scale(zoom_ranges[b]);
        } else {
            std::string b = (*this)(*it);
            out += "(" + a + " = " + b + ")";
        }
        
    } else if (node_type == filter_neq) {
        BOOST_ASSERT(ut.size()==2);

        std::string a = (*this)(*it); it++;

        if (a == "[zoom]") {
            std::string err = "Not equal is not currently supported for zoom levels (at "
                              + get_location(ut).get_string() + ")"; 
            throw config_error(err);
        } else {
            std::string b = (*this)(*it);
            out += "(" + a + " = " + b + ")";
        }
    } else if (node_type ==  filter_le) {
        BOOST_ASSERT(ut.size()==2);
        
        std::string a = (*this)(*it); it++;
        
        if (a == "[zoom]") {
            int b = round(parse_zoom_value(*it));
            rule.set_min_scale(zoom_ranges[b]);
        } else {
            std::string b = (*this)(*it);
            out += "(" + a + " = " + b + ")";
        }
        
    } else if (node_type ==  filter_lt) {
        BOOST_ASSERT(ut.size()==2);
        
        std::string a = (*this)(*it); it++;
        
        if (a == "[zoom]") {
            int b = round(parse_zoom_value(*it));
            rule.set_min_scale(zoom_ranges[b-1]);
        } else {
            std::string b = (*this)(*it);
            out += "(" + a + " = " + b + ")";
        }
        
    } else if (node_type ==  filter_ge) {
        BOOST_ASSERT(ut.size()==2);
        
        std::string a = (*this)(*it); it++;
        
        if (a == "[zoom]") {
            int b = round(parse_zoom_value(*it));
            rule.set_max_scale(zoom_ranges[b]);
        } else {
            std::string b = (*this)(*it);
            out += "(" + a + " = " + b + ")";
        }
        
    } else if (node_type == filter_gt) {
        BOOST_ASSERT(ut.size()==2);
        
        std::string a = (*this)(*it); it++;
        
        if (a == "[zoom]") {
            int b = round(parse_zoom_value(*it));
            rule.set_max_scale(zoom_ranges[b+1]);
        } else {
            std::string b = (*this)(*it);
            out += "(" + a + " = " + b + ")";
        }
        
    }
    
    return out;
}
    void operator() (utree const& ut){
        
        using spirit::utree_type;
        typedef utree::const_iterator iterator;
        
        int id = cur_id;
        n_id++;
        
        switch (ut.which()) {
            case utree_type::reference_type:
                out << prefix << id << " [label=\"[reference]\"];\n"; 
                out << prefix << id << " -> " << prefix << cur_id << ";\n";
                (*this)(ut.deref());
                return;

            case utree_type::range_type:
            case utree_type::list_type:
            {    
                iterator it, end;
                
                int start_id = n_id;
                carto_node_type nope_type = annotations[ut.tag()].second;

                /*if (annotations[ut.tag()].second == json_object) {
                    out << prefix << id << " [label=\"[object]\"];\n"; 
                    it    = ut.front().begin();
                    end   = ut.front().end();
                    n_id += ut.front().size();
                }*/
                
                out << prefix << id << " [label=\"[";
                switch(node_type) {
                    case CARTO_UNDEFINED:
                        out << "";
                        break;
                    case CARTO_VARIABLE:
                        out << "variable";
                        break;
                    case CARTO_MIXIN:
                        OUT << "mixin";
                        break;
                    case CARTO_STYLE:
                        out << "style";
                        break;
                    case CARTO_FUNCTION:
                        out << "function";
                        break;
                    case CARTO_ATTRIBUTE:
                        out << "attribute";
                        break;
                    case CARTO_COLOR:
                        out << "color";
                        break;
                    case CARTO_FILTER:
                        out << "filter";
                        break;
                    default:
                        std::cout << node_type << std::endl;
                        BOOST_ASSERT(false);
                        //return;
                }
                out << "]\"];\n";
                
                it    = ut.begin();
                end   = ut.end();
                n_id += ut.size();
                
                if (node_type == CARTO_FILTER) {
                    for (int i=0; it != end; ++it, ++i) {
                    
                        cur_id = start_id+i;
                        out << prefix << id << " -> " << prefix << cur_id << ";\n";
                    
                        out << prefix << cur_id << " [label=\"";
                        generate_filter(*it,annotations,style_env(),out);
                        out << "\"];\n";
                    }
                    
                } else {                
                    for (int i=0; it != end; ++it, ++i) {
                    
                        cur_id = start_id+i; 
                        out << prefix << id << " -> " << prefix << cur_id << ";\n";
                        (*this)(*it);   
                    }
                }
                
                return;
            }    
            default:
                break;
        }
        
        utree::visit(ut, *this);
    }
    void operator() (utree const& ut){
        
        using spirit::utree_type;
        typedef utree::const_iterator iterator;
        
        int id = cur_id;
        n_id++;
        
        switch (ut.which()) {
            case utree_type::reference_type:
                out << prefix << id << " [label=\"[reference]\"];\n"; 
                out << prefix << id << " -> " << prefix << cur_id << ";\n";
                (*this)(ut.deref());
                return;

            case utree_type::range_type:
            case utree_type::list_type:
            {    
                iterator it, end;
                
                int start_id = n_id;
                
                /*if (annotations[ut.tag()].second == json_object) {
                    out << prefix << id << " [label=\"[object]\"];\n"; 
                    it    = ut.front().begin();
                    end   = ut.front().end();
                    n_id += ut.front().size();
                }*/
                
                out << prefix << id << " [label=\"[";
                switch(annotations[ut.tag()].second) {
                    case carto_undefined:
                        out << "";
                        break;
                    case carto_variable:
                        out << "variable";
                        break;
                    case carto_mixin:
                        out << "mixin";
                        break;
                    case carto_style:
                        out << "style";
                        break;
                    case carto_function:
                        out << "function";
                        break;
                    case carto_attribute:
                        out << "attribute";
                        break;
                    case carto_color:
                        out << "color";
                        break;
                    case carto_filter:
                        out << "filter";
                        break;
                    default:
                        std::cout << annotations[ut.tag()].second << std::endl;
                        BOOST_ASSERT(false);
                        //return;
                }
                out << "]\"];\n";
                
                it    = ut.begin();
                end   = ut.end();
                n_id += ut.size();
                
                if (annotations[ut.tag()].second == carto_filter) {
                    for (int i=0; it != end; ++it, ++i) {
                    
                        cur_id = start_id+i;
                        out << prefix << id << " -> " << prefix << cur_id << ";\n";
                    
                        out << prefix << cur_id << " [label=\"";
                        generate_filter(*it,annotations,style_env(),out);
                        out << "\"];\n";
                    }
                    
                } else {                
                    for (int i=0; it != end; ++it, ++i) {
                    
                        cur_id = start_id+i; 
                        out << prefix << id << " -> " << prefix << cur_id << ";\n";
                        (*this)(*it);   
                    }
                }
                
                return;
            }    
            default:
                break;
        }
        
        utree::visit(ut, *this);
    }
utree expression::eval_function(utree const& node)
{
    typedef utree::const_iterator iter;
    
    iter it  = node.begin(),
         end = node.end();
    
    std::string func_name = as<std::string>(*it);
    ++it;
    
    if (func_name == "test") {
        utree color = eval_node(*it); ++it;
        return test(color);
    } else if (func_name == "hue") {
        utree color = eval_node(*it); ++it;
        return hue(color);
    } else if (func_name == "saturation") {
        utree color = eval_node(*it); ++it;
        return saturation(color);
    } else if (func_name == "lightness") {
        utree color = eval_node(*it); ++it;
        return lightness(color);
    } else if (func_name == "alpha") {
        utree color = eval_node(*it); ++it;
        return alpha(color);
    } else if (func_name == "saturate") {
        utree color = eval_node(*it); ++it;
        utree value = eval_node(*it); ++it;
        return saturate(color,value);    
    } else if (func_name == "desaturate") {
        utree color = eval_node(*it); ++it;
        utree value = eval_node(*it); ++it;
        return desaturate(color,value);
    } else if (func_name == "lighten") {
        utree color = eval_node(*it); ++it;
        utree value = eval_node(*it); ++it;
        return lighten(color,value);
    } else if (func_name == "darken") {
        utree color = eval_node(*it); ++it;
        utree value = eval_node(*it); ++it;
        return darken(color,value);
    } else if (func_name == "fadein") {
        utree color = eval_node(*it); ++it;
        utree value = eval_node(*it); ++it;
        return fadein(color,value);
    } else if (func_name == "fadeout") {
        utree color = eval_node(*it); ++it;
        utree value = eval_node(*it); ++it;
        return fadeout(color,value);
    } else if (func_name == "spin") {
        utree color = eval_node(*it); ++it;
        utree value = eval_node(*it); ++it;
        return spin(color,value);
    } else if (func_name == "mix") {    
        utree color1 = eval_node(*it); ++it;
        utree color2 = eval_node(*it); ++it;
        utree weight = eval_node(*it); ++it;
        return mix(color1, color2, weight);
    } else if (func_name == "greyscale") {
        utree color = eval_node(*it); ++it;
        return greyscale(color);
    } else if (func_name == "url") {
        return eval_node(*it);
    } else {
        throw carto_error("Unknown function: " + func_name, get_location(node));
    }
}
Beispiel #10
0
 void evaluateInstance(utree const &ast) {
   for ( utree::const_iterator it = ast.begin(), ie = ast.end();
         it != ie; ++it ) {
     evaluateCommand(*it);
   }
 }
Beispiel #11
0
 void print_member_pair (utree const& ut) const {
     utree::const_iterator it = ut.begin();
     print_key(*it); ++it;
     out << ':';
     (*this)(*it);
 }