Sophie

Sophie

distrib > Mandriva > 2010.0 > i586 > by-pkgid > 052d79447130ebaf90b2730395954d11 > files > 953

openvrml-doc-0.18.3-1mdv2010.0.i586.rpm

<!doctype html public "-//W3C//DTD HTML 4.01 Transitional//EN"
               "http://www.w3.org/TR/html4/loose.dtd">

<html>
<head>
<title>OpenVRML: pretty_print.cpp</title>
<meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1">
<link rel="icon" href="../vrml-16">
<link rel="start" href="http://openvrml.org/index" title="OpenVRML Home">
<link rel="prev" href="http://openvrml.org/discussion" title="Discussion">
<link rel="contents" href="index" title="Documentation Main Page">
<link rel="index" href="functions" title="OpenVRML Compound Members">
<link rel="appendix" href="conformance" title="Conformance Test Results">
<style type="text/css">
@import url("tabs.css");
@import url("http://openvrml.org/openvrml.css");

table {
  width: 100%;
}

h2 {
  border-bottom-style: solid;
  border-bottom-width: 1px;
}

/*
 * Doxygen as of 1.5.4-20071217 uses the class "navpath" instead of "nav".
 * For now, we'll do both.
 */

div.nav,
div.navpath {
  background-color: transparent;
  text-align: left;
  margin-top: 1em;
  margin-bottom: 1em;
  border-color: black;
  border-left: none;
  border-right: none;
  padding-top: 0.5em;
  padding-bottom: 0.5em;
}

div.nav :link, div.nav :visited,
div.navpath :link, div.navpath :visited {
  border-width: 1px;
  border-style: solid;
  border-color: silver;
  padding: 2px;
}

div.nav :link:hover, div.nav :visited:hover,
div.navpath :link:hover, div.navpath :visited:hover {
  border-style: outset;
  border-color: gray;
}

div.nav :active,
div.navpath :active {
  border-style: inset;
  border-color: gray;
}

.body td {
  background-color: transparent;
}

.el {
  text-decoration: inherit;
  font-weight: inherit
}
.elRef {
  font-weight: inherit
}
.code:link, .code:visited {
  text-decoration: inherit;
  font-weight: inherit;
  color: inherit;
}
.codeRef:link {
  font-weight: normal;
  color: inherit;
}
:visited {
  color: silver;
}
:link:hover {
  color: inherit;
  text-decoration: inherit;
  background-color: transparent;
}

h1 {
  line-height: 1.2em;
}

td.memItemLeft, td.memItemRight,
td.memTemplParams, td.memTemplItemLeft, td.memTemplItemRight,
.memtemplate, .memname td {
  font-family: Consolas, "DejaVu Sans Mono", "Bitstream Vera Sans Mono", "Lucida Console", LucidaTypewriter, monospace;
}

td.memItemLeft, td.memItemRight, td.mdescLeft, td.mdescRight {
  background-color: rgb(95%, 95%, 95%);
  border-color: rgb(65%, 65%, 65%);
  border-width: 1px;
  font-size: smaller;
}

.memItemLeft {
  margin-top: 0.5em;
  border-top-style: solid;
}
.mdescLeft {
  border-bottom-style: solid;
}
.memItemRight {
  border-top-style: solid;
  margin-top: 0.5em;
}
.mdescRight {
  border-bottom-style: solid;
}

.mdescRight {
  font-style: italic;
}

.mdTable {
  background-color: rgb(95%, 95%, 95%);
}

.memproto td code {
  font-family: inherit;
  font-style: italic;
}

td.pass {
  background-color: rgb(50%, 100%, 50%);
}

td.fail {
  background-color: rgb(100%, 50%, 50%);
}

td.invalid {
  background-color: rgb(75%, 75%, 75%);
}

.memitem {
  padding: 0;
}

.memitem table {
  width: auto;
}

.memproto, .memdoc {
  border-width: 1px;
  border-color: rgb(65%, 65%, 65%);
}

