HTML code for sharing source code

HTML Copy To Clipboarddone!

<div class="highlight" style="background: #f8f8f8"><pre style="line-height: 125%"><div id="lc1"><span style="color: #BC7A00">#include&lt;stdio.h&gt;</span>
</div><div id="lc2"><span style="color: #BC7A00">#include&lt;stdlib.h&gt;</span>
</div><div id="lc3"><span style="color: #BC7A00">#include&lt;string.h&gt;</span>
</div><div id="lc4"><span style="color: #BC7A00">#include&lt;math.h&gt;</span>
</div><div id="lc5">
</div><div id="lc6"><span style="color: #008000; font-weight: bold">typedef</span> <span style="color: #008000; font-weight: bold">enum</span> { _none, _plus, _minus, _mul, _dig, _lt, _gt, _pow, _end } Lexem;
</div><div id="lc7">
</div><div id="lc8">Lexem currentLexem;
</div><div id="lc9"><span style="color: #B00040">int</span> currentPos;
</div><div id="lc10"><span style="color: #B00040">char</span> <span style="color: #666666">*</span>expr;
</div><div id="lc11">
</div><div id="lc12"><span style="color: #008000; font-weight: bold">typedef</span> <span style="color: #008000; font-weight: bold">struct</span> pNode
</div><div id="lc13">{
</div><div id="lc14">        <span style="color: #B00040">char</span> sign[<span style="color: #666666">5</span>];
</div><div id="lc15">        Lexem operator;
</div><div id="lc16">        <span style="color: #008000; font-weight: bold">struct</span> pNode<span style="color: #666666">*</span> left;
</div><div id="lc17">        <span style="color: #008000; font-weight: bold">struct</span> pNode<span style="color: #666666">*</span> right;
</div><div id="lc18">} Node;
</div><div id="lc19">
</div><div id="lc20"><span style="color: #B00040">void</span> <span style="color: #0000FF">print_lexem</span>(Lexem l)
</div><div id="lc21">{
</div><div id="lc22">        <span style="color: #008000; font-weight: bold">switch</span>(l)
</div><div id="lc23">        {
</div><div id="lc24">                <span style="color: #008000; font-weight: bold">case</span> _lt: printf(<span style="color: #BA2121">&quot;(&quot;</span>); <span style="color: #008000; font-weight: bold">break</span>;
</div><div id="lc25">                <span style="color: #008000; font-weight: bold">case</span> _gt: printf(<span style="color: #BA2121">&quot;)&quot;</span>); <span style="color: #008000; font-weight: bold">break</span>;
</div><div id="lc26">                <span style="color: #008000; font-weight: bold">case</span> _plus: printf(<span style="color: #BA2121">&quot;+&quot;</span>); <span style="color: #008000; font-weight: bold">break</span>;
</div><div id="lc27">                <span style="color: #008000; font-weight: bold">case</span> _minus: printf(<span style="color: #BA2121">&quot;-&quot;</span>); <span style="color: #008000; font-weight: bold">break</span>;
</div><div id="lc28">                <span style="color: #008000; font-weight: bold">case</span> _mul: printf(<span style="color: #BA2121">&quot;*&quot;</span>); <span style="color: #008000; font-weight: bold">break</span>;
</div><div id="lc29">                <span style="color: #008000; font-weight: bold">case</span> _pow: printf(<span style="color: #BA2121">&quot;^&quot;</span>); <span style="color: #008000; font-weight: bold">break</span>;
</div><div id="lc30">                <span style="color: #008000; font-weight: bold">case</span> _end: printf(<span style="color: #BA2121">&quot;</span><span style="color: #BB6622; font-weight: bold">\n</span><span style="color: #BA2121">&quot;</span>); <span style="color: #008000; font-weight: bold">break</span>;
</div><div id="lc31">        }
</div><div id="lc32">}
</div><div id="lc33">
</div><div id="lc34">Node<span style="color: #666666">*</span> expression();
</div><div id="lc35">Node<span style="color: #666666">*</span> sum();
</div><div id="lc36">Node<span style="color: #666666">*</span> mul_pow();
</div><div id="lc37">Node<span style="color: #666666">*</span> mul();
</div><div id="lc38">
</div><div id="lc39"><span style="color: #B00040">void</span> <span style="color: #0000FF">next_lexem</span>()
</div><div id="lc40">{
</div><div id="lc41">        currentPos<span style="color: #666666">++</span>;
</div><div id="lc42">        <span style="color: #008000; font-weight: bold">switch</span>(expr[currentPos])
</div><div id="lc43">        {
</div><div id="lc44">                <span style="color: #008000; font-weight: bold">case</span> <span style="color: #BA2121">&#39;(&#39;</span>: currentLexem <span style="color: #666666">=</span> _lt; <span style="color: #008000; font-weight: bold">break</span>;
</div><div id="lc45">                <span style="color: #008000; font-weight: bold">case</span> <span style="color: #BA2121">&#39;)&#39;</span>: currentLexem <span style="color: #666666">=</span> _gt; <span style="color: #008000; font-weight: bold">break</span>;
</div><div id="lc46">                <span style="color: #008000; font-weight: bold">case</span> <span style="color: #BA2121">&#39;+&#39;</span>: currentLexem <span style="color: #666666">=</span> _plus; <span style="color: #008000; font-weight: bold">break</span>;
</div><div id="lc47">                <span style="color: #008000; font-weight: bold">case</span> <span style="color: #BA2121">&#39;-&#39;</span>: currentLexem <span style="color: #666666">=</span> _minus; <span style="color: #008000; font-weight: bold">break</span>;
</div><div id="lc48">                <span style="color: #008000; font-weight: bold">case</span> <span style="color: #BA2121">&#39;*&#39;</span>: currentLexem <span style="color: #666666">=</span> _mul; <span style="color: #008000; font-weight: bold">break</span>;
</div><div id="lc49">                <span style="color: #008000; font-weight: bold">case</span> <span style="color: #BA2121">&#39;^&#39;</span>: currentLexem <span style="color: #666666">=</span> _pow; <span style="color: #008000; font-weight: bold">break</span>;
</div><div id="lc50">                <span style="color: #008000; font-weight: bold">case</span> <span style="color: #BA2121">&#39;\0&#39;</span>: currentLexem <span style="color: #666666">=</span> _end; <span style="color: #008000; font-weight: bold">break</span>;
</div><div id="lc51">                <span style="color: #A0A000">default:</span> currentLexem <span style="color: #666666">=</span> _dig; <span style="color: #008000; font-weight: bold">break</span>;
</div><div id="lc52">        }
</div><div id="lc53">}
</div><div id="lc54">
</div><div id="lc55">
</div><div id="lc56">Node<span style="color: #666666">*</span> <span style="color: #0000FF">expression</span>()
</div><div id="lc57">{
</div><div id="lc58">        Node<span style="color: #666666">*</span> child <span style="color: #666666">=</span> sum();
</div><div id="lc59">        Node<span style="color: #666666">*</span> res;
</div><div id="lc60">        <span style="color: #008000; font-weight: bold">if</span>(currentLexem <span style="color: #666666">==</span> _plus <span style="color: #666666">||</span> currentLexem <span style="color: #666666">==</span> _minus)
</div><div id="lc61">        {
</div><div id="lc62">                res <span style="color: #666666">=</span> malloc(<span style="color: #008000; font-weight: bold">sizeof</span>(Node));
</div><div id="lc63">                res<span style="color: #666666">-&gt;</span>left <span style="color: #666666">=</span> child;
</div><div id="lc64">                res<span style="color: #666666">-&gt;</span>operator <span style="color: #666666">=</span> currentLexem;
</div><div id="lc65">                next_lexem();
</div><div id="lc66">                res<span style="color: #666666">-&gt;</span>right <span style="color: #666666">=</span> expression();
</div><div id="lc67">        }
</div><div id="lc68">        <span style="color: #008000; font-weight: bold">else</span>
</div><div id="lc69">        {
</div><div id="lc70">                res <span style="color: #666666">=</span> child;
</div><div id="lc71">        }
</div><div id="lc72">        <span style="color: #008000; font-weight: bold">return</span> res;
</div><div id="lc73">}
</div><div id="lc74">
</div><div id="lc75">Node<span style="color: #666666">*</span> <span style="color: #0000FF">sum</span>()
</div><div id="lc76">{
</div><div id="lc77">        Node<span style="color: #666666">*</span> child <span style="color: #666666">=</span> mul_pow();
</div><div id="lc78">        Node<span style="color: #666666">*</span> res;
</div><div id="lc79">        <span style="color: #008000; font-weight: bold">if</span>(currentLexem <span style="color: #666666">==</span> _mul)
</div><div id="lc80">        {
</div><div id="lc81">                res <span style="color: #666666">=</span> malloc(<span style="color: #008000; font-weight: bold">sizeof</span>(Node));
</div><div id="lc82">                res<span style="color: #666666">-&gt;</span>left <span style="color: #666666">=</span> child;
</div><div id="lc83">                res<span style="color: #666666">-&gt;</span>operator <span style="color: #666666">=</span> currentLexem;
</div><div id="lc84">                next_lexem();
</div><div id="lc85">                res<span style="color: #666666">-&gt;</span>right <span style="color: #666666">=</span> sum();
</div><div id="lc86">        }
</div><div id="lc87">        <span style="color: #008000; font-weight: bold">else</span>
</div><div id="lc88">        {
</div><div id="lc89">                res <span style="color: #666666">=</span> child;
</div><div id="lc90">        }
</div><div id="lc91">        <span style="color: #008000; font-weight: bold">return</span> res;
</div><div id="lc92">}
</div><div id="lc93">
</div><div id="lc94">Node<span style="color: #666666">*</span> <span style="color: #0000FF">mul_pow</span>()
</div><div id="lc95">{
</div><div id="lc96">        Node<span style="color: #666666">*</span> child <span style="color: #666666">=</span> mul();
</div><div id="lc97">        Node<span style="color: #666666">*</span> res;
</div><div id="lc98">        <span style="color: #008000; font-weight: bold">if</span>(currentLexem <span style="color: #666666">==</span> _pow)
</div><div id="lc99">        {
</div><div id="lc100">                res <span style="color: #666666">=</span> malloc(<span style="color: #008000; font-weight: bold">sizeof</span>(Node));
</div><div id="lc101">                res<span style="color: #666666">-&gt;</span>left <span style="color: #666666">=</span> child;
</div><div id="lc102">                res<span style="color: #666666">-&gt;</span>operator <span style="color: #666666">=</span> currentLexem;
</div><div id="lc103">                next_lexem();
</div><div id="lc104">                res<span style="color: #666666">-&gt;</span>right <span style="color: #666666">=</span> mul();
</div><div id="lc105">        }
</div><div id="lc106">        <span style="color: #008000; font-weight: bold">else</span>
</div><div id="lc107">        {
</div><div id="lc108">                res <span style="color: #666666">=</span> child;
</div><div id="lc109">        }
</div><div id="lc110">        <span style="color: #008000; font-weight: bold">return</span> res;
</div><div id="lc111">}
</div><div id="lc112">
</div><div id="lc113">Node<span style="color: #666666">*</span> <span style="color: #0000FF">mul</span>()
</div><div id="lc114">{
</div><div id="lc115">        Node<span style="color: #666666">*</span> res;
</div><div id="lc116">        <span style="color: #008000; font-weight: bold">if</span>(currentLexem <span style="color: #666666">==</span> _lt)
</div><div id="lc117">        {
</div><div id="lc118">                next_lexem();
</div><div id="lc119">                res <span style="color: #666666">=</span> expression();
</div><div id="lc120">                next_lexem();
</div><div id="lc121">        }
</div><div id="lc122">        <span style="color: #008000; font-weight: bold">else</span>
</div><div id="lc123">        {
</div><div id="lc124">                <span style="color: #008000; font-weight: bold">if</span>(currentLexem <span style="color: #666666">==</span> _dig)
</div><div id="lc125">                {
</div><div id="lc126">                        res <span style="color: #666666">=</span> malloc(<span style="color: #008000; font-weight: bold">sizeof</span>(Node));
</div><div id="lc127">                        res<span style="color: #666666">-&gt;</span>operator <span style="color: #666666">=</span> currentLexem;
</div><div id="lc128">                        <span style="color: #B00040">int</span> i <span style="color: #666666">=</span> <span style="color: #666666">0</span>;
</div><div id="lc129">                        <span style="color: #008000; font-weight: bold">while</span>(currentLexem <span style="color: #666666">==</span> _dig)
</div><div id="lc130">                        {
</div><div id="lc131">                                res<span style="color: #666666">-&gt;</span>sign[i<span style="color: #666666">++</span>] <span style="color: #666666">=</span> expr[currentPos];
</div><div id="lc132">                                next_lexem();
</div><div id="lc133">                        }
</div><div id="lc134">                        res<span style="color: #666666">-&gt;</span>sign[i] <span style="color: #666666">=</span> <span style="color: #BA2121">&#39;\0&#39;</span>;
</div><div id="lc135">                }
</div><div id="lc136">        }
</div><div id="lc137">        <span style="color: #008000; font-weight: bold">return</span> res;
</div><div id="lc138">}
</div><div id="lc139">
</div><div id="lc140"><span style="color: #B00040">void</span> <span style="color: #0000FF">parse_tree</span>(Node <span style="color: #666666">*</span>n)
</div><div id="lc141">{
</div><div id="lc142">        <span style="color: #008000; font-weight: bold">if</span>(n<span style="color: #666666">-&gt;</span>operator <span style="color: #666666">==</span> _pow <span style="color: #666666">&amp;&amp;</span>
</div><div id="lc143">                n<span style="color: #666666">-&gt;</span>left<span style="color: #666666">-&gt;</span>operator <span style="color: #666666">==</span> _minus <span style="color: #666666">&amp;&amp;</span>
</div><div id="lc144">                n<span style="color: #666666">-&gt;</span>right<span style="color: #666666">-&gt;</span>operator <span style="color: #666666">==</span> _dig <span style="color: #666666">&amp;&amp;</span>
</div><div id="lc145">                <span style="color: #666666">!</span>strcmp(n<span style="color: #666666">-&gt;</span>right<span style="color: #666666">-&gt;</span>sign,<span style="color: #BA2121">&quot;2&quot;</span>))
</div><div id="lc146">        {
</div><div id="lc147">                Node <span style="color: #666666">*</span>n1 <span style="color: #666666">=</span> malloc(<span style="color: #008000; font-weight: bold">sizeof</span>(Node));
</div><div id="lc148">                Node <span style="color: #666666">*</span>n2 <span style="color: #666666">=</span> malloc(<span style="color: #008000; font-weight: bold">sizeof</span>(Node));
</div><div id="lc149">                Node <span style="color: #666666">*</span>n3 <span style="color: #666666">=</span> malloc(<span style="color: #008000; font-weight: bold">sizeof</span>(Node));
</div><div id="lc150">                Node <span style="color: #666666">*</span>n4 <span style="color: #666666">=</span> malloc(<span style="color: #008000; font-weight: bold">sizeof</span>(Node));
</div><div id="lc151">                Node <span style="color: #666666">*</span>n5 <span style="color: #666666">=</span> malloc(<span style="color: #008000; font-weight: bold">sizeof</span>(Node));
</div><div id="lc152">                Node <span style="color: #666666">*</span>n6 <span style="color: #666666">=</span> malloc(<span style="color: #008000; font-weight: bold">sizeof</span>(Node));
</div><div id="lc153">
</div><div id="lc154">                Node <span style="color: #666666">*</span>a <span style="color: #666666">=</span> n<span style="color: #666666">-&gt;</span>left<span style="color: #666666">-&gt;</span>left;
</div><div id="lc155">                Node <span style="color: #666666">*</span>b <span style="color: #666666">=</span> n<span style="color: #666666">-&gt;</span>left<span style="color: #666666">-&gt;</span>right;
</div><div id="lc156">
</div><div id="lc157">                n1<span style="color: #666666">-&gt;</span>sign[<span style="color: #666666">0</span>] <span style="color: #666666">=</span> <span style="color: #BA2121">&#39;2&#39;</span>; n1<span style="color: #666666">-&gt;</span>sign[<span style="color: #666666">1</span>] <span style="color: #666666">=</span>  <span style="color: #BA2121">&#39;\0&#39;</span>; n1<span style="color: #666666">-&gt;</span>operator <span style="color: #666666">=</span> _dig;
</div><div id="lc158">                n2<span style="color: #666666">-&gt;</span>left <span style="color: #666666">=</span> a; n2<span style="color: #666666">-&gt;</span>right <span style="color: #666666">=</span> n1; n2<span style="color: #666666">-&gt;</span>operator <span style="color: #666666">=</span> _pow;
</div><div id="lc159">                n3<span style="color: #666666">-&gt;</span>left <span style="color: #666666">=</span> n1; n3<span style="color: #666666">-&gt;</span>right <span style="color: #666666">=</span> a; n3<span style="color: #666666">-&gt;</span>operator <span style="color: #666666">=</span> _mul;
</div><div id="lc160">                n4<span style="color: #666666">-&gt;</span>left <span style="color: #666666">=</span> n3; n4<span style="color: #666666">-&gt;</span>right <span style="color: #666666">=</span> b; n4<span style="color: #666666">-&gt;</span>operator <span style="color: #666666">=</span> _mul;
</div><div id="lc161">                n5<span style="color: #666666">-&gt;</span>left <span style="color: #666666">=</span> n2; n5<span style="color: #666666">-&gt;</span>right <span style="color: #666666">=</span> n4; n5<span style="color: #666666">-&gt;</span>operator <span style="color: #666666">=</span> _minus;
</div><div id="lc162">                n6<span style="color: #666666">-&gt;</span>left <span style="color: #666666">=</span> b; n6<span style="color: #666666">-&gt;</span>right <span style="color: #666666">=</span> n1; n6<span style="color: #666666">-&gt;</span>operator <span style="color: #666666">=</span> _pow;
</div><div id="lc163">                n<span style="color: #666666">-&gt;</span>left <span style="color: #666666">=</span> n5; n<span style="color: #666666">-&gt;</span>right <span style="color: #666666">=</span> n6; n<span style="color: #666666">-&gt;</span>operator <span style="color: #666666">=</span> _plus;
</div><div id="lc164">        }
</div><div id="lc165">        <span style="color: #008000; font-weight: bold">if</span>(n<span style="color: #666666">-&gt;</span>operator <span style="color: #666666">!=</span> _dig)
</div><div id="lc166">        {
</div><div id="lc167">                parse_tree(n<span style="color: #666666">-&gt;</span>left);
</div><div id="lc168">                parse_tree(n<span style="color: #666666">-&gt;</span>right);
</div><div id="lc169">        }
</div><div id="lc170">}
</div><div id="lc171">
</div><div id="lc172"><span style="color: #B00040">void</span> <span style="color: #0000FF">print_tree</span>(Node <span style="color: #666666">*</span>n)
</div><div id="lc173">{
</div><div id="lc174">        <span style="color: #008000; font-weight: bold">if</span>(n<span style="color: #666666">-&gt;</span>operator <span style="color: #666666">==</span> _dig)
</div><div id="lc175">        {
</div><div id="lc176">                printf(<span style="color: #BA2121">&quot;%s&quot;</span>, n<span style="color: #666666">-&gt;</span>sign);
</div><div id="lc177">        }
</div><div id="lc178">        <span style="color: #008000; font-weight: bold">else</span>
</div><div id="lc179">        {
</div><div id="lc180">                <span style="color: #008000; font-weight: bold">if</span>(n<span style="color: #666666">-&gt;</span>left<span style="color: #666666">-&gt;</span>operator <span style="color: #666666">!=</span> _dig) print_lexem(_lt);
</div><div id="lc181">                print_tree(n<span style="color: #666666">-&gt;</span>left);
</div><div id="lc182">                <span style="color: #008000; font-weight: bold">if</span>(n<span style="color: #666666">-&gt;</span>left<span style="color: #666666">-&gt;</span>operator <span style="color: #666666">!=</span> _dig) print_lexem(_gt);
</div><div id="lc183">                print_lexem(n<span style="color: #666666">-&gt;</span>operator);
</div><div id="lc184">                <span style="color: #008000; font-weight: bold">if</span>(n<span style="color: #666666">-&gt;</span>right<span style="color: #666666">-&gt;</span>operator <span style="color: #666666">!=</span> _dig) print_lexem(_lt);
</div><div id="lc185">                print_tree(n<span style="color: #666666">-&gt;</span>right);
</div><div id="lc186">                <span style="color: #008000; font-weight: bold">if</span>(n<span style="color: #666666">-&gt;</span>right<span style="color: #666666">-&gt;</span>operator <span style="color: #666666">!=</span> _dig) print_lexem(_gt);
</div><div id="lc187">        }
</div><div id="lc188">}
</div><div id="lc189">
</div><div id="lc190"><span style="color: #B00040">int</span> <span style="color: #0000FF">main</span>()
</div><div id="lc191">{
</div><div id="lc192">        expr <span style="color: #666666">=</span> <span style="color: #BA2121">&quot;2&quot;</span>;
</div><div id="lc193">        currentPos <span style="color: #666666">=</span> <span style="color: #666666">-1</span>;
</div><div id="lc194">        next_lexem();
</div><div id="lc195">        Node <span style="color: #666666">*</span>root, <span style="color: #666666">*</span>new_root;
</div><div id="lc196">        root <span style="color: #666666">=</span> expression();
</div><div id="lc197">        parse_tree(root);
</div><div id="lc198">        print_tree(root);
</div><div id="lc199">        printf(<span style="color: #BA2121">&quot;</span><span style="color: #BB6622; font-weight: bold">\n</span><span style="color: #BA2121">&quot;</span>);
</div><div id="lc200">        <span style="color: #008000; font-weight: bold">return</span> <span style="color: #666666">0</span>;
</div><div id="lc201">}
</div></pre></div>
<p style="padding: 0; margin: 2em 0 1em 0; font-size: 0.8em; color: #666;"><span style="padding: 0 1em; background-color: #f5f5f5;"> Colored with <a style="color: #333" href="http://dumpz.org">dumpz.org</a></span></p>

