/Users/cpanrun/depot/main/contrib-patched/perl/CPAN/src/Parse-RPN/blib/html/site/lib/Parse/RPN.html

/Users/cpanrun/depot/main/contrib-patched/perl/CPAN/src/Parse-RPN/blib/html/site/lib/Parse/RPN.html

a b +</pre>

a b +</pre> <pre> return the result of 'a' + 'b'


=cut</pre>
<p>$dict{ '+' } = sub {</p>
<pre>
    <span class="keyword">my</span> <span class="variable">$work1</span> <span class="operator">=</span> <span class="keyword">shift</span><span class="operator">;</span>
    <span class="keyword">my</span> <span class="variable">$a</span>     <span class="operator">=</span> <span class="keyword">pop</span> <span class="variable">@</span><span class="operator">{</span> <span class="variable">$work1</span> <span class="operator">}</span><span class="operator">;</span>
    <span class="keyword">my</span> <span class="variable">$b</span>     <span class="operator">=</span> <span class="keyword">pop</span> <span class="variable">@</span><span class="operator">{</span> <span class="variable">$work1</span> <span class="operator">}</span><span class="operator">;</span>
    <span class="keyword">my</span> <span class="variable">@ret</span><span class="operator">;</span>
    <span class="keyword">push</span> <span class="variable">@ret</span><span class="operator">,</span> <span class="variable">$a</span> <span class="operator">+</span> <span class="variable">$b</span><span class="operator">;</span>
    <span class="keyword">return</span> <span class="operator">\</span><span class="variable">@ret</span><span class="operator">,</span> <span class="number">2</span><span class="operator">,</span> <span class="number">0</span><span class="operator">;</span>
    <span class="operator">};</span>
</pre>
<p>
</p>
<h2><a name="a_b__">a b -</a></h2>
<pre>
      return the result of 'a' - 'b'