.memproto {
  background-color: rgb(90%, 90%, 90%);
  font-weight: inherit;
  font-size: smaller;
  border-top-style: solid;
  border-left-style: solid;
  border-right-style: solid;
  -webkit-border-top-left-radius: 0.6em;
  -webkit-border-top-right-radius: 0.6em;
  -moz-border-radius-topleft: 0.6em;
  -moz-border-radius-topright: 0.6em;
}

.memdoc {
  background-color: rgb(95%, 95%, 95%);
  padding: 2px 5px;
  border-style: solid;
  -webkit-border-bottom-left-radius: 0.6em;
  -webkit-border-bottom-right-radius: 0.6em;
  -moz-border-radius-bottomleft: 0.6em;
  -moz-border-radius-bottomright: 0.6em;
}

.memname {
  font-weight: inherit;
}

div.tabs {
  background-image: url("tab_b-openvrml.png");
}

div.tabs span {
  background-image: url("tab_l-openvrml.png");
}

div.tabs a {
  background-image: url("tab_r-openvrml.png");
  border-bottom: 1px solid #a5a5a5;
}

div.tabs a:link, div.tabs a:visited, div.tabs a:active, div.tabs a:hover {
  color: black;
}

table {
  border-collapse: collapse;
  border-spacing: 0;
}

.note {
  border: 1px solid rgb(65%, 65%, 65%);
  background-color: rgb(95%, 95%, 95%);
  margin-left: 10%;
  margin-right: 10%;
}
</style>
</head>
<body>
<table class="sitenav">
  <tr>
    <th><a href="http://openvrml.org/index" title="Home">Home</a></th>
    <th><a href="http://openvrml.org/download" title="Download">Download</a></th>
    <th><a href="http://openvrml.org/screenshots/index" title="Screen shots">Screen shots</a></th>
    <th><a href="http://openvrml.org/discussion" title="Mailing lists and IRC">Discussion</a></th>
    <th>Documentation</th>
  </tr>
</table>
<div class="body">
<!-- Generated by Doxygen 1.5.8 -->
<div class="navigation" id="top">
  <div class="tabs">
    <ul>
      <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
      <li><a href="pages.html"><span>Related&nbsp;Pages</span></a></li>
      <li><a href="namespaces.html"><span>Namespaces</span></a></li>
      <li><a href="annotated.html"><span>Classes</span></a></li>
      <li><a href="files.html"><span>Files</span></a></li>
      <li><a href="examples.html"><span>Examples</span></a></li>
    </ul>
  </div>
</div>
<div class="contents">
<h1>pretty_print.cpp</h1>A pretty-printer using <code><a class="el" href="structopenvrml_1_1vrml97__grammar.html" title="A Spirit grammar for parsing VRML97.">openvrml::vrml97_grammar</a></code>.<p>
<div class="fragment"><pre class="fragment"><span class="comment">// -*- Mode: C++; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 78 -*-</span>
<span class="comment">//</span>
<span class="comment">// pretty-print</span>
<span class="comment">//</span>
<span class="comment">// Copyright 2007  Braden McDaniel</span>
<span class="comment">//</span>
<span class="comment">// This program is free software; you can redistribute it and/or modify it</span>
<span class="comment">// under the terms of the GNU General Public License as published by the Free</span>
<span class="comment">// Software Foundation; either version 3 of the License, or (at your option)</span>
<span class="comment">// any later version.</span>
<span class="comment">//</span>
<span class="comment">// This program is distributed in the hope that it will be useful, but WITHOUT</span>
<span class="comment">// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or</span>
<span class="comment">// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for</span>
<span class="comment">// more details.</span>
<span class="comment">//</span>
<span class="comment">// You should have received a copy of the GNU General Public License along</span>
<span class="comment">// with this library; if not, see &lt;http://www.gnu.org/licenses/&gt;.</span>
<span class="comment">//</span>

<span class="preprocessor"># ifdef HAVE_CONFIG_H</span>
<span class="preprocessor"></span><span class="preprocessor">#   include &lt;config.h&gt;</span>
<span class="preprocessor"># endif</span>
<span class="preprocessor"></span>
<span class="preprocessor"># include &lt;<a class="code" href="vrml97__grammar_8h.html" title="VRML97 Spirit grammar and associated parsers.">openvrml/vrml97_grammar.h</a>&gt;</span>
<span class="preprocessor"># include &lt;<a class="code" href="browser_8h.html" title="Classes that manage the scene.">openvrml/browser.h</a>&gt;</span>
<span class="preprocessor"># include &lt;fstream&gt;</span>

