ceph/src/boost/libs/wave/doc/class_ref_ctxpolicy_depr.html

   1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
   2 <html>
   3 <head>
   4 <title>The Context Policy</title>
   5 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
   6 <link href="theme/style.css" rel="stylesheet" type="text/css">
   7 </head>
   8
   9 <body>
  10 <table width="100%" border="0" cellspacing="2" background="theme/bkd2.gif">
  11   <tr>
  12     <td width="21"> <h1></h1></td>
  13     <td width="885"> <font face="Verdana, Arial, Helvetica, sans-serif"><b><font size="6">The
  14       Context Policy (depreciated interface) </font></b></font></td>
  15     <td width="96"><a href="http://www.boost.org"><img src="theme/wave.gif" width="93" height="68" align="right" border="0"></a></td>
  16   </tr>
  17 </table>
  18 <br>
  19 <table border="0">
  20   <tr>
  21     <td width="10"></td>
  22     <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
  23     <td width="30"><a href="class_reference_inptpolcy.html"><img src="theme/l_arr.gif" width="20" height="19" border="0"></a></td>
  24     <td width="30"><a href="class_reference_lexer.html"><img src="theme/r_arr.gif" border="0"></a></td>
  25   </tr>
  26 </table>
  27 <blockquote>
  28   <p><a href="class_reference_ctxpolicy.html#introduction">Introduction</a><br>
  29     <a href="class_reference_ctxpolicy.html#header_synopsis">Header 'wave/preprocessing_hooks.hpp'
  30     synopsis</a><br>
  31     <a href="class_reference_ctxpolicy.html#member_functions">Member functions</a></p>
  32 </blockquote>
  33 <h2><b><a name="introduction"></a>Introduction</b></h2>
  34 <p>Please note that the following description relates to a depreciated interface as it was used by default up to Boost V1.34.x. For the new interface please refer to <a href="class_reference_ctxpolicy.html">The Context Policy</a>. You can still force to use this older interface by defining the <tt>BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS</tt> preprocessing constant as outlined in the <a href="compiletime_config.html">Compile
  35 Time Configuration</a> section. By default the new interface is used starting Boost V1.35.0, while the older one is used by default otherwise. </p>
  36 <p>The context policy is used to provide callback hooks, which are called from inside the library into the user code, whenever</p>
  37 <ul>
  38   <li>a preprocessor directive has been recognized, </li>
  39   <li>a token is about to be returned from the preprocessor, </li>
  40   <li>a macro get's defined or undefined, </li>
  41   <li>a macro has been expanded or rescanned,</li>
  42   <li>an include file has been opened or left, </li>
  43   <li>a conditional expression was evaluated,</li>
  44   <li>a token has to be skipped because it is contained in a non-evaluated conditional block, </li>
  45   <li> a pragma of the form <tt>'wave option[(value)]'</tt> has been recognised. </li>
  46 </ul>
  47 <p>This policy type is used as a template parameter to the <a href="class_reference_context.html"><tt>boost::wave::context&lt;&gt;</tt></a>
  48   object, where the default policy provides empty hook functions only.</p>
  49 <h2><a name="header_synopsis"></a>Header <a href="http://svn.boost.org/trac/boost/browser/trunk/boost/wave/preprocessing_hooks.hpp">wave/preprocessing_hooks.hpp</a>
  50   synopsis</h2>
  51 <pre>
  52 <span class="keyword">namespace</span> boost {
  53 <span class="keyword">namespace</span> wave {
  54 <span class="keyword">namespace</span> context_policies {
  55
  56     <span class="keyword">struct</span> default_preprocessing_hooks {
  57
  58         <span class="comment">// general hook functions</span>
  59         <span class="keyword">template</span> &lt;<span class="keyword">typename</span> TokenT&gt;
  60         <span class="keyword">void</span> <a href="class_reference_ctxpolicy.html#found_directive">found_directive</a>(TokenT <span class="keyword">const </span>&amp;directive);<br>
  61         <span class="comment">// test, whether a given token may be skipped</span><br>        <span class="keyword">template</span> &lt;<span class="keyword">typename</span> ContextT&gt;
  62         <span class="keyword">bool</span> <a href="class_reference_ctxpolicy.html#may_skip_whitespace">may_skip_whitespace</a> (ContextT <span class="keyword">const</span>&amp; ctx,
  63             TokenT &amp;token, <span class="keyword">bool</span> &amp;skipped_newline);<br>
  64         </span><span class="comment">// Conditional compilation</span><span class="keyword">
  65         template</span> &lt;<span class="keyword">typename</span> ContainerT&gt;<br>        <span class="keyword">bool</span> <a href="class_reference_ctxpolicy.html#evaluated_conditional_expression">evaluated_conditional_expression</a>(ContainerT <span class="keyword">const</span>&amp; expression, <br>            <span class="keyword">bool</span> expression_value);<br>
  66         <span class="keyword">template</span> &lt;<span class="keyword">typename</span> TokenT&gt;
  67         <span class="keyword">void</span> <a href="class_reference_ctxpolicy.html#skipped_token">skipped_token</a>(TokenT <span class="keyword">const</span></span>&amp; token);<br>
  68         <span class="comment">// macro expansion tracing</span><span class="keyword">
  69         template</span> &lt;<span class="keyword">typename</span> TokenT, <span class="keyword">typename</span> ContainerT&gt;
  70         <span class="keyword">void</span> <a href="class_reference_ctxpolicy.html#expanding_function_like_macro">expanding_function_like_macro</a>(TokenT <span class="keyword">const</span> &amp;macrodef,
  71             <span class="keyword">std::vector</span>&lt;TokenT&gt; <span class="keyword">const</span> &amp;formal_args,
  72             ContainerT <span class="keyword">const</span> &amp;definition, TokenT <span class="keyword">const</span> &amp;macrocall,
  73             <span class="keyword">std::vector</span>&lt;ContainerT&gt; <span class="keyword">const</span> &amp;arguments);
  74
  75         <span class="keyword">template</span> &lt;<span class="keyword">typename</span> TokenT, <span class="keyword">typename</span> ContainerT&gt;
  76         <span class="keyword">void</span> <a href="class_reference_ctxpolicy.html#expanding_object_like_macro">expanding_object_like_macro</a>(TokenT <span class="keyword">const</span> &amp;macro,
  77             ContainerT <span class="keyword">const</span> &amp;definition, TokenT <span class="keyword">const</span> &amp;macrocall);
  78
  79         <span class="keyword">template</span> &lt;<span class="keyword">typename</span> ContainerT&gt;
  80         <span class="keyword">void</span> <a href="class_reference_ctxpolicy.html#expanded_macro">expanded_macro</a>(ContainerT <span class="keyword">const</span> &amp;result);
  81
  82         <span class="keyword">template</span> &lt;<span class="keyword">typename</span> ContainerT&gt;
  83         <span class="keyword">void</span> <a href="class_reference_ctxpolicy.html#expanded_macro">rescanned_macro</a>(ContainerT <span class="keyword">const</span> &amp;result);
  84
  85         <span class="comment">// include file tracing functions</span>
  86         <span class="keyword">void</span> <a href="class_reference_ctxpolicy.html#opened_include_file">found_include_directive</a>(std::string <span class="keyword">const</span> &amp;filename,
  87             <span class="keyword">bool</span> include_next);
  88
  89         <span class="keyword">void </span><a href="class_reference_ctxpolicy.html#opened_include_file">opened_include_file</a>(std::string <span class="keyword">const</span> &amp;relname,
  90             std::string const&amp; absname,
  91             std::size_t include_depth, <span class="keyword">bool</span> is_system_include);
  92
  93         <span class="keyword">void</span> <a href="class_reference_ctxpolicy.html#returning_from_include_file">returning_from_include_file</a>();
  94
  95         <span class="comment">// interpretation of #pragma's of the form </span>
  96         <span class="comment">// 'wave option[(value)]'</span>
  97         <span class="keyword">template</span> &lt;<span class="keyword">typename</span> ContextT, <span class="keyword">typename</span> ContainerT&gt;
  98         bool <a href="class_reference_ctxpolicy.html#interpret_pragma">interpret_pragma</a>(ContextT <span class="keyword">const</span> &amp;ctx, ContainerT &amp;pending,
  99             <span class="keyword">typename</span> ContextT::token_type <span class="keyword">const</span> &amp;option,
 100             ContainerT <span class="keyword">const</span> &amp;values,
 101             <span class="keyword">typename</span> ContextT::token_type <span class="keyword">const</span> &amp;pragma_token);
 102
 103         <span class="comment">// macro definition hooks</span>
 104         <span class="keyword">template</span> &lt;
 105             <span class="keyword">typename</span> TokenT, <span class="keyword">typename</span> ParametersT, <span class="keyword">typename</span> DefinitionT
 106         &gt;
 107         <span class="keyword">void</span> <a href="class_reference_ctxpolicy.html#defined_macro">defined_macro</a>(TokenT <span class="keyword">const</span> &amp;name, <span class="keyword">bool</span> is_functionlike,
 108             ParametersT <span class="keyword">const</span> &amp;parameters, DefinitionT <span class="keyword">const</span> &amp;definition,
 109             <span class="keyword">bool</span> is_predefined);
 110
 111         <span class="keyword">template</span> &lt;<span class="keyword">typename</span> TokenT&gt;
 112         <span class="keyword">void</span> <a href="class_reference_ctxpolicy.html#undefined_macro">undefined_macro</a>(TokenT<span class="keyword">const</span> &amp;name);
 113     };
 114
 115 }}}   <span class="comment">// namespace boost::wave::context_policies</span></pre>
 116 <h2><a name="member_functions"></a>Member functions</h2>
 117 <h3>General hook functions </h3>
 118 <p><a name="found_directive"></a><strong>found_directive</strong></p>
 119 <pre>    <span class="keyword">template</span> &lt;<span class="keyword">typename</span> TokenT&gt;
 120     <span class="keyword">void</span> found_directive(TokenT <span class="keyword">const </span>&amp;directive);
 121 </pre>
 122 <blockquote>
 123   <p>The function <tt>found_directive</tt> is called, whenever the preprocessor has detected one of the preprocessing directives (<span class="preprocessor">#define</span>, <span class="preprocessor">#undef</span>, <span class="preprocessor">#if</span>, <span class="preprocessor">#idef</span>, <span class="preprocessor">#ifndef</span>, <span class="preprocessor">#elif</span>, <span class="preprocessor">#endif</span>, <span class="preprocessor">#error</span>, <span class="preprocessor">#include</span>, <span class="preprocessor">#pragma</span> or <span class="preprocessor">#warning</span>) .</p>
 124   <p>The parameter <tt>directive</tt> refers to the token containing the detected preprocessing directive. </p>
 125 </blockquote>
 126 <p><a name="may_skip_whitespace" id="may_skip"></a><strong>may_skipwhitespace</strong></p>
 127 <pre>    <span class="keyword">template</span> &lt;<span class="keyword">typename</span> ContextT, <span class="keyword">typename</span> TokenT&gt;
 128     <span class="keyword">bool</span> may_skip_whitespace(ContextT <span class="keyword">const</span>&amp; ctx, TokenT &amp;token, <span class="keyword">bool</span>&amp; skipped_newline);
 129 </pre>
 130 <blockquote>
 131   <p>The function <tt>may_skipwhitespace</tt> will be called by the library, whenever a token is about to be returned to the calling application. </p>
 132   <p>The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt> used during instantiation of the preprocessing iterators by the user. Note, this parameter was added for the Wave V1.2.4 release. </p>
 133   <p>The <tt>token</tt> parameter holds a reference to the current token. The policy is free to change this token if needed.</p>
 134   <p>The <tt>skipped_newline</tt> parameter holds a reference to a boolean value which should be set to true by the policy function whenever a newline is going to be skipped. </p>
 135   <p>If the return value is <tt>true</tt>, the given token is skipped and the preprocessing continues to the next token. If the return value is <tt>false</tt>, the given token is returned to the calling application. Caution has to be used, because by returning <span class="keyword">true</span> the policy function is able to force skipping even significant tokens not only whitespace. </p>
 136 </blockquote>
 137 <h3>Conditional compilation hook functions </h3>
 138 <p><a name="evaluated_conditional_expression"></a><strong>evaluated_conditional_expression</strong></p>
 139 <pre><span class="keyword">    template</span> &lt;<span class="keyword">typename</span> ContainerT&gt;<br><span class="keyword">    void</span> evaluated_conditional_expression(
 140         ContainerT <span class="keyword">const</span>&amp; expression, <span class="keyword">bool</span> expression_value);
 141 </pre>
 142 <blockquote>
 143   <p>The function <tt>evaluated_conditional_expression</tt> is called, whenever the preprocessor has encountered a <span class="preprocessor">#if</span>, <span class="preprocessor">#elif</span>, <span class="preprocessor">#ifdef</span> or <span class="preprocessor">#ifndef</span> directive. This hook gets passed the non-expanded conditional expression (as it was given in the analysed source file) and the result of the evaluation of this expression in the current preprocessing context.</p>
 144   <p>The parameter <tt>expression</tt> holds the non-expanded token sequence
 145   comprising the evaluated expression.</p>
 146   <p>The parameter <tt>expression_value</tt> contains the result of the evaluation of
 147     the expression in the current preprocessing context.<br>
 148   </p>
 149 </blockquote>
 150 <p><a name="skipped_token"></a><strong>skipped_token</strong></p>
 151 <pre>    <span class="keyword">template</span> &lt;<span class="keyword">typename</span> TokenT&gt;
 152     <span class="keyword">void</span> skipped_token(TokenT <span class="keyword">const</span>&amp; token);
 153 </pre>
 154 <blockquote>
 155   <p>The function <tt>skipped_token</tt> is called, whenever a token is about to be skipped due to a false preprocessor condition (code fragments to be
 156   skipped inside the not evaluated conditional <span class="preprocessor">#if</span>/<span class="preprocessor">#else</span>/<span class="preprocessor">#endif</span> branches).</p>
 157   <p>The parameter <tt>token</tt> refers to the token to be skipped.</p>
 158 </blockquote>
 159 <h3>Macro expansion tracking functions</h3>
 160 <p><a name="expanding_function_like_macro"></a><b>expanding_function_like_macro</b></p>
 161 <pre><span class="keyword">    template</span> &lt;<span class="keyword">typename</span> TokenT, <span class="keyword">typename</span> ContainerT&gt;
 162     <span class="keyword">void</span> expanding_function_like_macro(TokenT <span class="keyword">const</span> &amp;macrodef,
 163         <span class="keyword">std::vector</span>&lt;TokenT&gt; <span class="keyword">const</span> &amp;formal_args,
 164         ContainerT <span class="keyword">const</span> &amp;definition, TokenT <span class="keyword">const</span> &amp;macrocall,
 165         <span class="keyword">std::vector</span>&lt;ContainerT&gt; <span class="keyword">const</span> &amp;arguments);</pre>
 166 <blockquote>
 167   <p>The function <tt>expanding_function_like_macro</tt> is called, whenever a
 168     function-like macro is to be expanded, i.e. <i>before</i> the actual expansion
 169     starts.</p>
 170   <p>The <tt>macroname</tt> parameter marks the position where the macro to expand
 171     is defined. It contains the token which identifies the macro name used inside
 172     the corresponding macro definition.</p>
 173   <p>The <tt>formal_args</tt> parameter holds the formal arguments used during
 174     the definition of the macro. </p>
 175   <p>The <tt>definition</tt> parameter holds the macro definition for the macro
 176     to trace. This is a standard STL container which holds the token sequence
 177     identified during the macro definition as the macro replacement list.</p>
 178   <p>The <tt>macrocall</tt> parameter marks the position where this macro is invoked.
 179     It contains the token, which identifies the macro call inside the preprocessed
 180     input stream. </p>
 181   <p>The <tt>arguments</tt> parameter holds the macro arguments used during the
 182     invocation of the macro. This is a vector of standard STL containers which
 183     contain the token sequences identified at the position of the macro call as
 184     the arguments to be used during the macro expansion. </p>
 185 </blockquote>
 186 <p><a name="expanding_object_like_macro"></a><b>expanding_object_like_macro</b></p>
 187 <pre>    <span class="keyword">template</span> &lt;<span class="keyword">typename</span> TokenT, <span class="keyword">typename</span> ContainerT&gt;
 188     <span class="keyword">void</span> expanding_object_like_macro(TokenT <span class="keyword">const</span> &amp;macro,
 189         ContainerT <span class="keyword">const</span> &amp;definition, TokenT <span class="keyword">const</span> &amp;macrocall);
 190 </pre>
 191 <blockquote>
 192   <p>The function <tt>expanding_object_like_macro</tt> is called, whenever a object-like
 193     macro is to be expanded, i.e. <i>before</i> the actual expansion starts.</p>
 194   <p>The <tt>macroname</tt> parameter marks the position where the macro to expand
 195     is defined. It contains the token which identifies the macro name used inside
 196     the corresponding macro definition.</p>
 197   <p> The <tt>definition</tt> parameter holds the macro definition for the macro
 198     to trace. This is a standard STL container which holds the token sequence
 199     identified during the macro definition as the macro replacement list.</p>
 200   <p>The <tt>macrocall</tt> parameter marks the position where this macro is invoked.
 201     It contains the token which identifies the macro call inside the preprocessed
 202     input stream. </p>
 203 </blockquote>
 204 <p><a name="expanded_macro"></a><b>expanded_macro</b></p>
 205 <pre>    <span class="keyword">template</span> &lt;<span class="keyword">typename</span> ContainerT&gt;
 206     <span class="keyword">void</span> expanded_macro(ContainerT <span class="keyword">const</span> &amp;result);
 207 </pre>
 208 <blockquote>
 209   <p>The function <tt>expanded_macro</tt> is called whenever the expansion of
 210     a macro is finished, the replacement list is completely scanned and the identified
 211     macros herein are replaced by its corresponding expansion results, but <i>before</i>
 212     the rescanning process starts.</p>
 213   <p>The parameter <tt>result</tt> contains the the result of the macro expansion
 214     so far. This is a standard STL container containing the generated token sequence.</p>
 215 </blockquote>
 216 <p><a name="rescanned_macro"></a><b>rescanned_macro</b></p>
 217 <pre>    <span class="keyword">template</span> &lt;<span class="keyword">typename</span> ContainerT&gt;
 218     <span class="keyword">void</span> rescanned_macro(ContainerT <span class="keyword">const</span> &amp;result);
 219 </pre>
 220 <blockquote>
 221   <p>The function <tt>rescanned_macro</tt> is called whenever the rescanning
 222     of a macro is finished, i.e. the macro expansion is complete.</p>
 223   <p>The parameter <tt>result</tt> contains the the result of the whole macro
 224     expansion. This is a standard STL container containing the generated token
 225     sequence.</p>
 226 </blockquote>
 227 <h3>Include file tracing functions</h3>
 228 <p><a name="opened_include_file" id="found_include_directive"></a><strong>found_include_directive</strong></p>
 229 <pre>    <span class="keyword">void</span> found_include_directive(std::string <span class="keyword">const</span> &amp;filename,
 230         <span class="keyword">bool</span> include_next);
 231 </pre>
 232 <blockquote>
 233   <p>The function <tt>found_include_directive</tt> is called whenever whenever a #include directive was located..</p>
 234   <p>The parameter <tt>filename</tt> contains the (expanded) file name found after
 235     the <span class="preprocessor">#include</span> directive. This has the format <tt>&lt;file&gt;</tt>, <tt>&quot;file&quot;</tt> or
 236     <tt>file</tt>.
 237     The formats <tt>&lt;file&gt;</tt> or <tt>&quot;file&quot;</tt> are used for <span class="preprocessor">#include</span> directives found
 238     in the preprocessed token stream, the format <tt>file</tt> is used for files
 239   specified through the --force_include command line argument.</p>
 240   <p>The parameter <tt>include_next</tt> is set to true if the found directive was
 241     a <span class="preprocessor">#include_next</span> directive and the <tt>BOOST_WAVE_SUPPORT_INCLUDE_NEXT</tt>    preprocessing constant was defined to something != 0.<br>
 242   </p>
 243 </blockquote>
 244 <p><a name="opened_include_file" id="opened_include_file"></a><strong>opened_include_file</strong></p>
 245 <pre>    <span class="keyword">void</span> opened_include_file(std::string <span class="keyword">const</span> &amp;rel_filename,
 246         std::string <span class="keyword">const</span> &amp;abs_filename,
 247         std::size_t include_depth, <span class="keyword">bool</span> is_system_include);
 248 </pre>
 249 <blockquote>
 250   <p>The function <tt>opened_include_file</tt> is called whenever a file referred
 251     by an <span class="preprocessor">#include</span> directive was successfully located and opened.</p>
 252   <p>The parameter <tt>rel_filename</tt> contains the (normalised) probably relative file system path of the opened file. The concrete format of this file name depends on the format of the include search path given to the library beforehand.</p>
 253   <p>The parameter <tt>abs_filename</tt> contains the (normalised) full file system path of the
 254       opened file.</p>
 255   <p>The <tt>include_depth</tt> parameter contains the current include file depth.
 256   </p>
 257   <p>The <tt>is_system_include</tt> parameter denotes, if the given file was found
 258     as a result of a <tt>#include&nbsp;&lt;...&gt;</tt> directive.</p>
 259 </blockquote>
 260 <p><a name="returning_from_include_file" id="returning_from_include_file"></a><strong>returning_from_include_file</strong></p>
 261 <pre>    <span class="keyword">void</span> returning_from_include_file();
 262 </pre>
 263 <blockquote>
 264   <p>The function <tt>returning_from_include_file</tt> is called whenever an
 265     included file is about to be closed after it's processing is complete.</p>
 266 </blockquote>
 267 <h3>Interpretation of #pragma's</h3>
 268 <p><strong><a name="interpret_pragma"></a>interpret_pragma</strong></p>
 269 <pre>    <span class="keyword">template</span> &lt;<span class="keyword">typename</span> ContextT, <span class="keyword">typename</span> ContainerT&gt;
 270     bool <a href="class_reference_ctxpolicy.html#interpret_pragma">interpret_pragma</a>(ContextT <span class="keyword">const</span> &amp;ctx, ContainerT &amp;pending,
 271         <span class="keyword">typename</span> ContextT::token_type <span class="keyword">const</span> &amp;option,
 272         ContainerT <span class="keyword">const</span> &amp;values,
 273         <span class="keyword">typename</span> ContextT::token_type<span class="keyword"> const</span> &amp;pragma_token);
 274 </pre>
 275 <blockquote>
 276   <p>The function <tt>interpret_pragma</tt> is called whenever an unrecognized
 277     <tt>#pragma&nbsp;wave&nbsp;...</tt> or operator <tt>_Pragma(&quot;wave&nbsp;...&quot;)</tt>
 278     is found in the input stream.</p>
 279   <p>The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt> used during instantiation of the preprocessing iterators by the user. </p>
 280   <p>The <tt>pending</tt> parameter may be used to push tokens back into the input
 281     stream which are to be used as the replacement text for the whole <tt>#pragma&nbsp;wave()</tt>
 282     directive. If this sequence is left empty, no replacement takes place, i.e.
 283     the interpreted directive is removed from the generated token stream.</p>
 284   <p>The <tt>option</tt> parameter contains the name of the interpreted pragma.</p>
 285   <p>The <tt>values</tt> parameter holds the value of the parameter provided to
 286     the pragma operator.</p>
 287   <p>The <tt>pragma_token</tt> parameter contains the actual #pragma token which
 288     may be used for extraction of the location information for some error output.</p>
 289   <p>If the return value is 'false', the whole #pragma directive is interpreted
 290     as unknown and a corresponding error message is issued. A return value of
 291     'true' signs a successful interpretation of the given #pragma.<br>
 292   </p>
 293 </blockquote>
 294 <h3>Macro definition </h3>
 295 <p><strong><a name="defined_macro" id="defined_macro"></a>defined_macro</strong></p>
 296 <pre>    <span class="keyword">template</span> &lt;
 297         <span class="keyword">typename</span> TokenT, <span class="keyword">typename</span> ParametersT, <span class="keyword">typename</span> DefinitionT
 298     &gt;
 299     <span class="keyword">void</span> <a href="class_reference_ctxpolicy.html#defined_macro">defined_macro</a>(TokenT <span class="keyword">const</span> &amp;name, <span class="keyword">bool</span> is_functionlike,
 300         ParametersT <span class="keyword">const</span> &amp;parameters, DefinitionT <span class="keyword">const</span> &amp;definition,
 301         <span class="keyword">bool</span> is_predefined);
 302 </pre>
 303 <blockquote>  <p>The function <tt>defined_macro</tt> is called whenever a macro was defined successfully.</p>
 304   <p>The parameter <tt>name</tt> is a reference to the token holding the macro name.</p>
 305   <p>The parameter <tt>is_functionlike</tt> is set to true whenever the newly
 306     defined macro is defined as a function like macro.</p>
 307   <p>The parameter <tt>parameters</tt> holds the parameter tokens for the macro
 308       definition. If the macro has no parameters or if it is a object like
 309   macro, then this container is empty.</p>
 310   <p>The parameter <tt>definition</tt> contains the token sequence given as the
 311   replacement sequence (definition part) of the newly defined macro.</p>
 312   <p>The parameter <tt>is_predefined</tt> is set to true for all macros predefined
 313       during the initialisation pahase of the library.<br>
 314   </p>
 315 </blockquote>
 316 <p><strong><a name="undefined_macro" id="undefined_macro"></a>undefined_macro</strong></p>
 317 <pre>    <span class="keyword">template</span> &lt;<span class="keyword">typename</span> TokenT&gt;
 318     <span class="keyword">void</span> <a href="class_reference_ctxpolicy.html#undefined_macro">undefined_macro</a>(TokenT<span class="keyword">const</span> &amp;name);
 319 </pre>
 320 <blockquote>
 321   <p>The function <tt>undefined_macro</tt> is called whenever a macro definition
 322     was removed successfully.</p>
 323   <p>The parameter <tt>name</tt> holds the token of the macro which definition was removed.<br>
 324   </p>
 325 </blockquote>
 326 <table border="0">
 327   <tr>
 328     <td width="10"></td>
 329     <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
 330     <td width="30"><a href="class_reference_inptpolcy.html"><img src="theme/l_arr.gif" width="20" height="19" border="0"></a></td>
 331     <td width="30"><a href="class_reference_lexer.html"><img src="theme/r_arr.gif" border="0"></a></td>
 332   </tr>
 333 </table>
 334 <hr size="1">
 335 <p class="copyright">Copyright &copy; 2003-2011 Hartmut Kaiser<br>
 336   <br>
 337 <font size="2">Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) </font> </p>
 338 <p class="copyright"><span class="updated">Last updated:
 339   <!-- #BeginDate format:fcAm1m -->Tuesday, May 23, 2006  12:52<!-- #EndDate -->
 340 </span></p>
 341 </body>
 342 </html>