www.delorie.com/gnu/docs/calc/calc_192.html | search |
Buy the book! | |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
It is possible to attach a condition to a syntax rule. For example, the rules
foo ( # ) := ifoo(#1) :: integer(#1) foo ( # ) := gfoo(#1) |
will parse `foo(3)' as `ifoo(3)', but will parse
`foo(3.5)' and `foo(x)' as calls to gfoo
. Any
number of conditions may be attached; all must be true for the
rule to succeed. A condition is "true" if it evaluates to a
nonzero number. See section 11.10 Logical Operations, for a list of Calc
functions like integer
that perform logical tests.
The exact sequence of events is as follows: When Calc tries a rule, it first matches the pattern as usual. It then substitutes `#1', `#2', etc., in the conditions, if any. Next, the conditions are simplified and evaluated in order from left to right, as if by the a s algebra command (see section 11.3 Simplifying Formulas). Each result is true if it is a nonzero number, or an expression that can be proven to be nonzero (see section 7.6 Declarations). If the results of all conditions are true, the expression (such as `ifoo(#1)') has its `#'s substituted, and that is the result of the parse. If the result of any condition is false, Calc goes on to try the next rule in the syntax table.
Syntax rules also support let
conditions, which operate in
exactly the same way as they do in algebraic rewrite rules.
See section 11.11.5 Other Features of Rewrite Rules, for details. A let
condition is always true, but as a side effect it defines a
variable which can be used in later conditions, and also in the
expression after the `:=' sign:
foo ( # ) := hifoo(x) :: let(x := #1 + 0.5) :: dnumint(x) |
The dnumint
function tests if a value is numerically an
integer, i.e., either a true integer or an integer-valued float.
This rule will parse foo
with a half-integer argument,
like `foo(3.5)', to a call like `hifoo(4.)'.
The lefthand side of a syntax rule let
must be a simple
variable, not the arbitrary pattern that is allowed in rewrite
rules.
The matches
function is also treated specially in syntax
rule conditions (again, in the same way as in rewrite rules).
See section 11.11.10 Matching Commands. If the matching pattern contains
meta-variables, then those meta-variables may be used in later
conditions and in the result expression. The arguments to
matches
are not evaluated in this situation.
sum ( # , # ) := sum(#1,a,b,c) :: matches(#2, a=[b..c]) |
This is another way to implement the Maple mode sum
notation.
In this approach, we allow `#2' to equal the whole expression
`i=1..10'. Then, we use matches
to break it apart into
its components. If the expression turns out not to match the pattern,
the syntax rule will fail. Note that Z S always uses Calc's
normal language mode for editing expressions in syntax rules, so we
must use regular Calc notation for the interval `[b..c]' that
will correspond to the Maple mode interval `1..10'.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
webmaster donations bookstore | delorie software privacy |
Copyright © 2003 by The Free Software Foundation | Updated Jun 2003 |