<span class="keyword">using namespace </span>std;
<span class="keyword">using namespace </span>boost::spirit::classic;
<span class="keyword">using namespace </span>openvrml;

<span class="keyword">class </span>indent;

std::ostream &amp; <a name="a0"></a><a class="code" href="structopenvrml_1_1color.html#47b141bac0a97692fb7a18d11aefc7b2" title="Stream output.">operator&lt;&lt;</a>(std::ostream &amp; out, <span class="keyword">const</span> indent &amp; indent_);

<span class="keyword">class </span>indent {
    <span class="keyword">friend</span> std::ostream &amp; <a name="a1"></a><a class="code" href="namespaceopenvrml.html#2b46a5c244b91b46101a7a557c62fd65" title="Stream output.">operator&lt;&lt;</a>(std::ostream &amp; out, <span class="keyword">const</span> indent &amp; indent_);

    <span class="keyword">const</span> std::string increment_;
    std::vector&lt;std::string&gt; indent_;

<span class="keyword">public</span>:
    <span class="keyword">explicit</span> indent(<span class="keyword">const</span> std::string &amp; increment):
        increment_(increment)
    {}

    indent &amp; operator++()
    {
        this-&gt;indent_.push_back(this-&gt;increment_);
        <span class="keywordflow">return</span> *<span class="keyword">this</span>;
    }

    indent &amp; operator--()
    {
        this-&gt;indent_.pop_back();
        <span class="keywordflow">return</span> *<span class="keyword">this</span>;
    }
};

std::ostream &amp; <a class="code" href="structopenvrml_1_1color.html#47b141bac0a97692fb7a18d11aefc7b2" title="Stream output.">operator&lt;&lt;</a>(std::ostream &amp; out, <span class="keyword">const</span> indent &amp; indent_)
{
    std::copy(indent_.indent_.begin(),
              indent_.indent_.end(),
              std::ostream_iterator&lt;std::string&gt;(out));
    <span class="keywordflow">return</span> out;
}

<span class="keyword">struct </span>actions;

<span class="keyword">template</span> &lt;<span class="keyword">typename</span> MFValueType&gt;
<span class="keyword">struct </span>on_mfvalue {
    <span class="keyword">explicit</span> on_mfvalue(actions &amp; a):
        a(a)
    {}

    <span class="keywordtype">void</span> operator()(<span class="keyword">const</span> std::vector&lt;MFValueType&gt; &amp; val) <span class="keyword">const</span>;

<span class="keyword">private</span>:
    actions &amp; a;
};

<span class="keyword">template</span> &lt;&gt;
<span class="keyword">struct </span>on_mfvalue&lt;std::string&gt; {
    <span class="keyword">explicit</span> on_mfvalue(actions &amp; a):
        a(a)
    {}

    <span class="keywordtype">void</span> operator()(<span class="keyword">const</span> std::vector&lt;std::string&gt; &amp; val) <span class="keyword">const</span>;

<span class="keyword">private</span>:
    actions &amp; a;
};