BBCODE Copy To Clipboarddone!

[color=#BC7A00]#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
[/color]
[color=#008000][b]typedef[/b][/color] [color=#008000][b]enum[/b][/color] { _none, _plus, _minus, _mul, _dig, _lt, _gt, _pow, _end } Lexem;

Lexem currentLexem;
[color=#B00040]int[/color] currentPos;
[color=#B00040]char[/color] [color=#666666]*[/color]expr;

[color=#008000][b]typedef[/b][/color] [color=#008000][b]struct[/b][/color] pNode
{
        [color=#B00040]char[/color] sign[[color=#666666]5[/color]];
        Lexem operator;
        [color=#008000][b]struct[/b][/color] pNode[color=#666666]*[/color] left;
        [color=#008000][b]struct[/b][/color] pNode[color=#666666]*[/color] right;
} Node;

[color=#B00040]void[/color] [color=#0000FF]print_lexem[/color](Lexem l)
{
        [color=#008000][b]switch[/b][/color](l)
        {
                [color=#008000][b]case[/b][/color] _lt: printf([color=#BA2121]"("[/color]); [color=#008000][b]break[/b][/color];
                [color=#008000][b]case[/b][/color] _gt: printf([color=#BA2121]")"[/color]); [color=#008000][b]break[/b][/color];
                [color=#008000][b]case[/b][/color] _plus: printf([color=#BA2121]"+"[/color]); [color=#008000][b]break[/b][/color];
                [color=#008000][b]case[/b][/color] _minus: printf([color=#BA2121]"-"[/color]); [color=#008000][b]break[/b][/color];
                [color=#008000][b]case[/b][/color] _mul: printf([color=#BA2121]"*"[/color]); [color=#008000][b]break[/b][/color];
                [color=#008000][b]case[/b][/color] _pow: printf([color=#BA2121]"^"[/color]); [color=#008000][b]break[/b][/color];
                [color=#008000][b]case[/b][/color] _end: printf([color=#BA2121]"[/color][color=#BB6622][b]\n[/b][/color][color=#BA2121]"[/color]); [color=#008000][b]break[/b][/color];
        }
}

Node[color=#666666]*[/color] expression();
Node[color=#666666]*[/color] sum();
Node[color=#666666]*[/color] mul_pow();
Node[color=#666666]*[/color] mul();

[color=#B00040]void[/color] [color=#0000FF]next_lexem[/color]()
{
        currentPos[color=#666666]++[/color];
        [color=#008000][b]switch[/b][/color](expr[currentPos])
        {
                [color=#008000][b]case[/b][/color] [color=#BA2121]'('[/color]: currentLexem [color=#666666]=[/color] _lt; [color=#008000][b]break[/b][/color];
                [color=#008000][b]case[/b][/color] [color=#BA2121]')'[/color]: currentLexem [color=#666666]=[/color] _gt; [color=#008000][b]break[/b][/color];
                [color=#008000][b]case[/b][/color] [color=#BA2121]'+'[/color]: currentLexem [color=#666666]=[/color] _plus; [color=#008000][b]break[/b][/color];
                [color=#008000][b]case[/b][/color] [color=#BA2121]'-'[/color]: currentLexem [color=#666666]=[/color] _minus; [color=#008000][b]break[/b][/color];
                [color=#008000][b]case[/b][/color] [color=#BA2121]'*'[/color]: currentLexem [color=#666666]=[/color] _mul; [color=#008000][b]break[/b][/color];
                [color=#008000][b]case[/b][/color] [color=#BA2121]'^'[/color]: currentLexem [color=#666666]=[/color] _pow; [color=#008000][b]break[/b][/color];
                [color=#008000][b]case[/b][/color] [color=#BA2121]'\0'[/color]: currentLexem [color=#666666]=[/color] _end; [color=#008000][b]break[/b][/color];
                [color=#A0A000]default:[/color] currentLexem [color=#666666]=[/color] _dig; [color=#008000][b]break[/b][/color];
        }
}

Node[color=#666666]*[/color] [color=#0000FF]expression[/color]()
{
        Node[color=#666666]*[/color] child [color=#666666]=[/color] sum();
        Node[color=#666666]*[/color] res;
        [color=#008000][b]if[/b][/color](currentLexem [color=#666666]==[/color] _plus [color=#666666]||[/color] currentLexem [color=#666666]==[/color] _minus)
        {
                res [color=#666666]=[/color] malloc([color=#008000][b]sizeof[/b][/color](Node));
                res[color=#666666]->[/color]left [color=#666666]=[/color] child;
                res[color=#666666]->[/color]operator [color=#666666]=[/color] currentLexem;
                next_lexem();
                res[color=#666666]->[/color]right [color=#666666]=[/color] expression();
        }
        [color=#008000][b]else[/b][/color]
        {
                res [color=#666666]=[/color] child;
        }
        [color=#008000][b]return[/b][/color] res;
}

Node[color=#666666]*[/color] [color=#0000FF]sum[/color]()
{
        Node[color=#666666]*[/color] child [color=#666666]=[/color] mul_pow();
        Node[color=#666666]*[/color] res;
        [color=#008000][b]if[/b][/color](currentLexem [color=#666666]==[/color] _mul)
        {
                res [color=#666666]=[/color] malloc([color=#008000][b]sizeof[/b][/color](Node));
                res[color=#666666]->[/color]left [color=#666666]=[/color] child;
                res[color=#666666]->[/color]operator [color=#666666]=[/color] currentLexem;
                next_lexem();
                res[color=#666666]->[/color]right [color=#666666]=[/color] sum();
        }
        [color=#008000][b]else[/b][/color]
        {
                res [color=#666666]=[/color] child;
        }
        [color=#008000][b]return[/b][/color] res;
}

Node[color=#666666]*[/color] [color=#0000FF]mul_pow[/color]()
{
        Node[color=#666666]*[/color] child [color=#666666]=[/color] mul();
        Node[color=#666666]*[/color] res;
        [color=#008000][b]if[/b][/color](currentLexem [color=#666666]==[/color] _pow)
        {
                res [color=#666666]=[/color] malloc([color=#008000][b]sizeof[/b][/color](Node));
                res[color=#666666]->[/color]left [color=#666666]=[/color] child;
                res[color=#666666]->[/color]operator [color=#666666]=[/color] currentLexem;
                next_lexem();
                res[color=#666666]->[/color]right [color=#666666]=[/color] mul();
        }
        [color=#008000][b]else[/b][/color]
        {
                res [color=#666666]=[/color] child;
        }
        [color=#008000][b]return[/b][/color] res;
}

Node[color=#666666]*[/color] [color=#0000FF]mul[/color]()
{
        Node[color=#666666]*[/color] res;
        [color=#008000][b]if[/b][/color](currentLexem [color=#666666]==[/color] _lt)
        {
                next_lexem();
                res [color=#666666]=[/color] expression();
                next_lexem();
        }
        [color=#008000][b]else[/b][/color]
        {
                [color=#008000][b]if[/b][/color](currentLexem [color=#666666]==[/color] _dig)
                {
                        res [color=#666666]=[/color] malloc([color=#008000][b]sizeof[/b][/color](Node));
                        res[color=#666666]->[/color]operator [color=#666666]=[/color] currentLexem;
                        [color=#B00040]int[/color] i [color=#666666]=[/color] [color=#666666]0[/color];
                        [color=#008000][b]while[/b][/color](currentLexem [color=#666666]==[/color] _dig)
                        {
                                res[color=#666666]->[/color]sign[i[color=#666666]++[/color]] [color=#666666]=[/color] expr[currentPos];
                                next_lexem();
                        }
                        res[color=#666666]->[/color]sign[i] [color=#666666]=[/color] [color=#BA2121]'\0'[/color];
                }
        }
        [color=#008000][b]return[/b][/color] res;
}

[color=#B00040]void[/color] [color=#0000FF]parse_tree[/color](Node [color=#666666]*[/color]n)
{
        [color=#008000][b]if[/b][/color](n[color=#666666]->[/color]operator [color=#666666]==[/color] _pow [color=#666666]&&[/color]
                n[color=#666666]->[/color]left[color=#666666]->[/color]operator [color=#666666]==[/color] _minus [color=#666666]&&[/color]
                n[color=#666666]->[/color]right[color=#666666]->[/color]operator [color=#666666]==[/color] _dig [color=#666666]&&[/color]
                [color=#666666]![/color]strcmp(n[color=#666666]->[/color]right[color=#666666]->[/color]sign,[color=#BA2121]"2"[/color]))
        {
                Node [color=#666666]*[/color]n1 [color=#666666]=[/color] malloc([color=#008000][b]sizeof[/b][/color](Node));
                Node [color=#666666]*[/color]n2 [color=#666666]=[/color] malloc([color=#008000][b]sizeof[/b][/color](Node));
                Node [color=#666666]*[/color]n3 [color=#666666]=[/color] malloc([color=#008000][b]sizeof[/b][/color](Node));
                Node [color=#666666]*[/color]n4 [color=#666666]=[/color] malloc([color=#008000][b]sizeof[/b][/color](Node));
                Node [color=#666666]*[/color]n5 [color=#666666]=[/color] malloc([color=#008000][b]sizeof[/b][/color](Node));
                Node [color=#666666]*[/color]n6 [color=#666666]=[/color] malloc([color=#008000][b]sizeof[/b][/color](Node));

Node [color=#666666]*[/color]a [color=#666666]=[/color] n[color=#666666]->[/color]left[color=#666666]->[/color]left;
                Node [color=#666666]*[/color]b [color=#666666]=[/color] n[color=#666666]->[/color]left[color=#666666]->[/color]right;

n1[color=#666666]->[/color]sign[[color=#666666]0[/color]] [color=#666666]=[/color] [color=#BA2121]'2'[/color]; n1[color=#666666]->[/color]sign[[color=#666666]1[/color]] [color=#666666]=[/color]  [color=#BA2121]'\0'[/color]; n1[color=#666666]->[/color]operator [color=#666666]=[/color] _dig;
                n2[color=#666666]->[/color]left [color=#666666]=[/color] a; n2[color=#666666]->[/color]right [color=#666666]=[/color] n1; n2[color=#666666]->[/color]operator [color=#666666]=[/color] _pow;
                n3[color=#666666]->[/color]left [color=#666666]=[/color] n1; n3[color=#666666]->[/color]right [color=#666666]=[/color] a; n3[color=#666666]->[/color]operator [color=#666666]=[/color] _mul;
                n4[color=#666666]->[/color]left [color=#666666]=[/color] n3; n4[color=#666666]->[/color]right [color=#666666]=[/color] b; n4[color=#666666]->[/color]operator [color=#666666]=[/color] _mul;
                n5[color=#666666]->[/color]left [color=#666666]=[/color] n2; n5[color=#666666]->[/color]right [color=#666666]=[/color] n4; n5[color=#666666]->[/color]operator [color=#666666]=[/color] _minus;
                n6[color=#666666]->[/color]left [color=#666666]=[/color] b; n6[color=#666666]->[/color]right [color=#666666]=[/color] n1; n6[color=#666666]->[/color]operator [color=#666666]=[/color] _pow;
                n[color=#666666]->[/color]left [color=#666666]=[/color] n5; n[color=#666666]->[/color]right [color=#666666]=[/color] n6; n[color=#666666]->[/color]operator [color=#666666]=[/color] _plus;
        }
        [color=#008000][b]if[/b][/color](n[color=#666666]->[/color]operator [color=#666666]!=[/color] _dig)
        {
                parse_tree(n[color=#666666]->[/color]left);
                parse_tree(n[color=#666666]->[/color]right);
        }
}

[color=#B00040]void[/color] [color=#0000FF]print_tree[/color](Node [color=#666666]*[/color]n)
{
        [color=#008000][b]if[/b][/color](n[color=#666666]->[/color]operator [color=#666666]==[/color] _dig)
        {
                printf([color=#BA2121]"%s"[/color], n[color=#666666]->[/color]sign);
        }
        [color=#008000][b]else[/b][/color]
        {
                [color=#008000][b]if[/b][/color](n[color=#666666]->[/color]left[color=#666666]->[/color]operator [color=#666666]!=[/color] _dig) print_lexem(_lt);
                print_tree(n[color=#666666]->[/color]left);
                [color=#008000][b]if[/b][/color](n[color=#666666]->[/color]left[color=#666666]->[/color]operator [color=#666666]!=[/color] _dig) print_lexem(_gt);
                print_lexem(n[color=#666666]->[/color]operator);
                [color=#008000][b]if[/b][/color](n[color=#666666]->[/color]right[color=#666666]->[/color]operator [color=#666666]!=[/color] _dig) print_lexem(_lt);
                print_tree(n[color=#666666]->[/color]right);
                [color=#008000][b]if[/b][/color](n[color=#666666]->[/color]right[color=#666666]->[/color]operator [color=#666666]!=[/color] _dig) print_lexem(_gt);
        }
}

[color=#B00040]int[/color] [color=#0000FF]main[/color]()
{
        expr [color=#666666]=[/color] [color=#BA2121]"2"[/color];
        currentPos [color=#666666]=[/color] [color=#666666]-[/color][color=#666666]1[/color];
        next_lexem();
        Node [color=#666666]*[/color]root, [color=#666666]*[/color]new_root;
        root [color=#666666]=[/color] expression();
        parse_tree(root);
        print_tree(root);
        printf([color=#BA2121]"[/color][color=#BB6622][b]\n[/b][/color][color=#BA2121]"[/color]);
        [color=#008000][b]return[/b][/color] [color=#666666]0[/color];
}

--------------------------------------
Colored with http://dumpz.org

Light HTML Copy To Clipboarddone!

That method generates HTML with CSS classes. Hence you'll need the style sheet file

<div class="highlight"><pre><div id="lc1"><span class="cp">#include&lt;stdio.h&gt;</span>
</div><div id="lc2"><span class="cp">#include&lt;stdlib.h&gt;</span>
</div><div id="lc3"><span class="cp">#include&lt;string.h&gt;</span>
</div><div id="lc4"><span class="cp">#include&lt;math.h&gt;</span>
</div><div id="lc5">
</div><div id="lc6"><span class="k">typedef</span> <span class="k">enum</span> <span class="p">{</span> <span class="n">_none</span><span class="p">,</span> <span class="n">_plus</span><span class="p">,</span> <span class="n">_minus</span><span class="p">,</span> <span class="n">_mul</span><span class="p">,</span> <span class="n">_dig</span><span class="p">,</span> <span class="n">_lt</span><span class="p">,</span> <span class="n">_gt</span><span class="p">,</span> <span class="n">_pow</span><span class="p">,</span> <span class="n">_end</span> <span class="p">}</span> <span class="n">Lexem</span><span class="p">;</span>
</div><div id="lc7">
</div><div id="lc8"><span class="n">Lexem</span> <span class="n">currentLexem</span><span class="p">;</span>
</div><div id="lc9"><span class="kt">int</span> <span class="n">currentPos</span><span class="p">;</span>
</div><div id="lc10"><span class="kt">char</span> <span class="o">*</span><span class="n">expr</span><span class="p">;</span>
</div><div id="lc11">
</div><div id="lc12"><span class="k">typedef</span> <span class="k">struct</span> <span class="n">pNode</span>
</div><div id="lc13"><span class="p">{</span>
</div><div id="lc14">        <span class="kt">char</span> <span class="n">sign</span><span class="p">[</span><span class="mi">5</span><span class="p">];</span>
</div><div id="lc15">        <span class="n">Lexem</span> <span class="n">operator</span><span class="p">;</span>
</div><div id="lc16">        <span class="k">struct</span> <span class="n">pNode</span><span class="o">*</span> <span class="n">left</span><span class="p">;</span>
</div><div id="lc17">        <span class="k">struct</span> <span class="n">pNode</span><span class="o">*</span> <span class="n">right</span><span class="p">;</span>
</div><div id="lc18"><span class="p">}</span> <span class="n">Node</span><span class="p">;</span>
</div><div id="lc19">
</div><div id="lc20"><span class="kt">void</span> <span class="nf">print_lexem</span><span class="p">(</span><span class="n">Lexem</span> <span class="n">l</span><span class="p">)</span>
</div><div id="lc21"><span class="p">{</span>
</div><div id="lc22">        <span class="k">switch</span><span class="p">(</span><span class="n">l</span><span class="p">)</span>
</div><div id="lc23">        <span class="p">{</span>
</div><div id="lc24">                <span class="k">case</span> <span class="n">_lt</span>: <span class="n">printf</span><span class="p">(</span><span class="s">&quot;(&quot;</span><span class="p">);</span> <span class="k">break</span><span class="p">;</span>
</div><div id="lc25">                <span class="k">case</span> <span class="n">_gt</span>: <span class="n">printf</span><span class="p">(</span><span class="s">&quot;)&quot;</span><span class="p">);</span> <span class="k">break</span><span class="p">;</span>
</div><div id="lc26">                <span class="k">case</span> <span class="n">_plus</span>: <span class="n">printf</span><span class="p">(</span><span class="s">&quot;+&quot;</span><span class="p">);</span> <span class="k">break</span><span class="p">;</span>
</div><div id="lc27">                <span class="k">case</span> <span class="n">_minus</span>: <span class="n">printf</span><span class="p">(</span><span class="s">&quot;-&quot;</span><span class="p">);</span> <span class="k">break</span><span class="p">;</span>
</div><div id="lc28">                <span class="k">case</span> <span class="n">_mul</span>: <span class="n">printf</span><span class="p">(</span><span class="s">&quot;*&quot;</span><span class="p">);</span> <span class="k">break</span><span class="p">;</span>
</div><div id="lc29">                <span class="k">case</span> <span class="n">_pow</span>: <span class="n">printf</span><span class="p">(</span><span class="s">&quot;^&quot;</span><span class="p">);</span> <span class="k">break</span><span class="p">;</span>
</div><div id="lc30">                <span class="k">case</span> <span class="n">_end</span>: <span class="n">printf</span><span class="p">(</span><span class="s">&quot;</span><span class="se">\n</span><span class="s">&quot;</span><span class="p">);</span> <span class="k">break</span><span class="p">;</span>
</div><div id="lc31">        <span class="p">}</span>
</div><div id="lc32"><span class="p">}</span>
</div><div id="lc33">
</div><div id="lc34"><span class="n">Node</span><span class="o">*</span> <span class="n">expression</span><span class="p">();</span>
</div><div id="lc35"><span class="n">Node</span><span class="o">*</span> <span class="n">sum</span><span class="p">();</span>
</div><div id="lc36"><span class="n">Node</span><span class="o">*</span> <span class="n">mul_pow</span><span class="p">();</span>
</div><div id="lc37"><span class="n">Node</span><span class="o">*</span> <span class="n">mul</span><span class="p">();</span>
</div><div id="lc38">
</div><div id="lc39"><span class="kt">void</span> <span class="nf">next_lexem</span><span class="p">()</span>
</div><div id="lc40"><span class="p">{</span>
</div><div id="lc41">        <span class="n">currentPos</span><span class="o">++</span><span class="p">;</span>
</div><div id="lc42">        <span class="k">switch</span><span class="p">(</span><span class="n">expr</span><span class="p">[</span><span class="n">currentPos</span><span class="p">])</span>
</div><div id="lc43">        <span class="p">{</span>
</div><div id="lc44">                <span class="k">case</span> <span class="sc">&#39;(&#39;</span>: <span class="n">currentLexem</span> <span class="o">=</span> <span class="n">_lt</span><span class="p">;</span> <span class="k">break</span><span class="p">;</span>
</div><div id="lc45">                <span class="k">case</span> <span class="sc">&#39;)&#39;</span>: <span class="n">currentLexem</span> <span class="o">=</span> <span class="n">_gt</span><span class="p">;</span> <span class="k">break</span><span class="p">;</span>
</div><div id="lc46">                <span class="k">case</span> <span class="sc">&#39;+&#39;</span>: <span class="n">currentLexem</span> <span class="o">=</span> <span class="n">_plus</span><span class="p">;</span> <span class="k">break</span><span class="p">;</span>
</div><div id="lc47">                <span class="k">case</span> <span class="sc">&#39;-&#39;</span>: <span class="n">currentLexem</span> <span class="o">=</span> <span class="n">_minus</span><span class="p">;</span> <span class="k">break</span><span class="p">;</span>
</div><div id="lc48">                <span class="k">case</span> <span class="sc">&#39;*&#39;</span>: <span class="n">currentLexem</span> <span class="o">=</span> <span class="n">_mul</span><span class="p">;</span> <span class="k">break</span><span class="p">;</span>
</div><div id="lc49">                <span class="k">case</span> <span class="sc">&#39;^&#39;</span>: <span class="n">currentLexem</span> <span class="o">=</span> <span class="n">_pow</span><span class="p">;</span> <span class="k">break</span><span class="p">;</span>
</div><div id="lc50">                <span class="k">case</span> <span class="sc">&#39;\0&#39;</span>: <span class="n">currentLexem</span> <span class="o">=</span> <span class="n">_end</span><span class="p">;</span> <span class="k">break</span><span class="p">;</span>
</div><div id="lc51">                <span class="nl">default:</span> <span class="n">currentLexem</span> <span class="o">=</span> <span class="n">_dig</span><span class="p">;</span> <span class="k">break</span><span class="p">;</span>
</div><div id="lc52">        <span class="p">}</span>
</div><div id="lc53"><span class="p">}</span>
</div><div id="lc54">
</div><div id="lc55">
</div><div id="lc56"><span class="n">Node</span><span class="o">*</span> <span class="nf">expression</span><span class="p">()</span>
</div><div id="lc57"><span class="p">{</span>
</div><div id="lc58">        <span class="n">Node</span><span class="o">*</span> <span class="n">child</span> <span class="o">=</span> <span class="n">sum</span><span class="p">();</span>
</div><div id="lc59">        <span class="n">Node</span><span class="o">*</span> <span class="n">res</span><span class="p">;</span>
</div><div id="lc60">        <span class="k">if</span><span class="p">(</span><span class="n">currentLexem</span> <span class="o">==</span> <span class="n">_plus</span> <span class="o">||</span> <span class="n">currentLexem</span> <span class="o">==</span> <span class="n">_minus</span><span class="p">)</span>
</div><div id="lc61">        <span class="p">{</span>
</div><div id="lc62">                <span class="n">res</span> <span class="o">=</span> <span class="n">malloc</span><span class="p">(</span><span class="k">sizeof</span><span class="p">(</span><span class="n">Node</span><span class="p">));</span>
</div><div id="lc63">                <span class="n">res</span><span class="o">-&gt;</span><span class="n">left</span> <span class="o">=</span> <span class="n">child</span><span class="p">;</span>
</div><div id="lc64">                <span class="n">res</span><span class="o">-&gt;</span><span class="n">operator</span> <span class="o">=</span> <span class="n">currentLexem</span><span class="p">;</span>
</div><div id="lc65">                <span class="n">next_lexem</span><span class="p">();</span>
</div><div id="lc66">                <span class="n">res</span><span class="o">-&gt;</span><span class="n">right</span> <span class="o">=</span> <span class="n">expression</span><span class="p">();</span>
</div><div id="lc67">        <span class="p">}</span>
</div><div id="lc68">        <span class="k">else</span>
</div><div id="lc69">        <span class="p">{</span>
</div><div id="lc70">                <span class="n">res</span> <span class="o">=</span> <span class="n">child</span><span class="p">;</span>
</div><div id="lc71">        <span class="p">}</span>
</div><div id="lc72">        <span class="k">return</span> <span class="n">res</span><span class="p">;</span>
</div><div id="lc73"><span class="p">}</span>
</div><div id="lc74">
</div><div id="lc75"><span class="n">Node</span><span class="o">*</span> <span class="nf">sum</span><span class="p">()</span>
</div><div id="lc76"><span class="p">{</span>
</div><div id="lc77">        <span class="n">Node</span><span class="o">*</span> <span class="n">child</span> <span class="o">=</span> <span class="n">mul_pow</span><span class="p">();</span>
</div><div id="lc78">        <span class="n">Node</span><span class="o">*</span> <span class="n">res</span><span class="p">;</span>
</div><div id="lc79">        <span class="k">if</span><span class="p">(</span><span class="n">currentLexem</span> <span class="o">==</span> <span class="n">_mul</span><span class="p">)</span>
</div><div id="lc80">        <span class="p">{</span>
</div><div id="lc81">                <span class="n">res</span> <span class="o">=</span> <span class="n">malloc</span><span class="p">(</span><span class="k">sizeof</span><span class="p">(</span><span class="n">Node</span><span class="p">));</span>
</div><div id="lc82">                <span class="n">res</span><span class="o">-&gt;</span><span class="n">left</span> <span class="o">=</span> <span class="n">child</span><span class="p">;</span>
</div><div id="lc83">                <span class="n">res</span><span class="o">-&gt;</span><span class="n">operator</span> <span class="o">=</span> <span class="n">currentLexem</span><span class="p">;</span>
</div><div id="lc84">                <span class="n">next_lexem</span><span class="p">();</span>
</div><div id="lc85">                <span class="n">res</span><span class="o">-&gt;</span><span class="n">right</span> <span class="o">=</span> <span class="n">sum</span><span class="p">();</span>
</div><div id="lc86">        <span class="p">}</span>
</div><div id="lc87">        <span class="k">else</span>
</div><div id="lc88">        <span class="p">{</span>
</div><div id="lc89">                <span class="n">res</span> <span class="o">=</span> <span class="n">child</span><span class="p">;</span>
</div><div id="lc90">        <span class="p">}</span>
</div><div id="lc91">        <span class="k">return</span> <span class="n">res</span><span class="p">;</span>
</div><div id="lc92"><span class="p">}</span>
</div><div id="lc93">
</div><div id="lc94"><span class="n">Node</span><span class="o">*</span> <span class="nf">mul_pow</span><span class="p">()</span>
</div><div id="lc95"><span class="p">{</span>
</div><div id="lc96">        <span class="n">Node</span><span class="o">*</span> <span class="n">child</span> <span class="o">=</span> <span class="n">mul</span><span class="p">();</span>
</div><div id="lc97">        <span class="n">Node</span><span class="o">*</span> <span class="n">res</span><span class="p">;</span>
</div><div id="lc98">        <span class="k">if</span><span class="p">(</span><span class="n">currentLexem</span> <span class="o">==</span> <span class="n">_pow</span><span class="p">)</span>
</div><div id="lc99">        <span class="p">{</span>
</div><div id="lc100">                <span class="n">res</span> <span class="o">=</span> <span class="n">malloc</span><span class="p">(</span><span class="k">sizeof</span><span class="p">(</span><span class="n">Node</span><span class="p">));</span>
</div><div id="lc101">                <span class="n">res</span><span class="o">-&gt;</span><span class="n">left</span> <span class="o">=</span> <span class="n">child</span><span class="p">;</span>
</div><div id="lc102">                <span class="n">res</span><span class="o">-&gt;</span><span class="n">operator</span> <span class="o">=</span> <span class="n">currentLexem</span><span class="p">;</span>
</div><div id="lc103">                <span class="n">next_lexem</span><span class="p">();</span>
</div><div id="lc104">                <span class="n">res</span><span class="o">-&gt;</span><span class="n">right</span> <span class="o">=</span> <span class="n">mul</span><span class="p">();</span>
</div><div id="lc105">        <span class="p">}</span>
</div><div id="lc106">        <span class="k">else</span>
</div><div id="lc107">        <span class="p">{</span>
</div><div id="lc108">                <span class="n">res</span> <span class="o">=</span> <span class="n">child</span><span class="p">;</span>
</div><div id="lc109">        <span class="p">}</span>
</div><div id="lc110">        <span class="k">return</span> <span class="n">res</span><span class="p">;</span>
</div><div id="lc111"><span class="p">}</span>
</div><div id="lc112">
</div><div id="lc113"><span class="n">Node</span><span class="o">*</span> <span class="nf">mul</span><span class="p">()</span>
</div><div id="lc114"><span class="p">{</span>
</div><div id="lc115">        <span class="n">Node</span><span class="o">*</span> <span class="n">res</span><span class="p">;</span>
</div><div id="lc116">        <span class="k">if</span><span class="p">(</span><span class="n">currentLexem</span> <span class="o">==</span> <span class="n">_lt</span><span class="p">)</span>
</div><div id="lc117">        <span class="p">{</span>
</div><div id="lc118">                <span class="n">next_lexem</span><span class="p">();</span>
</div><div id="lc119">                <span class="n">res</span> <span class="o">=</span> <span class="n">expression</span><span class="p">();</span>
</div><div id="lc120">                <span class="n">next_lexem</span><span class="p">();</span>
</div><div id="lc121">        <span class="p">}</span>
</div><div id="lc122">        <span class="k">else</span>
</div><div id="lc123">        <span class="p">{</span>
</div><div id="lc124">                <span class="k">if</span><span class="p">(</span><span class="n">currentLexem</span> <span class="o">==</span> <span class="n">_dig</span><span class="p">)</span>
</div><div id="lc125">                <span class="p">{</span>
</div><div id="lc126">                        <span class="n">res</span> <span class="o">=</span> <span class="n">malloc</span><span class="p">(</span><span class="k">sizeof</span><span class="p">(</span><span class="n">Node</span><span class="p">));</span>
</div><div id="lc127">                        <span class="n">res</span><span class="o">-&gt;</span><span class="n">operator</span> <span class="o">=</span> <span class="n">currentLexem</span><span class="p">;</span>
</div><div id="lc128">                        <span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
</div><div id="lc129">                        <span class="k">while</span><span class="p">(</span><span class="n">currentLexem</span> <span class="o">==</span> <span class="n">_dig</span><span class="p">)</span>
</div><div id="lc130">                        <span class="p">{</span>
</div><div id="lc131">                                <span class="n">res</span><span class="o">-&gt;</span><span class="n">sign</span><span class="p">[</span><span class="n">i</span><span class="o">++</span><span class="p">]</span> <span class="o">=</span> <span class="n">expr</span><span class="p">[</span><span class="n">currentPos</span><span class="p">];</span>
</div><div id="lc132">                                <span class="n">next_lexem</span><span class="p">();</span>
</div><div id="lc133">                        <span class="p">}</span>
</div><div id="lc134">                        <span class="n">res</span><span class="o">-&gt;</span><span class="n">sign</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="sc">&#39;\0&#39;</span><span class="p">;</span>
</div><div id="lc135">                <span class="p">}</span>
</div><div id="lc136">        <span class="p">}</span>
</div><div id="lc137">        <span class="k">return</span> <span class="n">res</span><span class="p">;</span>
</div><div id="lc138"><span class="p">}</span>
</div><div id="lc139">
</div><div id="lc140"><span class="kt">void</span> <span class="nf">parse_tree</span><span class="p">(</span><span class="n">Node</span> <span class="o">*</span><span class="n">n</span><span class="p">)</span>
</div><div id="lc141"><span class="p">{</span>
</div><div id="lc142">        <span class="k">if</span><span class="p">(</span><span class="n">n</span><span class="o">-&gt;</span><span class="n">operator</span> <span class="o">==</span> <span class="n">_pow</span> <span class="o">&amp;&amp;</span>
</div><div id="lc143">                <span class="n">n</span><span class="o">-&gt;</span><span class="n">left</span><span class="o">-&gt;</span><span class="n">operator</span> <span class="o">==</span> <span class="n">_minus</span> <span class="o">&amp;&amp;</span>
</div><div id="lc144">                <span class="n">n</span><span class="o">-&gt;</span><span class="n">right</span><span class="o">-&gt;</span><span class="n">operator</span> <span class="o">==</span> <span class="n">_dig</span> <span class="o">&amp;&amp;</span>
</div><div id="lc145">                <span class="o">!</span><span class="n">strcmp</span><span class="p">(</span><span class="n">n</span><span class="o">-&gt;</span><span class="n">right</span><span class="o">-&gt;</span><span class="n">sign</span><span class="p">,</span><span class="s">&quot;2&quot;</span><span class="p">))</span>
</div><div id="lc146">        <span class="p">{</span>
</div><div id="lc147">                <span class="n">Node</span> <span class="o">*</span><span class="n">n1</span> <span class="o">=</span> <span class="n">malloc</span><span class="p">(</span><span class="k">sizeof</span><span class="p">(</span><span class="n">Node</span><span class="p">));</span>
</div><div id="lc148">                <span class="n">Node</span> <span class="o">*</span><span class="n">n2</span> <span class="o">=</span> <span class="n">malloc</span><span class="p">(</span><span class="k">sizeof</span><span class="p">(</span><span class="n">Node</span><span class="p">));</span>
</div><div id="lc149">                <span class="n">Node</span> <span class="o">*</span><span class="n">n3</span> <span class="o">=</span> <span class="n">malloc</span><span class="p">(</span><span class="k">sizeof</span><span class="p">(</span><span class="n">Node</span><span class="p">));</span>
</div><div id="lc150">                <span class="n">Node</span> <span class="o">*</span><span class="n">n4</span> <span class="o">=</span> <span class="n">malloc</span><span class="p">(</span><span class="k">sizeof</span><span class="p">(</span><span class="n">Node</span><span class="p">));</span>
</div><div id="lc151">                <span class="n">Node</span> <span class="o">*</span><span class="n">n5</span> <span class="o">=</span> <span class="n">malloc</span><span class="p">(</span><span class="k">sizeof</span><span class="p">(</span><span class="n">Node</span><span class="p">));</span>
</div><div id="lc152">                <span class="n">Node</span> <span class="o">*</span><span class="n">n6</span> <span class="o">=</span> <span class="n">malloc</span><span class="p">(</span><span class="k">sizeof</span><span class="p">(</span><span class="n">Node</span><span class="p">));</span>
</div><div id="lc153">
</div><div id="lc154">                <span class="n">Node</span> <span class="o">*</span><span class="n">a</span> <span class="o">=</span> <span class="n">n</span><span class="o">-&gt;</span><span class="n">left</span><span class="o">-&gt;</span><span class="n">left</span><span class="p">;</span>
</div><div id="lc155">                <span class="n">Node</span> <span class="o">*</span><span class="n">b</span> <span class="o">=</span> <span class="n">n</span><span class="o">-&gt;</span><span class="n">left</span><span class="o">-&gt;</span><span class="n">right</span><span class="p">;</span>
</div><div id="lc156">
</div><div id="lc157">                <span class="n">n1</span><span class="o">-&gt;</span><span class="n">sign</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="sc">&#39;2&#39;</span><span class="p">;</span> <span class="n">n1</span><span class="o">-&gt;</span><span class="n">sign</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">=</span>  <span class="sc">&#39;\0&#39;</span><span class="p">;</span> <span class="n">n1</span><span class="o">-&gt;</span><span class="n">operator</span> <span class="o">=</span> <span class="n">_dig</span><span class="p">;</span>
</div><div id="lc158">                <span class="n">n2</span><span class="o">-&gt;</span><span class="n">left</span> <span class="o">=</span> <span class="n">a</span><span class="p">;</span> <span class="n">n2</span><span class="o">-&gt;</span><span class="n">right</span> <span class="o">=</span> <span class="n">n1</span><span class="p">;</span> <span class="n">n2</span><span class="o">-&gt;</span><span class="n">operator</span> <span class="o">=</span> <span class="n">_pow</span><span class="p">;</span>
</div><div id="lc159">                <span class="n">n3</span><span class="o">-&gt;</span><span class="n">left</span> <span class="o">=</span> <span class="n">n1</span><span class="p">;</span> <span class="n">n3</span><span class="o">-&gt;</span><span class="n">right</span> <span class="o">=</span> <span class="n">a</span><span class="p">;</span> <span class="n">n3</span><span class="o">-&gt;</span><span class="n">operator</span> <span class="o">=</span> <span class="n">_mul</span><span class="p">;</span>
</div><div id="lc160">                <span class="n">n4</span><span class="o">-&gt;</span><span class="n">left</span> <span class="o">=</span> <span class="n">n3</span><span class="p">;</span> <span class="n">n4</span><span class="o">-&gt;</span><span class="n">right</span> <span class="o">=</span> <span class="n">b</span><span class="p">;</span> <span class="n">n4</span><span class="o">-&gt;</span><span class="n">operator</span> <span class="o">=</span> <span class="n">_mul</span><span class="p">;</span>
</div><div id="lc161">                <span class="n">n5</span><span class="o">-&gt;</span><span class="n">left</span> <span class="o">=</span> <span class="n">n2</span><span class="p">;</span> <span class="n">n5</span><span class="o">-&gt;</span><span class="n">right</span> <span class="o">=</span> <span class="n">n4</span><span class="p">;</span> <span class="n">n5</span><span class="o">-&gt;</span><span class="n">operator</span> <span class="o">=</span> <span class="n">_minus</span><span class="p">;</span>
</div><div id="lc162">                <span class="n">n6</span><span class="o">-&gt;</span><span class="n">left</span> <span class="o">=</span> <span class="n">b</span><span class="p">;</span> <span class="n">n6</span><span class="o">-&gt;</span><span class="n">right</span> <span class="o">=</span> <span class="n">n1</span><span class="p">;</span> <span class="n">n6</span><span class="o">-&gt;</span><span class="n">operator</span> <span class="o">=</span> <span class="n">_pow</span><span class="p">;</span>
</div><div id="lc163">                <span class="n">n</span><span class="o">-&gt;</span><span class="n">left</span> <span class="o">=</span> <span class="n">n5</span><span class="p">;</span> <span class="n">n</span><span class="o">-&gt;</span><span class="n">right</span> <span class="o">=</span> <span class="n">n6</span><span class="p">;</span> <span class="n">n</span><span class="o">-&gt;</span><span class="n">operator</span> <span class="o">=</span> <span class="n">_plus</span><span class="p">;</span>
</div><div id="lc164">        <span class="p">}</span>
</div><div id="lc165">        <span class="k">if</span><span class="p">(</span><span class="n">n</span><span class="o">-&gt;</span><span class="n">operator</span> <span class="o">!=</span> <span class="n">_dig</span><span class="p">)</span>
</div><div id="lc166">        <span class="p">{</span>
</div><div id="lc167">                <span class="n">parse_tree</span><span class="p">(</span><span class="n">n</span><span class="o">-&gt;</span><span class="n">left</span><span class="p">);</span>
</div><div id="lc168">                <span class="n">parse_tree</span><span class="p">(</span><span class="n">n</span><span class="o">-&gt;</span><span class="n">right</span><span class="p">);</span>
</div><div id="lc169">        <span class="p">}</span>
</div><div id="lc170"><span class="p">}</span>
</div><div id="lc171">
</div><div id="lc172"><span class="kt">void</span> <span class="nf">print_tree</span><span class="p">(</span><span class="n">Node</span> <span class="o">*</span><span class="n">n</span><span class="p">)</span>
</div><div id="lc173"><span class="p">{</span>
</div><div id="lc174">        <span class="k">if</span><span class="p">(</span><span class="n">n</span><span class="o">-&gt;</span><span class="n">operator</span> <span class="o">==</span> <span class="n">_dig</span><span class="p">)</span>
</div><div id="lc175">        <span class="p">{</span>
</div><div id="lc176">                <span class="n">printf</span><span class="p">(</span><span class="s">&quot;%s&quot;</span><span class="p">,</span> <span class="n">n</span><span class="o">-&gt;</span><span class="n">sign</span><span class="p">);</span>
</div><div id="lc177">        <span class="p">}</span>
</div><div id="lc178">        <span class="k">else</span>
</div><div id="lc179">        <span class="p">{</span>
</div><div id="lc180">                <span class="k">if</span><span class="p">(</span><span class="n">n</span><span class="o">-&gt;</span><span class="n">left</span><span class="o">-&gt;</span><span class="n">operator</span> <span class="o">!=</span> <span class="n">_dig</span><span class="p">)</span> <span class="n">print_lexem</span><span class="p">(</span><span class="n">_lt</span><span class="p">);</span>
</div><div id="lc181">                <span class="n">print_tree</span><span class="p">(</span><span class="n">n</span><span class="o">-&gt;</span><span class="n">left</span><span class="p">);</span>
</div><div id="lc182">                <span class="k">if</span><span class="p">(</span><span class="n">n</span><span class="o">-&gt;</span><span class="n">left</span><span class="o">-&gt;</span><span class="n">operator</span> <span class="o">!=</span> <span class="n">_dig</span><span class="p">)</span> <span class="n">print_lexem</span><span class="p">(</span><span class="n">_gt</span><span class="p">);</span>
</div><div id="lc183">                <span class="n">print_lexem</span><span class="p">(</span><span class="n">n</span><span class="o">-&gt;</span><span class="n">operator</span><span class="p">);</span>
</div><div id="lc184">                <span class="k">if</span><span class="p">(</span><span class="n">n</span><span class="o">-&gt;</span><span class="n">right</span><span class="o">-&gt;</span><span class="n">operator</span> <span class="o">!=</span> <span class="n">_dig</span><span class="p">)</span> <span class="n">print_lexem</span><span class="p">(</span><span class="n">_lt</span><span class="p">);</span>
</div><div id="lc185">                <span class="n">print_tree</span><span class="p">(</span><span class="n">n</span><span class="o">-&gt;</span><span class="n">right</span><span class="p">);</span>
</div><div id="lc186">                <span class="k">if</span><span class="p">(</span><span class="n">n</span><span class="o">-&gt;</span><span class="n">right</span><span class="o">-&gt;</span><span class="n">operator</span> <span class="o">!=</span> <span class="n">_dig</span><span class="p">)</span> <span class="n">print_lexem</span><span class="p">(</span><span class="n">_gt</span><span class="p">);</span>
</div><div id="lc187">        <span class="p">}</span>
</div><div id="lc188"><span class="p">}</span>
</div><div id="lc189">
</div><div id="lc190"><span class="kt">int</span> <span class="nf">main</span><span class="p">()</span>
</div><div id="lc191"><span class="p">{</span>
</div><div id="lc192">        <span class="n">expr</span> <span class="o">=</span> <span class="s">&quot;2&quot;</span><span class="p">;</span>
</div><div id="lc193">        <span class="n">currentPos</span> <span class="o">=</span> <span class="o">-</span><span class="mi">1</span><span class="p">;</span>
</div><div id="lc194">        <span class="n">next_lexem</span><span class="p">();</span>
</div><div id="lc195">        <span class="n">Node</span> <span class="o">*</span><span class="n">root</span><span class="p">,</span> <span class="o">*</span><span class="n">new_root</span><span class="p">;</span>
</div><div id="lc196">        <span class="n">root</span> <span class="o">=</span> <span class="n">expression</span><span class="p">();</span>
</div><div id="lc197">        <span class="n">parse_tree</span><span class="p">(</span><span class="n">root</span><span class="p">);</span>
</div><div id="lc198">        <span class="n">print_tree</span><span class="p">(</span><span class="n">root</span><span class="p">);</span>
</div><div id="lc199">        <span class="n">printf</span><span class="p">(</span><span class="s">&quot;</span><span class="se">\n</span><span class="s">&quot;</span><span class="p">);</span>
</div><div id="lc200">        <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
</div><div id="lc201"><span class="p">}</span>
</div></pre></div>
<p style="padding: 0; margin: 2em 0 1em 0; font-size: 0.8em; color: #666;"><span style="padding: 0 1em; background-color: #f5f5f5;"> Colored with <a style="color: #333" href="http://dumpz.org">dumpz.org</a></span></p>

Habrahabr.ru HTML Copy To Clipboarddone!

Use that HTML for publications on habrahabr.ru

<blockquote><code><font color="#BC7A00">#include&lt;stdio.h&gt;
#include&lt;stdlib.h&gt;
#include&lt;string.h&gt;
#include&lt;math.h&gt;
</font>
<font color="#008000"><strong>typedef</strong></font>&nbsp;<font color="#008000"><strong>enum</strong></font>&nbsp;{&nbsp;_none,&nbsp;_plus,&nbsp;_minus,&nbsp;_mul,&nbsp;_dig,&nbsp;_lt,&nbsp;_gt,&nbsp;_pow,&nbsp;_end&nbsp;}&nbsp;Lexem;

Lexem&nbsp;currentLexem;
<font color="#B00040">int</font>&nbsp;currentPos;
<font color="#B00040">char</font>&nbsp;<font color="#666666">*</font>expr;

<font color="#008000"><strong>typedef</strong></font>&nbsp;<font color="#008000"><strong>struct</strong></font>&nbsp;pNode
{
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#B00040">char</font>&nbsp;sign[<font color="#666666">5</font>];
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Lexem&nbsp;operator;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>struct</strong></font>&nbsp;pNode<font color="#666666">*</font>&nbsp;left;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>struct</strong></font>&nbsp;pNode<font color="#666666">*</font>&nbsp;right;
}&nbsp;Node;

<font color="#B00040">void</font>&nbsp;<font color="#0000FF">print_lexem</font>(Lexem&nbsp;l)
{
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>switch</strong></font>(l)
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>case</strong></font>&nbsp;_lt:&nbsp;printf(<font color="#BA2121">&quot;(&quot;</font>);&nbsp;<font color="#008000"><strong>break</strong></font>;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>case</strong></font>&nbsp;_gt:&nbsp;printf(<font color="#BA2121">&quot;)&quot;</font>);&nbsp;<font color="#008000"><strong>break</strong></font>;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>case</strong></font>&nbsp;_plus:&nbsp;printf(<font color="#BA2121">&quot;+&quot;</font>);&nbsp;<font color="#008000"><strong>break</strong></font>;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>case</strong></font>&nbsp;_minus:&nbsp;printf(<font color="#BA2121">&quot;-&quot;</font>);&nbsp;<font color="#008000"><strong>break</strong></font>;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>case</strong></font>&nbsp;_mul:&nbsp;printf(<font color="#BA2121">&quot;*&quot;</font>);&nbsp;<font color="#008000"><strong>break</strong></font>;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>case</strong></font>&nbsp;_pow:&nbsp;printf(<font color="#BA2121">&quot;^&quot;</font>);&nbsp;<font color="#008000"><strong>break</strong></font>;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>case</strong></font>&nbsp;_end:&nbsp;printf(<font color="#BA2121">&quot;</font><font color="#BB6622"><strong>\n</strong></font><font color="#BA2121">&quot;</font>);&nbsp;<font color="#008000"><strong>break</strong></font>;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}
}

Node<font color="#666666">*</font>&nbsp;expression();
Node<font color="#666666">*</font>&nbsp;sum();
Node<font color="#666666">*</font>&nbsp;mul_pow();
Node<font color="#666666">*</font>&nbsp;mul();

<font color="#B00040">void</font>&nbsp;<font color="#0000FF">next_lexem</font>()
{
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;currentPos<font color="#666666">++</font>;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>switch</strong></font>(expr[currentPos])
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>case</strong></font>&nbsp;<font color="#BA2121">&#39;(&#39;</font>:&nbsp;currentLexem&nbsp;<font color="#666666">=</font>&nbsp;_lt;&nbsp;<font color="#008000"><strong>break</strong></font>;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>case</strong></font>&nbsp;<font color="#BA2121">&#39;)&#39;</font>:&nbsp;currentLexem&nbsp;<font color="#666666">=</font>&nbsp;_gt;&nbsp;<font color="#008000"><strong>break</strong></font>;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>case</strong></font>&nbsp;<font color="#BA2121">&#39;+&#39;</font>:&nbsp;currentLexem&nbsp;<font color="#666666">=</font>&nbsp;_plus;&nbsp;<font color="#008000"><strong>break</strong></font>;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>case</strong></font>&nbsp;<font color="#BA2121">&#39;-&#39;</font>:&nbsp;currentLexem&nbsp;<font color="#666666">=</font>&nbsp;_minus;&nbsp;<font color="#008000"><strong>break</strong></font>;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>case</strong></font>&nbsp;<font color="#BA2121">&#39;*&#39;</font>:&nbsp;currentLexem&nbsp;<font color="#666666">=</font>&nbsp;_mul;&nbsp;<font color="#008000"><strong>break</strong></font>;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>case</strong></font>&nbsp;<font color="#BA2121">&#39;^&#39;</font>:&nbsp;currentLexem&nbsp;<font color="#666666">=</font>&nbsp;_pow;&nbsp;<font color="#008000"><strong>break</strong></font>;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>case</strong></font>&nbsp;<font color="#BA2121">&#39;\0&#39;</font>:&nbsp;currentLexem&nbsp;<font color="#666666">=</font>&nbsp;_end;&nbsp;<font color="#008000"><strong>break</strong></font>;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#A0A000">default:</font>&nbsp;currentLexem&nbsp;<font color="#666666">=</font>&nbsp;_dig;&nbsp;<font color="#008000"><strong>break</strong></font>;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}
}

Node<font color="#666666">*</font>&nbsp;<font color="#0000FF">expression</font>()
{
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Node<font color="#666666">*</font>&nbsp;child&nbsp;<font color="#666666">=</font>&nbsp;sum();
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Node<font color="#666666">*</font>&nbsp;res;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>if</strong></font>(currentLexem&nbsp;<font color="#666666">==</font>&nbsp;_plus&nbsp;<font color="#666666">||</font>&nbsp;currentLexem&nbsp;<font color="#666666">==</font>&nbsp;_minus)
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;res&nbsp;<font color="#666666">=</font>&nbsp;malloc(<font color="#008000"><strong>sizeof</strong></font>(Node));
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;res<font color="#666666">-&gt;</font>left&nbsp;<font color="#666666">=</font>&nbsp;child;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;res<font color="#666666">-&gt;</font>operator&nbsp;<font color="#666666">=</font>&nbsp;currentLexem;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;next_lexem();
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;res<font color="#666666">-&gt;</font>right&nbsp;<font color="#666666">=</font>&nbsp;expression();
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>else</strong></font>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;res&nbsp;<font color="#666666">=</font>&nbsp;child;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>return</strong></font>&nbsp;res;
}

Node<font color="#666666">*</font>&nbsp;<font color="#0000FF">sum</font>()
{
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Node<font color="#666666">*</font>&nbsp;child&nbsp;<font color="#666666">=</font>&nbsp;mul_pow();
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Node<font color="#666666">*</font>&nbsp;res;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>if</strong></font>(currentLexem&nbsp;<font color="#666666">==</font>&nbsp;_mul)
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;res&nbsp;<font color="#666666">=</font>&nbsp;malloc(<font color="#008000"><strong>sizeof</strong></font>(Node));
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;res<font color="#666666">-&gt;</font>left&nbsp;<font color="#666666">=</font>&nbsp;child;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;res<font color="#666666">-&gt;</font>operator&nbsp;<font color="#666666">=</font>&nbsp;currentLexem;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;next_lexem();
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;res<font color="#666666">-&gt;</font>right&nbsp;<font color="#666666">=</font>&nbsp;sum();
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>else</strong></font>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;res&nbsp;<font color="#666666">=</font>&nbsp;child;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>return</strong></font>&nbsp;res;
}

Node<font color="#666666">*</font>&nbsp;<font color="#0000FF">mul_pow</font>()
{
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Node<font color="#666666">*</font>&nbsp;child&nbsp;<font color="#666666">=</font>&nbsp;mul();
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Node<font color="#666666">*</font>&nbsp;res;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>if</strong></font>(currentLexem&nbsp;<font color="#666666">==</font>&nbsp;_pow)
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;res&nbsp;<font color="#666666">=</font>&nbsp;malloc(<font color="#008000"><strong>sizeof</strong></font>(Node));
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;res<font color="#666666">-&gt;</font>left&nbsp;<font color="#666666">=</font>&nbsp;child;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;res<font color="#666666">-&gt;</font>operator&nbsp;<font color="#666666">=</font>&nbsp;currentLexem;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;next_lexem();
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;res<font color="#666666">-&gt;</font>right&nbsp;<font color="#666666">=</font>&nbsp;mul();
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>else</strong></font>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;res&nbsp;<font color="#666666">=</font>&nbsp;child;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>return</strong></font>&nbsp;res;
}

Node<font color="#666666">*</font>&nbsp;<font color="#0000FF">mul</font>()
{
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Node<font color="#666666">*</font>&nbsp;res;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>if</strong></font>(currentLexem&nbsp;<font color="#666666">==</font>&nbsp;_lt)
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;next_lexem();
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;res&nbsp;<font color="#666666">=</font>&nbsp;expression();
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;next_lexem();
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>else</strong></font>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>if</strong></font>(currentLexem&nbsp;<font color="#666666">==</font>&nbsp;_dig)
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;res&nbsp;<font color="#666666">=</font>&nbsp;malloc(<font color="#008000"><strong>sizeof</strong></font>(Node));
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;res<font color="#666666">-&gt;</font>operator&nbsp;<font color="#666666">=</font>&nbsp;currentLexem;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#B00040">int</font>&nbsp;i&nbsp;<font color="#666666">=</font>&nbsp;<font color="#666666">0</font>;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>while</strong></font>(currentLexem&nbsp;<font color="#666666">==</font>&nbsp;_dig)
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;res<font color="#666666">-&gt;</font>sign[i<font color="#666666">++</font>]&nbsp;<font color="#666666">=</font>&nbsp;expr[currentPos];
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;next_lexem();
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;res<font color="#666666">-&gt;</font>sign[i]&nbsp;<font color="#666666">=</font>&nbsp;<font color="#BA2121">&#39;\0&#39;</font>;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>return</strong></font>&nbsp;res;
}

<font color="#B00040">void</font>&nbsp;<font color="#0000FF">parse_tree</font>(Node&nbsp;<font color="#666666">*</font>n)
{
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>if</strong></font>(n<font color="#666666">-&gt;</font>operator&nbsp;<font color="#666666">==</font>&nbsp;_pow&nbsp;<font color="#666666">&amp;&amp;</font>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;n<font color="#666666">-&gt;</font>left<font color="#666666">-&gt;</font>operator&nbsp;<font color="#666666">==</font>&nbsp;_minus&nbsp;<font color="#666666">&amp;&amp;</font>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;n<font color="#666666">-&gt;</font>right<font color="#666666">-&gt;</font>operator&nbsp;<font color="#666666">==</font>&nbsp;_dig&nbsp;<font color="#666666">&amp;&amp;</font>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#666666">!</font>strcmp(n<font color="#666666">-&gt;</font>right<font color="#666666">-&gt;</font>sign,<font color="#BA2121">&quot;2&quot;</font>))
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Node&nbsp;<font color="#666666">*</font>n1&nbsp;<font color="#666666">=</font>&nbsp;malloc(<font color="#008000"><strong>sizeof</strong></font>(Node));
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Node&nbsp;<font color="#666666">*</font>n2&nbsp;<font color="#666666">=</font>&nbsp;malloc(<font color="#008000"><strong>sizeof</strong></font>(Node));
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Node&nbsp;<font color="#666666">*</font>n3&nbsp;<font color="#666666">=</font>&nbsp;malloc(<font color="#008000"><strong>sizeof</strong></font>(Node));
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Node&nbsp;<font color="#666666">*</font>n4&nbsp;<font color="#666666">=</font>&nbsp;malloc(<font color="#008000"><strong>sizeof</strong></font>(Node));
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Node&nbsp;<font color="#666666">*</font>n5&nbsp;<font color="#666666">=</font>&nbsp;malloc(<font color="#008000"><strong>sizeof</strong></font>(Node));
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Node&nbsp;<font color="#666666">*</font>n6&nbsp;<font color="#666666">=</font>&nbsp;malloc(<font color="#008000"><strong>sizeof</strong></font>(Node));

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Node&nbsp;<font color="#666666">*</font>a&nbsp;<font color="#666666">=</font>&nbsp;n<font color="#666666">-&gt;</font>left<font color="#666666">-&gt;</font>left;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Node&nbsp;<font color="#666666">*</font>b&nbsp;<font color="#666666">=</font>&nbsp;n<font color="#666666">-&gt;</font>left<font color="#666666">-&gt;</font>right;

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;n1<font color="#666666">-&gt;</font>sign[<font color="#666666">0</font>]&nbsp;<font color="#666666">=</font>&nbsp;<font color="#BA2121">&#39;2&#39;</font>;&nbsp;n1<font color="#666666">-&gt;</font>sign[<font color="#666666">1</font>]&nbsp;<font color="#666666">=</font>&nbsp;&nbsp;<font color="#BA2121">&#39;\0&#39;</font>;&nbsp;n1<font color="#666666">-&gt;</font>operator&nbsp;<font color="#666666">=</font>&nbsp;_dig;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;n2<font color="#666666">-&gt;</font>left&nbsp;<font color="#666666">=</font>&nbsp;a;&nbsp;n2<font color="#666666">-&gt;</font>right&nbsp;<font color="#666666">=</font>&nbsp;n1;&nbsp;n2<font color="#666666">-&gt;</font>operator&nbsp;<font color="#666666">=</font>&nbsp;_pow;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;n3<font color="#666666">-&gt;</font>left&nbsp;<font color="#666666">=</font>&nbsp;n1;&nbsp;n3<font color="#666666">-&gt;</font>right&nbsp;<font color="#666666">=</font>&nbsp;a;&nbsp;n3<font color="#666666">-&gt;</font>operator&nbsp;<font color="#666666">=</font>&nbsp;_mul;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;n4<font color="#666666">-&gt;</font>left&nbsp;<font color="#666666">=</font>&nbsp;n3;&nbsp;n4<font color="#666666">-&gt;</font>right&nbsp;<font color="#666666">=</font>&nbsp;b;&nbsp;n4<font color="#666666">-&gt;</font>operator&nbsp;<font color="#666666">=</font>&nbsp;_mul;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;n5<font color="#666666">-&gt;</font>left&nbsp;<font color="#666666">=</font>&nbsp;n2;&nbsp;n5<font color="#666666">-&gt;</font>right&nbsp;<font color="#666666">=</font>&nbsp;n4;&nbsp;n5<font color="#666666">-&gt;</font>operator&nbsp;<font color="#666666">=</font>&nbsp;_minus;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;n6<font color="#666666">-&gt;</font>left&nbsp;<font color="#666666">=</font>&nbsp;b;&nbsp;n6<font color="#666666">-&gt;</font>right&nbsp;<font color="#666666">=</font>&nbsp;n1;&nbsp;n6<font color="#666666">-&gt;</font>operator&nbsp;<font color="#666666">=</font>&nbsp;_pow;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;n<font color="#666666">-&gt;</font>left&nbsp;<font color="#666666">=</font>&nbsp;n5;&nbsp;n<font color="#666666">-&gt;</font>right&nbsp;<font color="#666666">=</font>&nbsp;n6;&nbsp;n<font color="#666666">-&gt;</font>operator&nbsp;<font color="#666666">=</font>&nbsp;_plus;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>if</strong></font>(n<font color="#666666">-&gt;</font>operator&nbsp;<font color="#666666">!=</font>&nbsp;_dig)
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;parse_tree(n<font color="#666666">-&gt;</font>left);
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;parse_tree(n<font color="#666666">-&gt;</font>right);
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}
}

<font color="#B00040">void</font>&nbsp;<font color="#0000FF">print_tree</font>(Node&nbsp;<font color="#666666">*</font>n)
{
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>if</strong></font>(n<font color="#666666">-&gt;</font>operator&nbsp;<font color="#666666">==</font>&nbsp;_dig)
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;printf(<font color="#BA2121">&quot;%s&quot;</font>,&nbsp;n<font color="#666666">-&gt;</font>sign);
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>else</strong></font>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>if</strong></font>(n<font color="#666666">-&gt;</font>left<font color="#666666">-&gt;</font>operator&nbsp;<font color="#666666">!=</font>&nbsp;_dig)&nbsp;print_lexem(_lt);
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;print_tree(n<font color="#666666">-&gt;</font>left);
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>if</strong></font>(n<font color="#666666">-&gt;</font>left<font color="#666666">-&gt;</font>operator&nbsp;<font color="#666666">!=</font>&nbsp;_dig)&nbsp;print_lexem(_gt);
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;print_lexem(n<font color="#666666">-&gt;</font>operator);
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>if</strong></font>(n<font color="#666666">-&gt;</font>right<font color="#666666">-&gt;</font>operator&nbsp;<font color="#666666">!=</font>&nbsp;_dig)&nbsp;print_lexem(_lt);
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;print_tree(n<font color="#666666">-&gt;</font>right);
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>if</strong></font>(n<font color="#666666">-&gt;</font>right<font color="#666666">-&gt;</font>operator&nbsp;<font color="#666666">!=</font>&nbsp;_dig)&nbsp;print_lexem(_gt);
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}
}

<font color="#B00040">int</font>&nbsp;<font color="#0000FF">main</font>()
{
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;expr&nbsp;<font color="#666666">=</font>&nbsp;<font color="#BA2121">&quot;2&quot;</font>;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;currentPos&nbsp;<font color="#666666">=</font>&nbsp;<font color="#666666">-1</font>;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;next_lexem();
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Node&nbsp;<font color="#666666">*</font>root,&nbsp;<font color="#666666">*</font>new_root;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;root&nbsp;<font color="#666666">=</font>&nbsp;expression();
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;parse_tree(root);
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;print_tree(root);
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;printf(<font color="#BA2121">&quot;</font><font color="#BB6622"><strong>\n</strong></font><font color="#BA2121">&quot;</font>);
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font color="#008000"><strong>return</strong></font>&nbsp;<font color="#666666">0</font>;
}
</code></blockquote><p><font color="gray">Colored with <a href="http://dumpz.org">dumpz.org</a></p>