=cut</pre>
<p>$dict{ '-' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    push @ret, $b - $a;
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b__">a b *</a></h2>
<pre>
      return the result of 'a' * 'b'


=cut</pre>
<p>$dict{ '*' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    push @ret, $b * $a;
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b__">a b /</a></h2>
<pre>
      return the result of 'a' / 'b' 
      if b =0 return '' (to prevent exception raise)


=cut</pre>
<p>$dict{ '/' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    my $c;
    eval { ( $c = $b / $a ) };
    if ( $@ )
    {
        chomp $@;
        $DEBUG = $@;
        @ret   = ();
    }
    else
    {
        push @ret, $c;
    }
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b___">a b **</a></h2>
<pre>
      return the result of 'a' ** 'b'  (exponant)


=cut</pre>
<p>$dict{ '**' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    push @ret, $b**$a;
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_1_">a 1+</a></h2>
<pre>
      return the result of 'a' +1


=cut</pre>
<p>$dict{ '1+' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, $a + 1;
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_1_">a 1-</a></h2>
<pre>
      return the result of 'a' -1


=cut</pre>
<p>$dict{ '1-' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, $a - 1;
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_2_">a 2-</a></h2>
<pre>
      return the result of 'a' -2


=cut</pre>
<p>$dict{ '2-' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, $a - 2;
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_2_">a 2+</a></h2>
<pre>
      return the result of 'a' +2


=cut</pre>
<p>$dict{ '2+' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, $a + 2;
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_b_mod">a b MOD</a></h2>
<pre>
      return the result of 'a' % 'b'


=cut</pre>
<p>$dict{ 'MOD' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    push @ret, $a % $b;
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_abs">a ABS</a></h2>
<pre>
      return the result of  abs 'a'


=cut</pre>
<p>$dict{ 'ABS' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, abs( $a );
    return \@ret, 1, 0;</p>
<p>};</p>
<p>
</p>
<h2><a name="a_int">a INT</a></h2>
<pre>
      return the result of INT 'a'


=cut</pre>
<p>$dict{ 'INT' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, int( $a );
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a___">a +-</a></h2>
<pre>
      return the result negate value of 'a' (- 'a' )


=cut</pre>
<p>$dict{ '+-' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, -( $a );
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_remain">a REMAIN</a></h2>
<pre>
      return the result of 'a' - int 'a' (fractional part of 'a' )


=cut</pre>
<p>$dict{ 'REMAIN' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, $a - int( $a );
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_sin">a SIN</a></h2>
<pre>
      return the result of sin 'a'  ('a' in RADIAN)


=cut</pre>
<p>$dict{ 'SIN' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, sin( $a );
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_cos">a COS</a></h2>
<pre>
      return the result of cos 'a'  ('a' in RADIAN)


=cut</pre>
<p>$dict{ 'COS' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, cos( $a );
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_tan">a TAN</a></h2>
<pre>
      return the result of tan 'a'  ('a' in RADIAN)


=cut</pre>
<p>$dict{ 'TAN' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, ( sin( $a ) / cos( $a ) );
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_ctan">a CTAN</a></h2>
<pre>
      return the result of cotan 'a'  ('a' in RADIAN)


=cut</pre>
<p>$dict{ 'CTAN' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, ( cos( $a ) / sin( $a ) );
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_ln">a LN</a></h2>
<pre>
      return the result of ln 'a' 
      if = 0 return '' (to prevent exception raise)


=cut</pre>
<p>$dict{ 'LN' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    my $c;
    eval { ( $c = log( $a ) ) };
    if ( $@ )
    {
        chomp $@;
        $DEBUG = $@;
        @ret   = ();
    }
    else
    {
        push @ret, $c;
    }
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_exp">a EXP</a></h2>
<pre>
      return the result of 'e' ** 'a'


=cut</pre>
<p>$dict{ 'EXP' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, exp( $a );
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="pi">PI</a></h2>
<pre>
      return the value of PI (3.14159265358979)


=cut</pre>
<p>$dict{ 'PI' } = sub {
    my @ret;
    push @ret, &quot;3.14159265358979&quot;;
    return \@ret, 0, 0;
};</p>
<p>########################
# relational operators
########################</p>
<p>
</p>
<hr />
<h1><a name="relational_operators">relational operators</a></h1>
<p>.</p>
<p>
</p>
<h2><a name="a_b__">a b &lt;</a></h2>
<pre>
      return the result of 'a' &lt; 'b'  ( BOOLEAN value )


=cut</pre>
<p>$dict{ '&lt;' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    push @ret, ( $a &lt; $b ? 1 : 0 );
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b___">a b &lt;=</a></h2>
<pre>
      return the result of 'a' &lt;= 'b'  ( BOOLEAN value )


=cut</pre>
<p>$dict{ '&lt;=' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    push @ret, ( $a &lt;= $b ? 1 : 0 );
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b__">a b &gt;</a></h2>
<pre>
      return the result of 'a' &gt; 'b'  ( BOOLEAN value )


=cut</pre>
<p>$dict{ '&gt;' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    push @ret, ( $a &gt; $b ? 1 : 0 );
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b___">a b &gt;=</a></h2>
<pre>
      return the result of 'a' &gt;= 'b'  ( BOOLEAN value )


=cut</pre>
<p>$dict{ '&gt;=' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    push @ret, ( $a &gt;= $b ? 1 : 0 );
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b___">a b ==</a></h2>
<pre>
      return the result of 'a' == 'b'  ( BOOLEAN value ) 1 if a == b else 0


=cut</pre>
<p>$dict{ '==' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    push @ret, ( $b == $a ? 1 : 0 );
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b____">a b &lt;=&gt;</a></h2>
<pre>
      return the result of 'a' &lt;=&gt; 'b'  ( BOOLEAN value  ) -1 if a &lt; b ,0 if a == b, 1 if a &gt; b


=cut</pre>
<p>$dict{ '&lt;=&gt;' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    push @ret, ( $b &lt;=&gt; $a );
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b___">a b !=</a></h2>
<pre>
      return the result of 'a' != 'b'  ( BOOLEAN value ) 0 if a == b else 1


=cut</pre>
<p>$dict{ '!=' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    push @ret, ( $b != $a ? 1 : 0 );
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b_or_">a b OR=</a></h2>
<pre>
      return the result of 'a' || 'b'  ( BOOLEAN value ) 0 if a == b else 1


=cut</pre>
<p>########################
# logical operators
########################</p>
<p>
</p>
<hr />
<h1><a name="logical_operators">LOGICAL operators</a></h1>
<p>
</p>
<h2><a name="a_b_or">a b OR</a></h2>
<pre>
      return the 1 one of the 2 argument are not equal to 0


=cut</pre>
<p>$dict{ 'OR' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    push @ret, ( $a || $b );
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b_and">a b AND</a></h2>
<pre>
      return the 0 one of the 2 argument are equal to 0


=cut</pre>
<p>$dict{ 'AND' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    push @ret, ( $a &amp;&amp; $b );
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b_xor">a b XOR</a></h2>
<pre>
      return the 0 if the  2 argument are equal


=cut</pre>
<p>$dict{ 'XOR' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    push @ret, ( $a xor $b ) ? 1 : 0;
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_not">a NOT</a></h2>
<pre>
      return the 0 if the argument is not eqauk to 0
      return the 1 if the argument is  eqauk to 0


=cut</pre>
<p>$dict{ 'NOT' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };</p>
<pre>
    <span class="keyword">my</span> <span class="variable">@ret</span><span class="operator">;</span>
    <span class="keyword">push</span> <span class="variable">@ret</span><span class="operator">,</span> <span class="operator">(</span> <span class="keyword">not</span> <span class="variable">$a</span> <span class="operator">)</span> <span class="operator">?</span> <span class="number">1</span> <span class="operator">:</span> <span class="number">0</span><span class="operator">;</span>
    <span class="keyword">return</span> <span class="operator">\</span><span class="variable">@ret</span><span class="operator">,</span> <span class="number">1</span><span class="operator">,</span> <span class="number">0</span><span class="operator">;</span>
    <span class="operator">};</span>
</pre>
<p>
</p>
<h2><a name="a_true">a TRUE</a></h2>
<pre>
      return the 1 if the top of stack is !=0 and if stack not empty


=cut</pre>
<p>$dict{ 'TRUE' } = sub {
    my $work1 = shift;
    my $a;
    my $b = 0;
    if ( scalar @{ $work1 } )
    {
        $b = 1;
        $a = pop @{ $work1 };
        if ( $a &gt; 0 )
        {
            $b = 1;
        }
        else
        {
            $b = 0;
        }
    }
    my @ret;
    push @ret, $b;
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_false">a FALSE</a></h2>
<pre>
      return the 0 if the top of stack is !=0


=cut</pre>
<p>$dict{ 'FALSE' } = sub {
    my $work1 = shift;
    my $a;
    my $b = 1;
    if ( scalar @{ $work1 } )
    {
        $b = 0;
        $a = pop @{ $work1 };
        if ( $a &gt; 0 )
        {
            $b = 0;
        }
        else
        {
            $b = 1;
        }
    }
    my @ret;
    push @ret, $b;
    return \@ret, 1, 0;
};</p>
<p>########################
# misc operators
########################</p>
<p>
</p>
<hr />
<h1><a name="misc_operators">MISC operators</a></h1>
<p>
</p>
<h2><a name="a_b___">a b &gt;&gt;</a></h2>
<pre>
      bitwise shift to the right
      shift the bits in a to the left of b level


=cut</pre>
<p>$dict{ '&gt;&gt;' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    push @ret, ( $a &gt;&gt; $b );
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b___">a b &lt;&lt;</a></h2>
<pre>
      bitwise shift to the left
      shift the bits in a to the left of b level


=cut</pre>
<p>$dict{ '&lt;&lt;' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    push @ret, ( $a &lt;&lt; $b );
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b_min">a b MIN</a></h2>
<pre>
      return the result smallest of the 2 arguments


=cut</pre>
<p>$dict{ 'MIN' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    push @ret, ( $a &lt; $b ? $a : $b );
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b_max">a b MAX</a></h2>
<pre>
      return the result greatest of the 2 arguments


=cut</pre>
<p>$dict{ 'MAX' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    push @ret, ( $a &gt; $b ? $a : $b );
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="tick">TICK</a></h2>
<pre>
      return the current time in ticks


=cut</pre>
<p>$dict{ 'TICK' } = sub {
    my @ret;
    push @ret, ( <a href="../../../lib/pods/perlfunc.html#time"><code>time()</code></a> );
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_ltime">a LTIME</a></h2>
<pre>
      return the localtime coresponding to the ticks value 'a'
      the format is 'sec' 'min' 'hour' 'day_in_the_month' 'month' 'year' 'day_in_week' 'day_year' 'dayloight_saving'
      'year' is the elapsed year since 1900
      'month' start to 0
      The format is the same as localtime() in perl


=cut</pre>
<p>$dict{ 'LTIME' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, ( localtime( $a ) );
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_gtime">a GTIME</a></h2>
<pre>
      return the gmtime coresponding to the ticks value 'a'
      the format is 'sec' 'min' 'hour' 'day_in_the_month' 'month' 'year' 'day_in_week' 'day_year' 'dayloight_saving'
      'year' is the elapsed year since 1900
      'month' start to 0
      The format is the same as gmtime() in perl


=cut</pre>
<p>$dict{ 'GTIME' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, ( gmtime( $a ) );
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_hltime">a HLTIME</a></h2>
<pre>
      return the localtime coresponding to the ticks value 'a' in a human readable format


=cut</pre>
<p>$dict{ 'HLTIME' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, scalar( localtime( $a ) );
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_hgtime">a HGTIME</a></h2>
<pre>
      return the gmtime coresponding to the ticks value 'a' in a human readable format


=cut</pre>
<p>$dict{ 'HGTIME' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, scalar( gmtime( $a ) );
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="rand">RAND</a></h2>
<pre>
      return a random value in the range [0,1[


=cut</pre>
<p>$dict{ 'RAND' } = sub {
    my @ret;
    push @ret, <a href="../../../lib/pods/perlfunc.html#rand"><code>rand()</code></a>;
    return \@ret, 0, 0;
};</p>
<p>
</p>
<h2><a name="a_lrand">a LRAND</a></h2>
<pre>
      return a random value in the range [0,'a'[


=cut</pre>
<p>$dict{ 'LRAND' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, rand( $a );
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_space">a SPACE</a></h2>
<pre>
      return the number 'a' formated with space each 3 digits


=cut</pre>
<p>$dict{ 'SPACE' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $text  = reverse $a;
    $text =~ s/(\d\d\d)(?=\d)(?!\d*\.)/$1 /g;
    $text = reverse $text;
    my @ret;
    push @ret, $text;
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_dot">a DOT</a></h2>
<pre>
      return the number 'a' formated with . (dot) each 3 digits


=cut</pre>
<p>$dict{ 'DOT' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $text  = reverse $a;
    $text =~ s/(\d\d\d)(?=\d)(?!\d*\.)/$1./g;
    $text = reverse $text;
    my @ret;
    push @ret, $text;
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_norm">a NORM</a></h2>
<pre>
      return the number 'a' normalize by slice of 1000 with extra power value &quot;K&quot;, &quot;M&quot;, &quot;G&quot;, &quot;T&quot;, &quot;P&quot; (or nothing if lower than 1000)


=cut</pre>
<p>$dict{ 'NORM' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $exp;
    $a = $a ? $a : 0;
    my @EXP = ( &quot; &quot;, &quot;K&quot;, &quot;M&quot;, &quot;G&quot;, &quot;T&quot;, &quot;P&quot; );
    while ( $a &gt; 1000 )
    {
        $a = $a / 1000;
        $exp++;
    }
    $a = sprintf &quot;%.2f&quot;, $a;
    my $ret = &quot;$a $EXP[$exp]&quot;;
    my @ret;
    push @ret, &quot;'&quot; . $ret . &quot;'&quot;;
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_norm2">a NORM2</a></h2>
<pre>
      return the number 'a' normalize by slice of 1024 with extra power value &quot;K&quot;, &quot;M&quot;, &quot;G&quot;, &quot;T&quot;, &quot;P&quot; (or nothing if lower than 1024)


=cut</pre>
<p>$dict{ 'NORM2' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $exp;
    $a = $a ? $a : 0;
    my @EXP = ( &quot; &quot;, &quot;K&quot;, &quot;M&quot;, &quot;G&quot;, &quot;T&quot;, &quot;P&quot; );
    while ( $a &gt; 1024 )
    {
        $a = $a / 1024;
        $exp++;
    }
    $a = sprintf &quot;%.2f&quot;, $a;
    my $ret = &quot;$a $EXP[$exp]&quot;;
    my @ret;
    push @ret, &quot;'&quot; . $ret . &quot;'&quot;;
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_oct">a OCT</a></h2>
<pre>
      return the decimal value for the HEX, BINARY or OCTAL value 'a'
      OCTAL is like  '0nn' where n is in the range of 0-7
      BINARY is like '0bnnn...'   where n is in the range of 0-1
      HEX is like '0xnnn' where n is in the range of 0-9A-F
      if no specific format convert as an hexadecimal by default


=cut</pre>
<p>$dict{ 'OCT' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    if ( $a !~ /^0(x|b|([0-7][0-7]))/ )
    {
        $a = &quot;0x&quot; . $a;
    }
    push @ret, oct( $a );
    return \@ret, 1, 0;
};</p>
<p>########################
# string operators
########################</p>
<p>
</p>
<hr />
<h1><a name="string_operators">STRING operators</a></h1>
<p>.</p>
<p>
</p>
<h2><a name="a_b_eq">a b EQ</a></h2>
<pre>
      return the result of 'a' EQ 'b'  ( BOOLEAN value )


=cut</pre>
<p>$dict{ 'EQ' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    push @ret, ( $b eq $a ? 1 : 0 );
    return \@ret, 2;
};</p>
<p>
</p>
<h2><a name="a_b_ne">a b NE</a></h2>
<pre>
      return the result of 'a' NE 'b'  ( BOOLEAN value )


=cut</pre>
<p>$dict{ 'NE' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    push @ret, ( $b ne $a ? 1 : 0 );
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b_lt">a b LT</a></h2>
<pre>
      return the result of 'a' LT 'b'  ( BOOLEAN value )


=cut</pre>
<p>$dict{ 'LT' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    push @ret, ( $b lt $a ? 1 : 0 );
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b_gt">a b GT</a></h2>
<pre>
      return the result of 'a' GT 'b'  ( BOOLEAN value )


=cut</pre>
<p>$dict{ 'GT' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    push @ret, ( $b gt $a ? 1 : 0 );
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b_le">a b LE</a></h2>
<pre>
      return the result of 'a' LE 'b'  ( BOOLEAN value )


=cut</pre>
<p>$dict{ 'LE' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    push @ret, ( $b le $a ? 1 : 0 );
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b_ge">a b GE</a></h2>
<pre>
      return the result of 'a' GE 'b'  ( BOOLEAN value )


=cut</pre>
<p>$dict{ 'GE' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    push @ret, ( $b ge $a ? 1 : 0 );
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b_cmp">a b CMP</a></h2>
<pre>
      return the result of 'a' CMP 'b'  ( BOOLEAN value )


=cut</pre>
<p>$dict{ 'CMP' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    push @ret, ( $b cmp $a );
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_len">a LEN</a></h2>
<pre>
      return the length of 'a' EQ 'b'


=cut</pre>
<p>$dict{ 'LEN' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, ( length $a );
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_b_cat">a b CAT</a></h2>
<pre>
      return the concatenation 'a' and 'b'


=cut</pre>
<p>$dict{ 'CAT' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    push @ret, ( &quot;'&quot; . $b . $a . &quot;'&quot; );
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b_catall">a b CATALL</a></h2>
<pre>
      return the concatenation all element on the stack


=cut</pre>
<p>$dict{ 'CATALL' } = sub {
    my $work1 = shift;
    my $dep   = scalar @{ $work1 };
    my $ret;
    for ( 1 .. $dep )
    {
        $ret .= shift @{ $work1 };
    }
    my @ret;
    push @ret, $ret;
    return \@ret, 1 + $dep, 0;
};</p>
<p>
</p>
<h2><a name="a_b_rep">a b REP</a></h2>
<pre>
      return the result of 'a' x 'b'  duplicate 'a' by the number of 'x'


=cut</pre>
<p>$dict{ 'REP' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @ret;
    push @ret, ( $b x $a );
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_rev">a REV</a></h2>
<pre>
      return the reverse of 'a' EQ 'b'


=cut</pre>
<p>$dict{ 'REV' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = reverse $a;
    my @ret;
    push @ret, ( $b );
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_b_c_substr">a b c SUBSTR</a></h2>
<pre>
      return the substring of 'c' starting at 'b' with the length of 'a'


=cut</pre>
<p>$dict{ 'SUBSTR' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my $c     = pop @{ $work1 };
    my @ret;
    push @ret, ( substr( $c, $b, $a ) );
    return \@ret, 3, 0;
};</p>
<p>
</p>
<h2><a name="a_uc">a UC</a></h2>
<pre>
      return 'a' in uppercase


=cut</pre>
<p>$dict{ 'UC' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, ( uc $a );
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_lc">a LC</a></h2>
<pre>
      return 'a' in lowercase


=cut</pre>
<p>$dict{ 'LC' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, ( lc $a );
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_ucfirst">a UCFIRST</a></h2>
<pre>
      return 'a' with the first letter in uppercase


=cut</pre>
<p>$dict{ 'UCFIRST' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, ( ucfirst $a );
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_lcfirst">a LCFIRST</a></h2>
<pre>
      return 'a' with the first letter in lowercase


=cut</pre>
<p>$dict{ 'LCFIRST' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, ( lcfirst $a );
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_b_split">a b SPLIT</a></h2>
<pre>
      return all splitted item of 'a' by the separator 'b' 
      'b' is a REGEX 
      !!! becare, if you need to use : as a regex, you need to backslash to prevent overlap with new dictionary entry
      !!! if the split match on the beginning of string,
      SPLIT return the matched value WITHOUT the empty string of the beginning


=cut</pre>
<p>$dict{ 'SPLIT' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @r     = grep /[^(^$)]/, split /$a/, $b;
    my @ret;
    push @ret, @r;
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b_spliti">a b SPLITI</a></h2>
<pre>
      return all splitted item of 'a' by the separator 'b' 
      'b' is a REGEX case insensitive
      !!! becare, if you need to use : as a regex, you need to backslash to prevent overlap with new dictionary entry
      !!! if the split match on the beginning of string,
      SPLIT return the matched value WITHOUT the empty string of the beginning


=cut</pre>
<p>$dict{ 'SPLITI' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @r     = grep /[^(^$)]/, split /$a/i, $b;
    my @ret;
    push @ret, @r;
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b_pat">a b PAT</a></h2>
<pre>
      return one or more occurance of 'b' in 'a' 
      'b' is a REGEX
      !!! becare, if you need to use : as a regex, you need to backslash to prevent overlap with new dictionary entry


=cut</pre>
<p>$dict{ 'PAT' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @r     = ( $b =~ m/$a/g );
    my @ret;
    push @ret, @r;
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b_pati">a b PATI</a></h2>
<pre>
      return one or more occurance of 'b' in 'a' 
      'b' is a REGEX case insensitive
      !!! becare, if you need to use : as a regex, you need to backslash to prevent overlap with new dictionary entry


=cut</pre>
<p>$dict{ 'PATI' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my @r     = ( $b =~ m/$a/ig );
    my @ret;
    push @ret, @r;
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b_tpat">a b TPAT</a></h2>
<pre>
      test if the pattern 'b' is in 'a' 
      'b' is a REGEX
      !!! becare, if you need to use : as a regex, you need to backslash to prevent overlap with new dictionary entry


=cut</pre>
<p>$dict{ 'TPAT' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my $r     = ( $b =~ m/$a/g );
    my @ret;
    push @ret, ( $r ? 1 : 0 );
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b_tpati">a b TPATI</a></h2>
<pre>
      test if the pattern 'b' is in 'a' 
      'b' is a REGEX
      !!! becare, if you need to use : as a regex, you need to backslash to prevent overlap with new dictionary entry


=cut</pre>
<p>$dict{ 'TPATI' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my $b     = pop @{ $work1 };
    my $r     = ( $b =~ m/$a/ig );
    my @ret;
    push @ret, ( $r ? 1 : 0 );
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b_c_spat">a b c SPAT</a></h2>
<pre>
      substitute the pattern 'b' by the pattern 'a'  in 'c'
      'b' and 'c' are a REGEX
      !!! becare, if you need to use : as a regex, you need to backslash to prevent overlap with new dictionary entry


=cut</pre>
<p>$dict{ 'SPAT' } = sub {
    my $work1   = shift;
    my $a       = pop @{ $work1 };
    my $b       = pop @{ $work1 };
    my $c       = pop @{ $work1 } || '';
    my $to_eval = qq{\$c =~ s/$b/$a/};
    eval( $to_eval );
    my @ret;
    push @ret, $c;
    return \@ret, 3, 0;
};</p>
<p>
</p>
<h2><a name="a_b_c_spatg">a b c SPATG</a></h2>
<pre>
      substitute the pattern 'b' by the pattern 'a'  in 'c' as many time as possible (g flag in REGEX)
      'b' and 'c' are a REGEX
      !!! becare, if you need to use : as a regex, you need to backslash to prevent overlap with new dictionary entry


=cut</pre>
<p>$dict{ 'SPATG' } = sub {
    my $work1   = shift;
    my $a       = pop @{ $work1 };
    my $b       = pop @{ $work1 };
    my $c       = pop @{ $work1 };
    my $to_eval = qq{\$c =~ s/$b/$a/g};
    eval( $to_eval );
    my @ret;
    push @ret, $c;
    return \@ret, 3, 0;
};</p>
<p>
</p>
<h2><a name="a_b_c_spati">a b c SPATI</a></h2>
<pre>
      substitute the pattern 'b' by the pattern 'a'  in 'c'case insensitive (i flag in REGEX)
      'b' and 'c' are a REGEX
      !!! becare, if you need to use : as a regex, you need to backslash to prevent overlap with new dictionary entry


=cut</pre>
<p>$dict{ 'SPATI' } = sub {
    my $work1   = shift;
    my $a       = pop @{ $work1 };
    my $b       = pop @{ $work1 };
    my $c       = pop @{ $work1 };
    my $to_eval = qq{\$c =~ s/$b/$a/i};
    eval( $to_eval );
    my @ret;
    push @ret, $c;
    return \@ret, 3, 0;
};</p>
<p>
</p>
<h2><a name="a_b_c_spatgi">a b c SPATGI</a></h2>
<pre>
      substitute the pattern 'b' by the pattern 'a'  in 'c' as many time as possible (g flag in REGEX)
      and case insensitive (1 flag in REGEX)
      'b' and 'c' are a REGEX
      !!! becare, if you need to use : as a regex, you need to backslash to prevent overlap with new dictionary entry


=cut</pre>
<p>$dict{ 'SPATGI' } = sub {
    my $work1   = shift;
    my $a       = pop @{ $work1 };
    my $b       = pop @{ $work1 };
    my $c       = pop @{ $work1 };
    my $to_eval = qq{\$c =~ s/$b/$a/ig};
    eval( $to_eval );
    my @ret;
    push @ret, $c;
    return \@ret, 3, 0;
};</p>
<p>
</p>
<h2><a name="a_____z_printf">a ... z PRINTF</a></h2>
<pre>
     use the format 'z' to print the value(s) on the stack
     7,3,/,10,3,/,%d %f,PRINTF -&gt; 2 3.333333
     see printf in perl


=cut</pre>
<p>$dict{ 'PRINTF' } = sub {</p>
<pre>
    <span class="keyword">my</span> <span class="variable">$work1</span>  <span class="operator">=</span> <span class="keyword">shift</span><span class="operator">;</span>
    <span class="keyword">my</span> <span class="variable">$format</span> <span class="operator">=</span> <span class="keyword">pop</span> <span class="variable">@</span><span class="operator">{</span> <span class="variable">$work1</span> <span class="operator">}</span><span class="operator">;</span>
    <span class="keyword">my</span> <span class="variable">@r</span>      <span class="operator">=</span> <span class="operator">(</span> <span class="variable">$format</span> <span class="operator">=~</span> <span class="regex">m/(%[^ ])/g</span> <span class="operator">);</span>
    <span class="keyword">my</span> <span class="variable">@var</span><span class="operator">;</span>
    <span class="keyword">for</span> <span class="operator">(</span> <span class="number">0</span> <span class="operator">..</span> <span class="variable">$#r</span> <span class="operator">)</span>
    <span class="operator">{</span>
        <span class="keyword">unshift</span> <span class="variable">@var</span><span class="operator">,</span> <span class="keyword">pop</span> <span class="variable">@</span><span class="operator">{</span> <span class="variable">$work1</span> <span class="operator">}</span><span class="operator">;</span>
    <span class="operator">}</span>
    <span class="keyword">my</span> <span class="variable">@ret</span><span class="operator">;</span>
    <span class="keyword">push</span> <span class="variable">@ret</span><span class="operator">,</span> <span class="keyword">sprintf</span> <span class="variable">$format</span><span class="operator">,</span> <span class="variable">@var</span><span class="operator">;</span>
    <span class="keyword">return</span> <span class="operator">\</span><span class="variable">@ret</span><span class="operator">,</span> <span class="number">2</span> <span class="operator">+</span> <span class="variable">$#r</span><span class="operator">,</span> <span class="number">0</span><span class="operator">;</span>
    <span class="operator">};</span>
</pre>
<p>
</p>
<h2><a name="a_b_pack">a b PACK</a></h2>
<pre>
      pack the value 'a' with the format 'b'
      2004,06,08,a4 a2 a2,PACK -&gt; 20040608
      see pack in perl


=cut</pre>
<p>$dict{ 'PACK' } = sub {
    my $work1  = shift;
    my $format = &quot; &quot; . ( pop( @{ $work1 } ) ) . &quot; &quot;;
    my @r      = ( $format =~ m/([a-zA-Z]\d*\s*)/g );
    my @var;
    for ( 0 .. $#r )
    {
        unshift @var, pop @{ $work1 };
    }
    my @ret;
    push @ret,, pack( $format, @var );
    return \@ret, 2 + $#r, 0;
};</p>
<p>
</p>
<h2><a name="a_b_unpack">a b UNPACK</a></h2>
<pre>
      unpack the value 'a' with the format 'b'
      20040608,a4 a2 a2,PACK -&gt; 2004,06,08
      see unpack in perl


=cut</pre>
<p>$dict{ 'UNPACK' } = sub {
    my $work1  = shift;
    my $format = pop @{ $work1 };
    my $var    = pop @{ $work1 };
    my @ret;
    push @ret, unpack( $format, $var );
    return \@ret, 2, 0;
};</p>
<p>
</p>
<h2><a name="a_b_isnum">a b ISNUM</a></h2>
<pre>
      test if top of the stack is a number
      return 1 if if it is a NUMBER otherwise return 0


=cut</pre>
<p>$dict{ 'ISNUM' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, ($a =~ /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/ ? 1 : 0);
    return \@ret, 0, 0;
};</p>
<p>
</p>
<h2><a name="a_b_isnumd">a b ISNUMD</a></h2>
<pre>
      test if top of the stack is a number
      delete the top element on the statck and return 1 if it is a NUMBER otherwise return 0


=cut</pre>
<p>$dict{ 'ISNUMD' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, ($a =~ /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/ ? 1 : 0);
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_b_isint">a b ISINT</a></h2>
<pre>
      test if top of the stack is a integer (natural number)
      return 1 if if it is a INTEGER otherwise return 0


=cut</pre>
<p>$dict{ 'ISINT' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, ($a =~ /^\d+$/ ? 1 : 0);
    return \@ret, 0, 0;
};</p>
<p>
</p>
<h2><a name="a_b_isintd">a b ISINTD</a></h2>
<pre>
      test if top of the stack is a integer (natural number)
      delete the top element on the statck and return 1 if it is a INTEGER otherwise return 0


=cut</pre>
<p>$dict{ 'ISINTD' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, ($a =~ /^\d+$/ ? 1 : 0);
    return \@ret, 1, 0;
};</p>
<p>
</p>
<h2><a name="a_b_ishex">a b ISHEX</a></h2>
<pre>
      test if top of the stack is a hexadecimal value (starting with 0x or 0X or # )
      return 1 if if it is a HEXADECIMAL otherwise return 0


=cut</pre>
<p>$dict{ 'ISHEX' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, ($a =~ /^(#|0x|0X)(\p{IsXDigit})+$/ ? 1 : 0);
    return \@ret, 0, 0;
};</p>
<p>
</p>
<h2><a name="a_b_ishexd">a b ISHEXD</a></h2>
<pre>
      test if top of the stack is a hexadecimal value (starting with 0x or 0X or # )
      delete the top element on the statck and return 1 if it is a HEXADECIMAL otherwise return 0


=cut</pre>
<p>$dict{ 'ISHEXD' } = sub {
    my $work1 = shift;
    my $a     = pop @{ $work1 };
    my @ret;
    push @ret, ($a =~ /^(#|0x|0X)(\p{IsXDigit})+$/ ? 1 : 0);
    return \@ret, 1, 0;
};</p>
<p>########################
# stack operators
########################</p>
<p>
</p>
<hr />
<h1><a name="stack_operators">STACK operators</a></h1>
<p>.</p>
<p>
</p>
<h2><a name="a_b_swap">a b SWAP</a></h2>
<pre>
        return 'b' 'a'</pre>
<p>
</p>
<h2><a name="a_b_over">a b OVER</a></h2>
<pre>
        return 'a' 'b' 'a'</pre>
<p>
</p>
<h2><a name="a_dup">a DUP</a></h2>
<pre>
        return 'a' 'a'</pre>
<p>
</p>
<h2><a name="a_b_ddup">a b DDUP</a></h2>
<pre>
        return 'a' 'b' 'a' 'b'</pre>
<p>
</p>
<h2><a name="a_b_c_rot">a b c ROT</a></h2>
<pre>
        return 'b' 'c' 'a'</pre>
<p>
</p>
<h2><a name="a_b_c_rrot">a b c RROT</a></h2>
<pre>
        return 'c' 'a' 'b'</pre>
<p>
</p>
<h2><a name="depth">DEPTH</a></h2>
<pre>
        return the number of elements on the stack</pre>
<p>
</p>
<h2><a name="a_b_pop">a b POP</a></h2>
<pre>
        remove the last element on the stack</pre>
<p>
</p>
<h2><a name="a_____z_popn">a ... z POPN</a></h2>
<pre>
        remove the 'z' last element(s) from the stack</pre>
<p>
</p>
<h2><a name="a_b_c_d_e_n_roll">a b c d e n ROLL</a></h2>
<pre>
        rotate the stack on 'n' element
        a,b,c,d,e,4,ROLL -&gt; a c d e b
        if n = 3 &lt;=&gt; ROT</pre>
<p>
</p>
<h2><a name="a_pick">a PICK</a></h2>
<pre>

        copy element from depth 'a' to the stack</pre>
<p>
</p>
<h2><a name="a_get">a GET</a></h2>
<pre>

        get (remove) element from depth 'a'
        and put on top of stack</pre>
<p>
</p>
<h2><a name="a_b_put">a b PUT</a></h2>
<pre>

        put element 'a' at the level 'b' of the stack
        if 'b' gretaer than the stack put at first place
        if 'b' &lt; 0 start to the reverse order of the stack</pre>
<p>
</p>
<h2><a name="a_b_del">a b DEL</a></h2>
<pre>

        delete 'b' element on the stack from level 'a'
        'a' and 'b' is get in absolute value</pre>
<p>
</p>
<h2><a name="a_find">a FIND</a></h2>
<pre>

        get the level of stack containing the exact value 'a'</pre>
<p>
</p>
<h2><a name="a_search">a SEARCH</a></h2>
<pre>

        get the level of stack containing the REGEX 'a'</pre>
<p>
</p>
<h2><a name="a_searchi">a SEARCHI</a></h2>
<pre>

        get the level of stack containing the REGEX 'a' (cas insensitive)</pre>
<p>
</p>
<h2><a name="a_keep">a KEEP</a></h2>
<pre>

        delete all element on the stack except the level 'a'
        if 'a' is deeper then stack, keep the stack untouched</pre>
<pre>

/Users/cpanrun/depot/main/contrib-patched/perl/CPAN/src/Parse-RPN/blib/html/site/lib/Parse/RPN.html