<span class="keyword">struct </span>actions : openvrml::<a name="_a2"></a><a class="code" href="structopenvrml_1_1null__vrml97__parse__actions.html" title="No-op semantic actions for vrml97_grammar.">null_vrml97_parse_actions</a> {

    <span class="keyword">template</span> &lt;<span class="keyword">typename</span> SFValueType&gt;
    <span class="keyword">struct </span>on_sfvalue {
        <span class="keyword">explicit</span> on_sfvalue(actions &amp; a):
            a(a)
        {}

        <span class="keywordtype">void</span> operator()(<span class="keyword">const</span> SFValueType &amp; val)<span class="keyword"> const</span>
<span class="keyword">        </span>{
            a.out &lt;&lt; <span class="charliteral">' '</span> &lt;&lt; val &lt;&lt; <span class="charliteral">'\n'</span>;
        }

    <span class="keyword">private</span>:
        actions &amp; a;
    };

    std::ostream &amp; out;
    indent indent_;

    <span class="keyword">explicit</span> actions(std::ostream &amp; out):
        out(out),
        indent_(<span class="stringliteral">"  "</span>),
        on_externproto(*this),
        on_proto_start(*this),
        on_proto_interface(*this),
        on_proto_body_start(*this),
        on_proto_finish(*this),
        on_node_start(*this),
        on_node_finish(*this),
        on_script_interface_decl(*this),
        on_route(*this),
        on_use(*this),
        on_is_mapping(*this),
        on_field_start(*this),
        on_sfnode(*this),
        on_sfbool(*this),
        on_sfcolor(*this),
        on_sffloat(*this),
        on_sfimage(*this),
        on_sfint32(*this),
        on_sfrotation(*this),
        on_sfstring(*this),
        on_sftime(*this),
        on_sfvec2f(*this),
        on_sfvec3f(*this),
        on_mfcolor(*this),
        on_mffloat(*this),
        on_mfint32(*this),
        on_mfrotation(*this),
        on_mfstring(*this),
        on_mftime(*this),
        on_mfvec2f(*this),
        on_mfvec3f(*this)
    {}

    <span class="keyword">struct </span>on_externproto_t {
        <span class="keyword">explicit</span> on_externproto_t(actions &amp; a):
            a(a)
        {}

        <span class="keywordtype">void</span> operator()(<span class="keyword">const</span> std::string &amp; node_type_id,
                        <span class="keyword">const</span> <a class="code" href="namespaceopenvrml.html#4c88b862d45625d0cbeb839d4c4e9ec8" title="A group of unique node_interfaces.">node_interface_set</a> &amp; interfaces,
                        <span class="keyword">const</span> std::vector&lt;std::string&gt; &amp; uri_list)<span class="keyword"> const</span>
<span class="keyword">        </span>{
            <span class="keyword">using</span> std::string;
            <span class="keyword">using</span> std::vector;
            a.out &lt;&lt; a.indent_ &lt;&lt; <span class="stringliteral">"EXTERNPROTO "</span> &lt;&lt; node_type_id &lt;&lt; <span class="stringliteral">" [\n"</span>;
            ++a.indent_;
            <span class="keywordflow">for</span> (node_interface_set::const_iterator interface_ =
                     interfaces.begin();
                 interface_ != interfaces.end();
                 ++interface_) {
                a.out &lt;&lt; a.indent_ &lt;&lt; *interface_ &lt;&lt; <span class="charliteral">'\n'</span>;
            }
            --a.indent_;
            a.out &lt;&lt; a.indent_ &lt;&lt; <span class="stringliteral">"] [\n"</span>;
            ++a.indent_;
            <span class="keywordflow">for</span> (vector&lt;string&gt;::const_iterator uri = uri_list.begin();
                 uri != uri_list.end();
                 ++uri) {
                a.out &lt;&lt; a.indent_ &lt;&lt; <span class="charliteral">'"'</span> &lt;&lt; *uri &lt;&lt; <span class="charliteral">'"'</span>;
                <span class="keywordflow">if</span> (uri + 1 != uri_list.end()) {
                    a.out &lt;&lt; <span class="charliteral">','</span>;
                }
                a.out &lt;&lt; <span class="charliteral">'\n'</span>;
            }
            --a.indent_;
            a.out &lt;&lt; a.indent_ &lt;&lt; <span class="stringliteral">"]\n"</span>;
        }

        actions &amp; a;
    } on_externproto;

    <span class="keyword">struct </span>on_proto_start_t {
        <span class="keyword">explicit</span> on_proto_start_t(actions &amp; a):
            a(a)
        {}

        <span class="keywordtype">void</span> operator()(<span class="keyword">const</span> std::string &amp; node_type_id)<span class="keyword"> const</span>
<span class="keyword">        </span>{
            a.out &lt;&lt; <span class="stringliteral">"PROTO "</span> &lt;&lt; node_type_id &lt;&lt; <span class="stringliteral">" [\n"</span>;
            ++a.indent_;
        }

        actions &amp; a;
    } on_proto_start;

    <span class="keyword">struct </span>on_proto_interface_t {
        <span class="keyword">explicit</span> on_proto_interface_t(actions &amp; a):
            a(a)
        {}

        <span class="keywordtype">void</span> operator()(<span class="keyword">const</span> <a name="_a3"></a><a class="code" href="classopenvrml_1_1node__interface.html" title="Type information for an interface of a node.">node_interface</a> &amp; interface_)<span class="keyword"> const</span>
<span class="keyword">        </span>{
            a.out &lt;&lt; a.indent_ &lt;&lt; interface_;
            <span class="keywordflow">if</span> (interface_.<a name="a4"></a><a class="code" href="classopenvrml_1_1node__interface.html#dde78e72b3568da9a63996325f0467ed" title="The interface type.">type</a> == node_interface::eventin_id
                || interface_.<a class="code" href="classopenvrml_1_1node__interface.html#dde78e72b3568da9a63996325f0467ed" title="The interface type.">type</a> == node_interface::eventout_id) {
                a.out &lt;&lt; <span class="charliteral">'\n'</span>;
            }
        }

        actions &amp; a;
    } on_proto_interface;

    <span class="keyword">struct </span>on_proto_body_start_t {
        <span class="keyword">explicit</span> on_proto_body_start_t(actions &amp; a):
            a(a)
        {}

        <span class="keywordtype">void</span> operator()()<span class="keyword"> const</span>
<span class="keyword">        </span>{
            --a.indent_;
            a.out &lt;&lt; a.indent_ &lt;&lt; <span class="stringliteral">"] {\n"</span>;
            ++a.indent_;
        }

        actions &amp; a;
    } on_proto_body_start;

    <span class="keyword">struct </span>on_proto_finish_t {
        <span class="keyword">explicit</span> on_proto_finish_t(actions &amp; a):
            a(a)
        {}

        <span class="keywordtype">void</span> operator()()<span class="keyword"> const</span>
<span class="keyword">        </span>{
            --a.indent_;
            a.out &lt;&lt; a.indent_ &lt;&lt; <span class="stringliteral">"}\n"</span>;
        }

        actions &amp; a;
    } on_proto_finish;

    <span class="keyword">struct </span>on_node_start_t {
        <span class="keyword">explicit</span> on_node_start_t(actions &amp; a):
            a(a)
        {}

        <span class="keywordtype">void</span> operator()(<span class="keyword">const</span> std::string &amp; node_name_id,
                        <span class="keyword">const</span> std::string &amp; node_type_id)<span class="keyword"> const</span>
<span class="keyword">        </span>{
            a.out &lt;&lt; <span class="charliteral">'\n'</span> &lt;&lt; a.indent_;
            <span class="keywordflow">if</span> (!node_name_id.empty()) {
                a.out &lt;&lt; <span class="stringliteral">"DEF "</span> &lt;&lt; node_name_id &lt;&lt; <span class="charliteral">' '</span>;
            }
            a.out &lt;&lt; node_type_id &lt;&lt; <span class="stringliteral">" {\n"</span>;
            ++a.indent_;
        }

        actions &amp; a;
    } on_node_start;

    <span class="keyword">struct </span>on_node_finish_t {
        <span class="keyword">explicit</span> on_node_finish_t(actions &amp; a):
            a(a)
        {}

        <span class="keywordtype">void</span> operator()()<span class="keyword"> const</span>
<span class="keyword">        </span>{
            --a.indent_;
            a.out &lt;&lt; a.indent_ &lt;&lt; <span class="stringliteral">"}\n"</span>;
        }

        actions &amp; a;
    } on_node_finish;

    <span class="keyword">struct </span>on_script_interface_decl_t {
        <span class="keyword">explicit</span> on_script_interface_decl_t(actions &amp; a):
            a(a)
        {}

        <span class="keywordtype">void</span> operator()(<span class="keyword">const</span> <a class="code" href="classopenvrml_1_1node__interface.html" title="Type information for an interface of a node.">node_interface</a> &amp; interface_)<span class="keyword"> const</span>
<span class="keyword">        </span>{
            a.out &lt;&lt; a.indent_ &lt;&lt; interface_;
        }

        actions &amp; a;
    } on_script_interface_decl;

    <span class="keyword">struct </span>on_route_t {
        <span class="keyword">explicit</span> on_route_t(actions &amp; a):
            a(a)
        {}

        <span class="keywordtype">void</span> operator()(<span class="keyword">const</span> std::string &amp; from_node_name_id,
                        <span class="keyword">const</span> <a class="code" href="classopenvrml_1_1node__interface.html" title="Type information for an interface of a node.">node_interface</a> &amp; from_node_interface,
                        <span class="keyword">const</span> std::string &amp; to_node_name_id,
                        <span class="keyword">const</span> <a class="code" href="classopenvrml_1_1node__interface.html" title="Type information for an interface of a node.">node_interface</a> &amp; to_node_interface)<span class="keyword"> const</span>
<span class="keyword">        </span>{
            a.out &lt;&lt; a.indent_ &lt;&lt; <span class="stringliteral">"ROUTE "</span>
                  &lt;&lt; from_node_name_id &lt;&lt; <span class="charliteral">'.'</span> &lt;&lt; from_node_interface.<a name="a5"></a><a class="code" href="classopenvrml_1_1node__interface.html#5ff3c7d82d17d4c20920440fc5b9c043" title="The name of this interface.">id</a>
                  &lt;&lt; <span class="stringliteral">" TO "</span>
                  &lt;&lt; to_node_name_id &lt;&lt; <span class="charliteral">'.'</span> &lt;&lt; to_node_interface.<a class="code" href="classopenvrml_1_1node__interface.html#5ff3c7d82d17d4c20920440fc5b9c043" title="The name of this interface.">id</a> &lt;&lt; <span class="charliteral">'\n'</span>;
        }

        actions &amp; a;
    } on_route;

    <span class="keyword">struct </span>on_use_t {
        <span class="keyword">explicit</span> on_use_t(actions &amp; a):
            a(a)
        {}

        <span class="keywordtype">void</span> operator()(<span class="keyword">const</span> std::string &amp; node_name_id)<span class="keyword"> const</span>
<span class="keyword">        </span>{
            a.out &lt;&lt; <span class="charliteral">'\n'</span> &lt;&lt; a.indent_ &lt;&lt; <span class="stringliteral">"USE"</span> &lt;&lt; node_name_id &lt;&lt; <span class="charliteral">'\n'</span>;
        }

        actions &amp; a;
    } on_use;

    <span class="keyword">struct </span>on_is_mapping_t {
        <span class="keyword">explicit</span> on_is_mapping_t(actions &amp; a):
            a(a)
        {}

        <span class="keywordtype">void</span> operator()(<span class="keyword">const</span> std::string &amp; proto_interface_id)<span class="keyword"> const</span>
<span class="keyword">        </span>{
            a.out &lt;&lt; <span class="stringliteral">" IS "</span> &lt;&lt; proto_interface_id &lt;&lt; <span class="charliteral">'\n'</span>;
        }

        actions &amp; a;
    } on_is_mapping;

    <span class="keyword">struct </span>on_field_start_t {
        <span class="keyword">explicit</span> on_field_start_t(actions &amp; a):
            a(a)
        {}

        <span class="keywordtype">void</span> operator()(<span class="keyword">const</span> std::string &amp; field_name_id,
                        <a class="code" href="classopenvrml_1_1field__value.html#4bc5e65d6aec0ad3cf49f3992025d4ef" title="Used to identify field_value types.">field_value::type_id</a> <span class="comment">/* field_type */</span>)<span class="keyword"> const</span>
<span class="keyword">        </span>{
            a.out &lt;&lt; a.indent_ &lt;&lt; field_name_id;
        }

        actions &amp; a;
    } on_field_start;

    <span class="keyword">struct </span>on_sfnode_t {
        <span class="keyword">explicit</span> on_sfnode_t(actions &amp; a):
            a(a)
        {}

        <span class="keywordtype">void</span> operator()(<span class="keyword">const</span> <span class="keywordtype">bool</span> null)<span class="keyword"> const</span>
<span class="keyword">        </span>{
            <span class="keywordflow">if</span> (null) { a.out &lt;&lt; <span class="stringliteral">" NULL\n"</span>; }
        }

        actions &amp; a;
    } on_sfnode;

    <span class="keyword">struct </span>on_sfbool_t {
        <span class="keyword">explicit</span> on_sfbool_t(actions &amp; a):
            a(a)
        {}

        <span class="keywordtype">void</span> operator()(<span class="keyword">const</span> <span class="keywordtype">bool</span> val)<span class="keyword"> const</span>
<span class="keyword">        </span>{
            a.out &lt;&lt; <span class="charliteral">' '</span> &lt;&lt; (val ? <span class="stringliteral">"TRUE"</span> : <span class="stringliteral">"FALSE"</span>) &lt;&lt; <span class="charliteral">'\n'</span>;
        }

        actions &amp; a;
    } on_sfbool;

    on_sfvalue&lt;color&gt; on_sfcolor;
    on_sfvalue&lt;float&gt; on_sffloat;
    on_sfvalue&lt;image&gt; on_sfimage;
    on_sfvalue&lt;int32&gt; on_sfint32;
    on_sfvalue&lt;rotation&gt; on_sfrotation;
    on_sfvalue&lt;string&gt; on_sfstring;
    on_sfvalue&lt;double&gt; on_sftime;
    on_sfvalue&lt;vec2f&gt; on_sfvec2f;
    on_sfvalue&lt;vec3f&gt; on_sfvec3f;
    on_mfvalue&lt;color&gt; on_mfcolor;
    on_mfvalue&lt;float&gt; on_mffloat;
    on_mfvalue&lt;int32&gt; on_mfint32;
    on_mfvalue&lt;rotation&gt; on_mfrotation;
    on_mfvalue&lt;string&gt; on_mfstring;
    on_mfvalue&lt;double&gt; on_mftime;
    on_mfvalue&lt;vec2f&gt; on_mfvec2f;
    on_mfvalue&lt;vec3f&gt; on_mfvec3f;
};


<span class="keywordtype">int</span> main(<span class="keywordtype">int</span> argc, <span class="keywordtype">char</span> * argv[])
{
    ifstream infile;
    <span class="keywordflow">if</span> (argc &gt; 1) {
        infile.open(argv[1]);
        <span class="keywordflow">if</span> (!infile.is_open()) {
            cerr &lt;&lt; argv[0] &lt;&lt; <span class="stringliteral">": could not open file \""</span> &lt;&lt; argv[1] &lt;&lt; endl;
            <span class="keywordflow">return</span> EXIT_FAILURE;
        }
    }

    istream &amp; in(infile.is_open() ? infile : cin);
    <span class="keyword">const</span> <span class="keywordtype">string</span> filename(infile.is_open() ? argv[1] : <span class="stringliteral">"&lt;stdin&gt;"</span>);

    <span class="keyword">typedef</span> multi_pass&lt;istreambuf_iterator&lt;char&gt; &gt; multi_pass_iterator_t;
    <span class="keyword">typedef</span> istream::char_type char_t;

    multi_pass_iterator_t
        in_begin(make_multi_pass(istreambuf_iterator&lt;char_t&gt;(in))),
        in_end(make_multi_pass(istreambuf_iterator&lt;char_t&gt;()));

    <span class="keyword">typedef</span> position_iterator&lt;multi_pass_iterator_t&gt; iterator_t;

    iterator_t first(in_begin, in_end, filename), last;

    <a name="_a6"></a><a class="code" href="structopenvrml_1_1vrml97__skip__grammar.html" title="A Spirit grammar appropriate for use as a skip parser for VRML97 and VRML-encoded...">vrml97_skip_grammar</a> skip_g;
    actions act(std::cout);
    <a name="_a7"></a><a class="code" href="structopenvrml_1_1vrml97__grammar.html" title="A Spirit grammar for parsing VRML97.">vrml97_grammar&lt;actions&gt;</a> g(act);

    BOOST_SPIRIT_DEBUG_NODE(skip_g);
    BOOST_SPIRIT_DEBUG_NODE(g);

    <span class="keywordflow">if</span> (!parse(first, last, g, skip_g).full) {
        <span class="keywordflow">return</span> EXIT_FAILURE;
    }

    <span class="keywordflow">return</span> EXIT_SUCCESS;
}

<span class="keyword">template</span> &lt;<span class="keyword">typename</span> MFValueType&gt;
<span class="keywordtype">void</span>
on_mfvalue&lt;MFValueType&gt;::operator()(<span class="keyword">const</span> std::vector&lt;MFValueType&gt; &amp; val)<span class="keyword"> const</span>
<span class="keyword"></span>{
    a.out &lt;&lt; <span class="stringliteral">" [\n"</span>;
    ++a.indent_;
    <span class="keywordflow">for</span> (<span class="keyword">typename</span> std::vector&lt;MFValueType&gt;::const_iterator element =
             val.begin();
         element != val.end();
         ++element) {
        a.out &lt;&lt; a.indent_ &lt;&lt; *element &lt;&lt; <span class="stringliteral">",\n"</span>;
    }
    --a.indent_;
    a.out &lt;&lt; a.indent_ &lt;&lt; <span class="stringliteral">"]\n"</span>;
}

<span class="keywordtype">void</span>
on_mfvalue&lt;std::string&gt;::operator()(<span class="keyword">const</span> std::vector&lt;std::string&gt; &amp; val)<span class="keyword"> const</span>
<span class="keyword"></span>{
    a.out &lt;&lt; <span class="stringliteral">" [\n"</span>;
    ++a.indent_;
    <span class="keywordflow">for</span> (std::vector&lt;std::string&gt;::const_iterator element =
             val.begin();
         element != val.end();
         ++element) {
        a.out &lt;&lt; a.indent_ &lt;&lt; <span class="charliteral">'"'</span> &lt;&lt; *element &lt;&lt; <span class="stringliteral">"\",\n"</span>;
    }
    --a.indent_;
    a.out &lt;&lt; a.indent_ &lt;&lt; <span class="stringliteral">"]\n"</span>;
}
</pre></div> </div>
</div>
<address class="footer"><span class="images"><a href="http://web3d.org/x3d/"><img src="x3d-white-on-black.png" width="43" height="32" border="0" alt="X3D"></a><a href="http://opengl.org"><img src="OGL_sm_wht.png" width="68" height="32" border="0" alt="OpenGL"></a><a href="http://sourceforge.net/projects/openvrml"><img src="http://sourceforge.net/sflogo.php?group_id=7151&amp;type=11" width="120" height="30" border="0" alt="SourceForge.net"></a></span><a href="https://sourceforge.net/apps/trac/openvrml/newticket">Report error</a><br>Generated Thu Aug 13 02:49:09 2009 by Doxygen 1.5.8</address>
<script src="http://www.google-analytics.com/urchin.js" type="text/javascript"></script>
<script type="text/javascript">_uacct = "UA-446379-2"; urchinTracker();</script>
<!-- Piwik -->
<script type="text/javascript">
var pkBaseURL = (("https:" == document.location.protocol) ? "https://sourceforge.net/apps/piwik/openvrml/" : "http://sourceforge.net/apps/piwik/openvrml/");
document.write(unescape("%3Cscript src='" + pkBaseURL + "piwik.js' type='text/javascript'%3E%3C/script%3E"));
</script><script type="text/javascript">
piwik_action_name = '';
piwik_idsite = 1;
piwik_url = pkBaseURL + "piwik.php";
piwik_log(piwik_action_name, piwik_idsite, piwik_url);
</script>
<object><noscript><p><img src="http://sourceforge.net/apps/piwik/openvrml/piwik.php?idsite=1" alt="piwik"/></p></noscript></object>
<!-- End Piwik Tag -->
</body>
</html>

Perl :: Catalyst :: PostgreSQL :: RPM Valid HTML 4.01 Transitional