mirrors
/
fop
mirror of https://github.com/apache/fop.git
Watch 1
Star 0
Fork 0
Code Issues 0 Releases 48 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1848 Commits
70 Branches
Tree: 807819bf42
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '807819bf42'
${ noResults }
fop/src/documentation/content/design/alt.design/properties/PropertyParser.html

PropertyParser.html 84KB
Raw Blame History

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038 
  1. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">

  2. <!-- Created by htmlize-0.67 in css mode. -->

  3. <html>

  4.   <head>

  5.     <title>PropertyParser.java</title>

  6.     <style type="text/css">

  7.     <!--

  8.       body {

  9.         color: #000000;

  10.         background-color: #faf0e6;

  11.       } /* default */

  12.       .jde-java-font-lock-number {

  13.         color: #bc8f8f;

  14.         background-color: #faf0e6;

  15.       } /* jde-java-font-lock-number-face */

  16.       .function-name {

  17.         color: #8b2323;

  18.         background-color: #faf0e6;

  19.       } /* font-lock-function-name-face */

  20.       .jde-java-font-lock-italic {

  21.         background-color: #faf0e6;

  22.         font-style: italic;

  23.       } /* jde-java-font-lock-italic-face */

  24.       .jde-java-font-lock-modifier {

  25.         color: #da70d6;

  26.         background-color: #faf0e6;

  27.       } /* jde-java-font-lock-modifier-face */

  28.       .keyword {

  29.         color: #8b0000;

  30.         background-color: #faf0e6;

  31.       } /* font-lock-keyword-face */

  32.       .variable-name {

  33.         color: #8b008b;

  34.         background-color: #faf0e6;

  35.       } /* font-lock-variable-name-face */

  36.       .string {

  37.         color: #008b00;

  38.         background-color: #faf0e6;

  39.       } /* font-lock-string-face */

  40.       .jde-java-font-lock-package {

  41.         color: #0000cd;

  42.         background-color: #faf0e6;

  43.       } /* jde-java-font-lock-package-face */

  44.       .jde-java-font-lock-constant {

  45.         color: #5f9ea0;

  46.         background-color: #faf0e6;

  47.       } /* jde-java-font-lock-constant-face */

  48.       .type {

  49.         color: #4682b4;

  50.         background-color: #faf0e6;

  51.       } /* font-lock-type-face */

  52.       .jde-java-font-lock-bold {

  53.         background-color: #faf0e6;

  54.         font-weight: bold;

  55.       } /* jde-java-font-lock-bold-face */

  56.       .jde-java-font-lock-doc-tag {

  57.         color: #008b00;

  58.         background-color: #faf0e6;

  59.       } /* jde-java-font-lock-doc-tag-face */

  60.       .comment {

  61.         color: #00008b;

  62.         background-color: #faf0e6;

  63.       } /* font-lock-comment-face */

  64.       .reference {

  65.         color: #cd0000;

  66.         background-color: #faf0e6;

  67.       } /* font-lock-reference-face */

  68.       a {

  69.         color: inherit;

  70.         background-color: inherit;

  71.         font: inherit;

  72.         text-decoration: inherit;

  73.       }

  74.       a:hover {

  75.         text-decoration: underline;

  76.       }

  77.     -->

  78.     </style>

  79.   </head>

  80.   <body>

  81.     <pre>

  82. <span class="comment">/*

  83.  * $Id$

  84.  * Copyright (C) 2001 The Apache Software Foundation. All rights reserved.

  85.  * For details on use and redistribution please refer to the

  86.  * LICENSE file included with these sources.

  87.  */</span>

  88. 

  89. <span class="keyword">package</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">expr</span>;

  90. 

  91. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">PropertyConsts</span>;

  92. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">properties</span>.<span class="type">Property</span>;

  93. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">PropNames</span>;

  94. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">FOTree</span>;

  95. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">FONode</span>;

  96. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="jde-java-font-lock-package">expr</span>.<span class="type">SystemFontFunction</span>;

  97. 

  98. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">PropertyValue</span>;

  99. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">PropertyValueList</span>;

  100. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Numeric</span>;

  101. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Literal</span>;

  102. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">NCName</span>;

  103. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Percentage</span>;

  104. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Ems</span>;

  105. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">IntegerType</span>;

  106. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Length</span>;

  107. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Time</span>;

  108. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Frequency</span>;

  109. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Angle</span>;

  110. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Bool</span>;

  111. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Auto</span>;

  112. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">None</span>;

  113. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Slash</span>;

  114. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">ColorType</span>;

  115. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">StringType</span>;

  116. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">MimeType</span>;

  117. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">UriType</span>;

  118. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="jde-java-font-lock-package">indirect</span>.<span class="type">Inherit</span>;

  119. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="jde-java-font-lock-package">indirect</span>.<span class="type">InheritedValue</span>;

  120. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="jde-java-font-lock-package">indirect</span>.<span class="type">FromParent</span>;

  121. <span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="jde-java-font-lock-package">indirect</span>.<span class="type">FromNearestSpecified</span>;

  122. 

  123. <span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">HashMap</span>;

  124. 

  125. <span class="comment">/**

  126.  * Class to parse XSL FO property expression.

  127.  * This class is heavily based on the expression parser in James Clark's

  128.  * XT, an XSLT processor.

  129.  *

  130.  * PropertyParser objects are re-usable.  The constructor simply creates the

  131.  * object.  To parse an expression, the public method &lt;i&gt;</span><span class="jde-java-font-lock-italic">Parse</span><span class="comment">&lt;/i&gt; is

  132.  * called.

  133.  */</span>

  134. <span class="jde-java-font-lock-modifier">public</span> <span class="keyword">class</span> <span class="function-name" id="PropertyParserClass">PropertyParser</span> <span class="keyword">extends</span> <span class="type">PropertyTokenizer</span> {

  135. 

  136.     <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="tag">tag</span> = &quot;<span class="string">$Name$</span>&quot;;

  137.     <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="revision">revision</span> = &quot;<span class="string">$Revision$</span>&quot;;

  138. 

  139.     <span class="comment">/** The FO tree which has initiated this parser */</span>

  140.     <span class="jde-java-font-lock-modifier">private</span> <span class="type">FOTree</span> <span class="variable-name" id="foTree">foTree</span>;

  141.     <span class="comment">/** The FONode which has initiated this parser */</span>

  142.     <span class="jde-java-font-lock-modifier">private</span> <span class="type">FONode</span> <span class="variable-name" id="node">node</span>;

  143. 

  144.     <span class="jde-java-font-lock-modifier">public</span> <span class="function-name" id="PropertyParser">PropertyParser</span>(<span class="type">FOTree</span> <span class="variable-name">foTree</span>) {

  145.         <span class="keyword">super</span>();

  146.         <span class="keyword">this</span>.foTree = foTree;

  147.     }

  148. 

  149.     <span class="comment">/**

  150.      * Parse the property expression described in the instance variables.

  151.      * 

  152.      * &lt;p&gt;The &lt;tt&gt;PropertyValue&lt;/tt&gt; returned by this function has the

  153.      * following characteristics:

  154.      * If the expression resolves to a single element that object is returned

  155.      * directly in an object which implements &lt;PropertyValue&lt;/tt&gt;.

  156.      *

  157.      * &lt;p&gt;If the expression cannot be resolved into a single object, the set

  158.      * to which it resolves is returned in a &lt;tt&gt;PropertyValueList&lt;/tt&gt; object

  159.      * (which itself implements &lt;tt&gt;PropertyValue&lt;/tt&gt;).

  160.      *

  161.      * &lt;p&gt;The &lt;tt&gt;PropertyValueList&lt;/tt&gt; contains objects whose corresponding

  162.      * elements in the original expression were separated by &lt;em&gt;</span><span class="jde-java-font-lock-italic">commas</span><span class="comment">&lt;/em&gt;.

  163.      *

  164.      * &lt;p&gt;Objects whose corresponding elements in the original expression

  165.      * were separated by spaces are composed into a sublist contained in

  166.      * another &lt;tt&gt;PropertyValueList&lt;/tt&gt;.  If all of the elements in the

  167.      * expression were separated by spaces, the returned

  168.      * &lt;tt&gt;PropertyValueList&lt;/tt&gt; will contain one element, a

  169.      * &lt;tt&gt;PropertyValueList&lt;/tt&gt; containing objects representing each of

  170.      * the space-separated elements in the original expression.

  171.      *

  172.      * &lt;p&gt;E.g., if a &lt;b&gt;</span><span class="jde-java-font-lock-bold">font-family</span><span class="comment">&lt;/b&gt; property is assigned the string

  173.      * &lt;em&gt;</span><span class="jde-java-font-lock-italic">Palatino, New Century Schoolbook, serif</span><span class="comment">&lt;/em&gt;, the returned value

  174.      * will look like this:

  175.      * &lt;pre&gt;

  176.      * PropertyValueList(NCName('Palatino')

  177.      *                   PropertyValueList(NCName('New')

  178.      *                                     NCName('Century')

  179.      *                                     NCName('Schoolbook') )

  180.      *                   NCName('serif') )

  181.      * &lt;/pre&gt;

  182.      * &lt;p&gt;If the property had been assigned the string

  183.      * &lt;em&gt;</span><span class="jde-java-font-lock-italic">Palatino, &quot;New Century Schoolbook&quot;, serif</span><span class="comment">&lt;/em&gt;, the returned value

  184.      * would look like this:

  185.      * &lt;pre&gt;

  186.      * PropertyValueList(NCName('Palatino')

  187.      *                   NCName('New Century Schoolbook')

  188.      *                   NCName('serif') )

  189.      * &lt;/pre&gt;

  190.      * &lt;p&gt;If a &lt;b&gt;</span><span class="jde-java-font-lock-bold">background-position</span><span class="comment">&lt;/b&gt; property is assigned the string

  191.      * &lt;em&gt;</span><span class="jde-java-font-lock-italic">top center</span><span class="comment">&lt;/em&gt;, the returned value will look like this:

  192.      * &lt;pre&gt;

  193.      * PropertyValueList(PropertyValueList(NCName('top')

  194.      *                                     NCName('center') ) )

  195.      * &lt;/pre&gt;

  196.      *

  197.      * &lt;p&gt;Note: If the property expression String is empty, a StringProperty

  198.      * object holding an empty String is returned.

  199.      * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">node</span><span class="comment"> - the &lt;tt&gt;FONode&lt;/tt&gt; for which the property expression

  200.      * is being resolved.

  201.      * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="property">property</span><span class="comment"> - an &lt;tt&gt;int&lt;/tt&gt; containing the property index.

  202.      * which the property expression is to be evaluated.

  203.      * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="expr">expr</span><span class="comment"> - the specified value (attribute on the xml element).

  204.      * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a PropertyValue holding the parsed result.

  205.      * </span><span class="jde-java-font-lock-doc-tag">@throws</span><span class="comment"> </span><span class="type">PropertyException</span><span class="comment"> if the &quot;expr&quot; cannot be parsed as a

  206.      * PropertyValue.

  207.      */</span>

  208.     <span class="jde-java-font-lock-modifier">public</span> <span class="type">PropertyValue</span> <span class="function-name" id="parse">parse</span>(<span class="type">FONode</span> <span class="variable-name">node</span>, <span class="type">int</span> <span class="variable-name">property</span>, <span class="type">String</span> <span class="variable-name">expr</span>)

  209.         <span class="keyword">throws</span> <span class="type">PropertyException</span>

  210.     {

  211.         <span class="comment">//System.out.println(&quot;-----Entering parse:&quot;

  212. </span>        <span class="comment">// + PropNames.getPropertyName(property) + &quot; &quot; + expr);

  213. </span>        <span class="jde-java-font-lock-modifier">synchronized</span> (<span class="keyword">this</span>) {

  214.             <span class="comment">// make sure this parser is available

  215. </span>            <span class="keyword">if</span> (getExpr() != <span class="jde-java-font-lock-constant" id="null">null</span>) <span class="comment">// the parser is currently active

  216. </span>                <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>

  217.                         (&quot;<span class="string">PropertyParser is currently active: </span>&quot; + getExpr());

  218.             initialize(property, expr);

  219.             <span class="keyword">this</span>.node = node;

  220.         }

  221. 

  222.         next();

  223.         <span class="keyword">if</span> (currentToken == <span class="jde-java-font-lock-constant" id="EOF">EOF</span>)

  224.             <span class="comment">// prop value is empty

  225. </span>            <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>

  226.                     (&quot;<span class="string">No token recognized in :</span>&quot; + expr + &quot;<span class="string">:</span>&quot;);

  227. 

  228.         <span class="type">PropertyValueList</span> <span class="variable-name" id="propList">propList</span> = <span class="keyword">new</span> <span class="type">PropertyValueList</span>(property);

  229.         <span class="keyword">while</span> (<span class="jde-java-font-lock-constant" id="true">true</span>) {

  230.             <span class="type">PropertyValue</span> <span class="variable-name" id="prop">prop</span> = parseAdditiveExpr();

  231.             <span class="keyword">if</span> (currentToken == <span class="jde-java-font-lock-constant">EOF</span>) {

  232.                 <span class="comment">// end of the expression - add to list and go

  233. </span>                <span class="keyword">if</span> (propList.size() != <span class="jde-java-font-lock-number">0</span>) {

  234.                     propList.add(prop);

  235.                     reset();

  236.                     <span class="keyword">return</span> propList;

  237.                 } <span class="keyword">else</span> { <span class="comment">// list is empty

  238. </span>                    reset();

  239.                     <span class="keyword">return</span> prop;

  240.                 }

  241.             }

  242.             <span class="comment">// throw away commas separating arguments.  These can occur

  243. </span>            <span class="comment">// in font-family and voice-family.  Commas are regarded here

  244. </span>            <span class="comment">// as separators of list and sublist elements.

  245. </span>            <span class="comment">// See 7.16.5 &quot;text-shadow&quot; in the 1.0 Recommendation for an

  246. </span>            <span class="comment">// example of sublists.

  247. </span>            <span class="keyword">if</span> (currentToken == <span class="jde-java-font-lock-constant" id="COMMA">COMMA</span>) {

  248.                 next();

  249.                 propList.add(prop);

  250.             } <span class="keyword">else</span> { <span class="comment">// whitespace separates list elements; make a sublist

  251. </span>                propList.add(parseSublist(prop));

  252.                 <span class="keyword">if</span> (currentToken == <span class="jde-java-font-lock-constant">EOF</span>) {

  253.                     reset();

  254.                     <span class="keyword">return</span> propList;

  255.                 }

  256.             }

  257.         }

  258.     }

  259. 

  260.     <span class="comment">/**

  261.      * &lt;p&gt;Parse a property values sublist - a list of whitespace separated

  262.      * &lt;tt&gt;PropertyValue&lt;/tt&gt;s.

  263.      * &lt;p&gt;

  264.      * Property value expressions for various properties may contain lists

  265.      * of values, which may be separated by whitespace or by commas.  See,

  266.      * e.g., 7.6.17 &quot;voice-family&quot; and 7.8.2 &quot;font-family&quot;.  The shorthands

  267.      * may also contain lists of elements, generally (or exclusively)

  268.      * whitespace separated.  7.16.5 &quot;text-shadow&quot; allows whitespace

  269.      * separated length doubles or triples to be specified for individual

  270.      * shadow effects, with multiple shadow effects, each separated by

  271.      * commmas.

  272.      * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="initialValue">initialValue</span><span class="comment"> a &lt;tt&gt;PropertyValue&lt;/tt&gt; to assign as the initial

  273.      * value of the sublist.  The detection of this value, which is

  274.      * whitespace separated from a subsequent value,  has been the

  275.      * trigger for the creation of the sublist.

  276.      * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a &lt;tt&gt;PropertyValueList&lt;/tt&gt; containing the sublist.  The

  277.      * indicatior for the end of the sublist is the end of the expression,

  278.      * or a comma.

  279.      */</span>

  280.     <span class="type">PropertyValueList</span> <span class="function-name" id="parseSublist">parseSublist</span>(<span class="type">PropertyValue</span> <span class="variable-name">initialValue</span>)

  281.         <span class="keyword">throws</span> <span class="type">PropertyException</span>

  282.     {

  283.         <span class="type">PropertyValueList</span> <span class="variable-name" id="sublist">sublist</span> = <span class="keyword">new</span> <span class="type">PropertyValueList</span>(property);

  284.         sublist.add(initialValue);

  285.         <span class="keyword">while</span> (<span class="jde-java-font-lock-constant">true</span>) {

  286.             <span class="type">PropertyValue</span> <span class="variable-name">prop</span> = parseAdditiveExpr();

  287.             <span class="keyword">if</span> (currentToken == <span class="jde-java-font-lock-constant">EOF</span>) {

  288.                 <span class="comment">// end of the expression - add to sublist and go

  289. </span>                sublist.add(prop);

  290.                 <span class="keyword">return</span> sublist;

  291.             }

  292.             <span class="comment">// Comma separates next element - end of sublist

  293. </span>            <span class="keyword">if</span> (currentToken == <span class="jde-java-font-lock-constant">COMMA</span>) {

  294.                 next();

  295.                 sublist.add(prop);

  296.                 <span class="keyword">return</span> sublist;

  297.             } <span class="keyword">else</span> { <span class="comment">// whitespace separates next elements; add to sublist

  298. </span>                sublist.add(prop);

  299.             }

  300.         }

  301.     }

  302. 

  303.     <span class="comment">/**

  304.      * Reset the parser by resetting the tokenizer to null (or equivalent)

  305.      * values.

  306.      */</span>

  307.     <span class="jde-java-font-lock-modifier">public</span> <span class="type">void</span> <span class="function-name" id="resetParser">resetParser</span>() {

  308.         <span class="jde-java-font-lock-modifier">synchronized</span> (<span class="keyword">this</span>) {

  309.             <span class="comment">//elementsSeen = 0;

  310. </span>            <span class="comment">//restrictedValueFunctSeen = null;

  311. </span>            reset();

  312.         }

  313.     }

  314. 

  315.     <span class="comment">/**

  316.      * Generate an arithmetic error string.

  317.      * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> arithmetic error message.

  318.      */</span>

  319.     <span class="jde-java-font-lock-modifier">private</span> <span class="type">String</span> <span class="function-name" id="arithErrorStr">arithErrorStr</span>() {

  320.         <span class="keyword">return</span> &quot;<span class="string">Arithmetic operator not followed by Numeric or integer: </span>&quot;

  321.                 + getExpr();

  322.     }

  323. 

  324. 

  325.     <span class="comment">/**

  326.      * Generate an function numeric argument error string.

  327.      * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> function numeric argument error message.

  328.      */</span>

  329.     <span class="jde-java-font-lock-modifier">private</span> <span class="type">String</span> <span class="function-name" id="funcNumericErrorStr">funcNumericErrorStr</span>() {

  330.         <span class="keyword">return</span> &quot;<span class="string">Function requires Numeric or integer argument: </span>&quot;

  331.                 + getExpr();

  332.     }

  333. 

  334.     <span class="comment">/**

  335.      * Try to parse an addition or subtraction expression and return the

  336.      * resulting PropertyValue.

  337.      */</span>

  338.     <span class="jde-java-font-lock-modifier">private</span> <span class="type">PropertyValue</span> <span class="function-name" id="parseAdditiveExpr">parseAdditiveExpr</span>() <span class="keyword">throws</span> <span class="type">PropertyException</span> {

  339.         <span class="comment">// Evaluate and put result on the operand stack

  340. </span>        <span class="comment">//System.out.println(&quot;parseAdd&quot;);

  341. </span>        <span class="type">PropertyValue</span> <span class="variable-name">prop</span> = parseMultiplicativeExpr();

  342.         <span class="type">PropertyValue</span> <span class="variable-name" id="pv">pv</span>;

  343.         <span class="reference">outer</span>:

  344.         <span class="keyword">for</span> (; ; ) {

  345.             <span class="reference">inner</span>:

  346.             <span class="keyword">switch</span> (prop.getType()) {

  347.             <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>: {

  348.                 <span class="keyword">switch</span> (currentToken) {

  349.                 <span class="keyword">case</span> <span class="reference">PLUS</span>:

  350.                     next();

  351.                     pv = parseMultiplicativeExpr();

  352.                     <span class="keyword">switch</span> (pv.getType()) {

  353.                     <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:

  354.                         ((<span class="type">Numeric</span>)prop).add((<span class="type">Numeric</span>)pv);

  355.                         <span class="keyword">break</span> <span class="reference">inner</span>;

  356.                     <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:

  357.                         ((<span class="type">Numeric</span>)prop).add((<span class="type">double</span>)

  358.                                             (((<span class="type">IntegerType</span>)pv).getInt()));

  359.                         <span class="keyword">break</span> <span class="reference">inner</span>;

  360.                     <span class="keyword">default</span>:

  361.                         <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(arithErrorStr());

  362.                     }

  363.                 <span class="keyword">case</span> <span class="reference">MINUS</span>:

  364.                     next();

  365.                     pv = parseMultiplicativeExpr();

  366.                     <span class="keyword">switch</span> (pv.getType()) {

  367.                     <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:

  368.                         ((<span class="type">Numeric</span>)prop).subtract((<span class="type">Numeric</span>)pv);

  369.                         <span class="keyword">break</span> <span class="reference">inner</span>;

  370.                     <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:

  371.                         ((<span class="type">Numeric</span>)prop).subtract((<span class="type">double</span>)

  372.                                              (((<span class="type">IntegerType</span>)pv).getInt()));

  373.                         <span class="keyword">break</span> <span class="reference">inner</span>;

  374.                     <span class="keyword">default</span>:

  375.                         <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(arithErrorStr());

  376.                     }

  377.                 <span class="keyword">default</span>:

  378.                     <span class="keyword">break</span> <span class="reference">outer</span>;

  379.                 }

  380.             }

  381.             <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>: {

  382.                 <span class="type">int</span> <span class="variable-name" id="intVal">intVal</span> = ((<span class="type">IntegerType</span>)prop).getInt();

  383.                 <span class="keyword">switch</span> (currentToken) {

  384.                 <span class="keyword">case</span> <span class="reference">PLUS</span>:

  385.                     next();

  386.                     pv = parseMultiplicativeExpr();

  387.                     <span class="keyword">switch</span> (pv.getType()) {

  388.                     <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:

  389.                         prop = ((<span class="type">Numeric</span>)pv).add((<span class="type">double</span>)intVal);

  390.                         <span class="keyword">break</span> <span class="reference">inner</span>;

  391.                     <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:

  392.                         ((<span class="type">IntegerType</span>)prop).setInt(intVal +

  393.                                             ((<span class="type">IntegerType</span>)pv).getInt());

  394.                         <span class="keyword">break</span> <span class="reference">inner</span>;

  395.                     <span class="keyword">default</span>:

  396.                         <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(arithErrorStr());

  397.                     }

  398.                 <span class="keyword">case</span> <span class="reference">MINUS</span>:

  399.                     next();

  400.                     pv = parseMultiplicativeExpr();

  401.                     <span class="keyword">switch</span> (pv.getType()) {

  402.                     <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:

  403.                         ((<span class="type">Numeric</span>)pv).add((<span class="type">double</span>)(-intVal));

  404.                         prop = ((<span class="type">Numeric</span>)pv).negate();

  405.                         <span class="keyword">break</span> <span class="reference">inner</span>;

  406.                     <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:

  407.                         ((<span class="type">IntegerType</span>)prop).setInt(intVal +

  408.                                             ((<span class="type">IntegerType</span>)pv).getInt());

  409.                         <span class="keyword">break</span> <span class="reference">inner</span>;

  410.                     <span class="keyword">default</span>:

  411.                         <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(arithErrorStr());

  412.                     }

  413.                 <span class="keyword">default</span>:

  414.                     <span class="keyword">break</span> <span class="reference">outer</span>;

  415.                 }

  416.             }

  417.             <span class="keyword">default</span>:

  418.                 <span class="keyword">break</span> <span class="reference">outer</span>;

  419.             }

  420.         }

  421.         <span class="keyword">return</span> prop;

  422.     }

  423. 

  424.     <span class="comment">/**

  425.      * Try to parse a multiply, divide or modulo expression and return

  426.      * the resulting PropertyValue.

  427.      */</span>

  428.     <span class="jde-java-font-lock-modifier">private</span> <span class="type">PropertyValue</span> <span class="function-name" id="parseMultiplicativeExpr">parseMultiplicativeExpr</span>() <span class="keyword">throws</span> <span class="type">PropertyException</span> {

  429.         <span class="comment">//System.out.println(&quot;parseMult&quot;);

  430. </span>        <span class="type">PropertyValue</span> <span class="variable-name">prop</span> = parseUnaryExpr();

  431.         <span class="type">PropertyValue</span> <span class="variable-name">pv</span>;

  432.         <span class="reference">outer</span>:

  433.         <span class="comment">// Outer loop exists to handle a sequence of multiplicative operations

  434. </span>        <span class="comment">// e.g. 5 * 4 / 2

  435. </span>        <span class="comment">// break outer; will terminate the multiplicative expression parsing

  436. </span>        <span class="comment">// break inner; will look for another trailing multiplicative

  437. </span>        <span class="comment">// operator.

  438. </span>        <span class="keyword">for</span> (; ; ) {

  439.             <span class="reference">inner</span>:

  440.             <span class="keyword">switch</span> (prop.getType()) {

  441.             <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:

  442.                 <span class="keyword">switch</span> (currentToken) {

  443.                 <span class="keyword">case</span> <span class="reference">DIV</span>:

  444.                     next();

  445.                     pv = parseUnaryExpr();

  446.                     <span class="keyword">switch</span> (pv.getType()) {

  447.                     <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:

  448.                         ((<span class="type">Numeric</span>)prop).divide

  449.                                         ((<span class="type">double</span>)(((<span class="type">IntegerType</span>)pv).getInt()));

  450.                         <span class="keyword">break</span> <span class="reference">inner</span>;

  451.                     <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:

  452.                         ((<span class="type">Numeric</span>)prop).divide((<span class="type">Numeric</span>)pv);

  453.                         <span class="keyword">break</span> <span class="reference">inner</span>;

  454.                     <span class="keyword">default</span>:

  455.                         <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(arithErrorStr());

  456.                     }

  457.                 <span class="keyword">case</span> <span class="reference">MOD</span>:

  458.                     next();

  459.                     pv = parseUnaryExpr();

  460.                     <span class="keyword">switch</span> (pv.getType()) {

  461.                     <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:

  462.                         ((<span class="type">Numeric</span>)prop).mod

  463.                                         ((<span class="type">double</span>)(((<span class="type">IntegerType</span>)pv).getInt()));

  464.                         <span class="keyword">break</span> <span class="reference">inner</span>;

  465.                     <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:

  466.                         ((<span class="type">Numeric</span>)prop).mod((<span class="type">Numeric</span>)pv);

  467.                         <span class="keyword">break</span> <span class="reference">inner</span>;

  468.                     <span class="keyword">default</span>:

  469.                         <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(arithErrorStr());

  470.                     }

  471.                 <span class="keyword">case</span> <span class="reference">MULTIPLY</span>:

  472.                     next();

  473.                     pv = parseUnaryExpr();

  474.                     <span class="keyword">switch</span> (pv.getType()) {

  475.                     <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:

  476.                         ((<span class="type">Numeric</span>)prop).multiply

  477.                                         ((<span class="type">double</span>)(((<span class="type">IntegerType</span>)pv).getInt()));

  478.                         <span class="keyword">break</span> <span class="reference">inner</span>;

  479.                     <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:

  480.                         ((<span class="type">Numeric</span>)prop).multiply((<span class="type">Numeric</span>)pv);

  481.                         <span class="keyword">break</span> <span class="reference">inner</span>;

  482.                     <span class="keyword">default</span>:

  483.                         <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(arithErrorStr());

  484.                     }

  485.                 <span class="keyword">default</span>:

  486.                     <span class="keyword">break</span> <span class="reference">outer</span>;

  487.                 }

  488.                 <span class="comment">// N.B. The above case cannot fall through to here

  489. </span>            <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:

  490.                 <span class="comment">// This code treats all multiplicative operations as implicit

  491. </span>                <span class="comment">// operations on doubles.  It might be reasonable to allow

  492. </span>                <span class="comment">// an integer multiply.

  493. </span>                <span class="type">int</span> <span class="variable-name">intVal</span> = ((<span class="type">IntegerType</span>)prop).getInt();

  494.                 <span class="keyword">switch</span> (currentToken) {

  495.                 <span class="keyword">case</span> <span class="reference">DIV</span>:

  496.                     next();

  497.                     pv = parseUnaryExpr();

  498.                     <span class="keyword">switch</span> (pv.getType()) {

  499.                     <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:

  500.                         prop = <span class="keyword">new</span> <span class="type">Numeric</span>(property,

  501.                             (<span class="type">double</span>)intVal / ((<span class="type">IntegerType</span>)pv).getInt());

  502.                         <span class="keyword">break</span> <span class="reference">inner</span>;

  503.                     <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:

  504.                         prop = (<span class="keyword">new</span> <span class="type">Numeric</span>(property, (<span class="type">double</span>)intVal))

  505.                                                         .divide((<span class="type">Numeric</span>)pv);

  506.                         <span class="keyword">break</span> <span class="reference">inner</span>;

  507.                     <span class="keyword">default</span>:

  508.                         <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(arithErrorStr());

  509.                     }

  510.                 <span class="keyword">case</span> <span class="reference">MOD</span>:

  511.                     next();

  512.                     pv = parseUnaryExpr();

  513.                     <span class="keyword">switch</span> (pv.getType()) {

  514.                     <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:

  515.                         prop = <span class="keyword">new</span> <span class="type">Numeric</span>(property,

  516.                                 ((<span class="type">double</span>)intVal) % ((<span class="type">IntegerType</span>)pv).getInt());

  517.                         <span class="keyword">break</span> <span class="reference">inner</span>;

  518.                     <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:

  519.                         prop = (<span class="keyword">new</span> <span class="type">Numeric</span>(property, (<span class="type">double</span>)intVal))

  520.                                                         .mod((<span class="type">Numeric</span>)pv);

  521.                         <span class="keyword">break</span> <span class="reference">inner</span>;

  522.                     <span class="keyword">default</span>:

  523.                         <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(arithErrorStr());

  524.                     }

  525.                 <span class="keyword">case</span> <span class="reference">MULTIPLY</span>:

  526.                     next();

  527.                     pv = parseUnaryExpr();

  528.                     <span class="keyword">switch</span> (pv.getType()) {

  529.                     <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:

  530.                         prop = <span class="keyword">new</span> <span class="type">Numeric</span>(property,

  531.                             ((<span class="type">double</span>)intVal) * ((<span class="type">IntegerType</span>)pv).getInt());

  532.                         <span class="keyword">break</span> <span class="reference">inner</span>;

  533.                     <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:

  534.                         prop = (<span class="keyword">new</span> <span class="type">Numeric</span>(property, (<span class="type">double</span>)intVal))

  535.                                                    .multiply((<span class="type">Numeric</span>)pv);

  536.                         <span class="keyword">break</span> <span class="reference">inner</span>;

  537.                     <span class="keyword">default</span>:

  538.                         <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(arithErrorStr());

  539.                     }

  540.                 <span class="keyword">default</span>:

  541.                     <span class="keyword">break</span> <span class="reference">outer</span>;

  542.                 }

  543.             <span class="keyword">default</span>:

  544.                 <span class="keyword">break</span> <span class="reference">outer</span>;

  545.             }

  546.         }

  547.         <span class="keyword">return</span> prop;

  548.     }

  549. 

  550.     <span class="comment">/**

  551.      * Try to parse a unary minus expression and return the

  552.      * resulting PropertyValue.

  553.      */</span>

  554.     <span class="jde-java-font-lock-modifier">private</span> <span class="type">PropertyValue</span> <span class="function-name" id="parseUnaryExpr">parseUnaryExpr</span>() <span class="keyword">throws</span> <span class="type">PropertyException</span> {

  555.         <span class="comment">//System.out.println(&quot;Unary entry&quot;);

  556. </span>        <span class="keyword">if</span> (currentToken == <span class="jde-java-font-lock-constant" id="MINUS">MINUS</span>) {

  557.             next();

  558.             <span class="type">PropertyValue</span> <span class="variable-name">pv</span> = parseUnaryExpr();

  559.             <span class="keyword">switch</span> (pv.getType()) {

  560.             <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:

  561.                 <span class="keyword">return</span> ((<span class="type">Numeric</span>)pv).negate();

  562.             <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:

  563.                 ((<span class="type">IntegerType</span>)pv).setInt( -((<span class="type">IntegerType</span>)pv).getInt());

  564.                 <span class="keyword">return</span> pv;

  565.             <span class="keyword">default</span>:

  566.                 <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(arithErrorStr());

  567.             }

  568.         }

  569.         <span class="keyword">return</span> parsePrimaryExpr();

  570.     }

  571. 

  572. 

  573.     <span class="comment">/**

  574.      * Checks that the current token is a right parenthesis

  575.      * and throws an exception if this isn't the case.

  576.      */</span>

  577.     <span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">void</span> <span class="function-name" id="expectRpar">expectRpar</span>() <span class="keyword">throws</span> <span class="type">PropertyException</span> {

  578.         <span class="keyword">if</span> (currentToken != <span class="jde-java-font-lock-constant" id="RPAR">RPAR</span>)

  579.             <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">expected )</span>&quot;);

  580.         next();

  581.     }

  582. 

  583.     <span class="comment">/**

  584.      * Try to parse a primary expression and return the

  585.      * resulting PropertyValue.

  586.      * A primary expression is either a parenthesized expression or an

  587.      * expression representing a primitive PropertyValue datatype, such as a

  588.      * string literal, an NCname, a number or a unit expression, or a

  589.      * function call expression.

  590.      */</span>

  591.     <span class="jde-java-font-lock-modifier">private</span> <span class="type">PropertyValue</span> <span class="function-name" id="parsePrimaryExpr">parsePrimaryExpr</span>() <span class="keyword">throws</span> <span class="type">PropertyException</span> {

  592.         <span class="type">PropertyValue</span> <span class="variable-name">prop</span>;

  593.         <span class="comment">//System.out.println(&quot;Primary currentToken:&quot; + currentToken + &quot; &quot;

  594. </span>        <span class="comment">//                   + currentTokenValue);

  595. </span>        <span class="keyword">switch</span> (currentToken) {

  596.         <span class="keyword">case</span> <span class="reference">LPAR</span>:

  597.             next();

  598.             prop = parseAdditiveExpr();

  599.             expectRpar();

  600.             <span class="comment">// Do this here, rather than breaking, because expectRpar()

  601. </span>            <span class="comment">// consumes the right parenthesis and calls next().

  602. </span>            <span class="keyword">return</span> prop;

  603. 

  604.         <span class="keyword">case</span> <span class="reference">LITERAL</span>:

  605.             prop = <span class="keyword">new</span> <span class="type">Literal</span>(property, currentTokenValue);

  606.             <span class="keyword">break</span>;

  607. 

  608.         <span class="keyword">case</span> <span class="reference">NCNAME</span>:

  609.             <span class="comment">// Interpret this in context of the property or do it later?

  610. </span>            prop = <span class="keyword">new</span> <span class="type">NCName</span>(property, currentTokenValue);

  611.             <span class="keyword">break</span>;

  612. 

  613.         <span class="keyword">case</span> <span class="reference">FLOAT</span>:

  614.             <span class="comment">// Do I need to differentiate here between floats and integers?

  615. </span>            prop = <span class="keyword">new</span> <span class="type">Numeric</span>

  616.                     (property, Double.parseDouble(currentTokenValue));

  617.             <span class="keyword">break</span>;

  618. 

  619.         <span class="keyword">case</span> <span class="reference">INTEGER</span>:

  620.             prop = <span class="keyword">new</span> <span class="type">IntegerType</span>

  621.                     (property, Integer.parseInt(currentTokenValue));

  622.             <span class="keyword">break</span>;

  623. 

  624.         <span class="keyword">case</span> <span class="reference">PERCENT</span>:

  625.             <span class="comment">/*

  626.              * Generate a Percentage object with the percentage number.

  627.              * The constructor converts this to a straight multiplicative

  628.              * factor by dividing by 100.

  629.              */</span>

  630.             prop = Percentage.makePercentage

  631.                     (property, Double.parseDouble(currentTokenValue));

  632.             <span class="keyword">break</span>;

  633. 

  634.         <span class="keyword">case</span> <span class="reference">ABSOLUTE_LENGTH</span>:

  635.             prop = Length.makeLength(property,

  636.                               Double.parseDouble(currentTokenValue),

  637.                               currentUnit);

  638.             <span class="keyword">break</span>;

  639.         <span class="keyword">case</span> <span class="reference">TIME</span>:

  640.             prop = <span class="keyword">new</span> <span class="type">Time</span>(property, currentUnit,

  641.                             Double.parseDouble(currentTokenValue));

  642.             <span class="keyword">break</span>;

  643.         <span class="keyword">case</span> <span class="reference">FREQ</span>:

  644.             prop = <span class="keyword">new</span> <span class="type">Frequency</span>(property, currentUnit,

  645.                                  Double.parseDouble(currentTokenValue));

  646.             <span class="keyword">break</span>;

  647.         <span class="keyword">case</span> <span class="reference">ANGLE</span>:

  648.             prop = <span class="keyword">new</span> <span class="type">Angle</span>(property, currentUnit,

  649.                              Double.parseDouble(currentTokenValue));

  650.             <span class="keyword">break</span>;

  651.         <span class="keyword">case</span> <span class="reference">RELATIVE_LENGTH</span>:

  652.             prop = Ems.makeEms(node, property,

  653.                                Double.parseDouble(currentTokenValue));

  654.             <span class="keyword">break</span>;

  655. 

  656.         <span class="keyword">case</span> <span class="reference">COLORSPEC</span>:

  657.             prop = <span class="keyword">new</span> <span class="type">ColorType</span>(property, currentTokenValue);

  658.             <span class="keyword">break</span>;

  659. 

  660.         <span class="keyword">case</span> <span class="reference">BOOL</span>:

  661.             prop = <span class="keyword">new</span> <span class="type">Bool</span>(property, currentTokenValue);

  662.             <span class="keyword">break</span>;

  663. 

  664.         <span class="keyword">case</span> <span class="reference">AUTO</span>:

  665.             prop = <span class="keyword">new</span> <span class="type">Auto</span>(property);

  666.             <span class="keyword">break</span>;

  667. 

  668.         <span class="keyword">case</span> <span class="reference">NONE</span>:

  669.             prop = <span class="keyword">new</span> <span class="type">None</span>(property);

  670.             <span class="keyword">break</span>;

  671. 

  672.         <span class="keyword">case</span> <span class="reference">INHERIT</span>:

  673.             prop = <span class="keyword">new</span> <span class="type">Inherit</span>(property);

  674.             <span class="comment">//throw new PropertyException(&quot;INHERIT not supported&quot;);

  675. </span>            <span class="keyword">break</span>;

  676. 

  677.         <span class="keyword">case</span> <span class="reference">URI</span>:

  678.             prop = <span class="keyword">new</span> <span class="type">UriType</span>(property, currentTokenValue);

  679.             <span class="keyword">break</span>;

  680. 

  681.         <span class="keyword">case</span> <span class="reference">MIMETYPE</span>:

  682.             prop = <span class="keyword">new</span> <span class="type">MimeType</span>(property, currentTokenValue);

  683.             <span class="keyword">break</span>;

  684. 

  685.         <span class="keyword">case</span> <span class="reference">SLASH</span>:

  686.             prop = <span class="keyword">new</span> <span class="type">Slash</span>(property);

  687.             <span class="keyword">break</span>;

  688. 

  689.         <span class="keyword">case</span> <span class="reference">FUNCTION_LPAR</span>: {

  690.             <span class="comment">// N.B. parseArgs() invokes expectRpar at the end of argument

  691. </span>            <span class="comment">// processing, so, like LPAR processing, next() is not called

  692. </span>            <span class="comment">// and the return from this method must be premature

  693. </span>            prop = <span class="jde-java-font-lock-constant">null</span>;

  694.             <span class="type">int</span> <span class="variable-name" id="funcType">funcType</span> = PropertyValue.<span class="jde-java-font-lock-constant" id="NO_TYPE">NO_TYPE</span>;

  695.             <span class="type">String</span> <span class="variable-name" id="function">function</span> = currentTokenValue;

  696.             next();

  697.             <span class="keyword">do</span> {

  698.                 <span class="comment">// Numeric functions

  699. </span>                <span class="keyword">if</span> (function.equals(&quot;<span class="string">floor</span>&quot;)) {

  700.                     <span class="type">PropertyValue</span>[] <span class="variable-name" id="args">args</span> = parseArgs(<span class="jde-java-font-lock-number">1</span>);

  701.                     <span class="keyword">switch</span> (args[<span class="jde-java-font-lock-number">0</span>].getType()) {

  702.                     <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:

  703.                         args[<span class="jde-java-font-lock-number">0</span>] =

  704.                             <span class="keyword">new</span> <span class="type">Numeric</span>

  705.                                 (property, ((<span class="type">IntegerType</span>)args[<span class="jde-java-font-lock-number">0</span>]).getInt());

  706.                     <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:

  707.                         prop = <span class="keyword">new</span> <span class="type">Numeric</span>

  708.                                 (property, ((<span class="type">Numeric</span>)args[<span class="jde-java-font-lock-number">0</span>]).floor());

  709.                         <span class="keyword">break</span>;

  710.                     <span class="keyword">default</span>:

  711.                         <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(funcNumericErrorStr());

  712.                     }

  713.                     <span class="keyword">break</span>;

  714.                 }

  715.                 <span class="keyword">if</span> (function.equals(&quot;<span class="string">ceiling</span>&quot;)) {

  716.                     <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">1</span>);

  717.                     <span class="keyword">switch</span> (args[<span class="jde-java-font-lock-number">0</span>].getType()) {

  718.                     <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:

  719.                         args[<span class="jde-java-font-lock-number">0</span>] =

  720.                             <span class="keyword">new</span> <span class="type">Numeric</span>

  721.                                 (property, ((<span class="type">IntegerType</span>)args[<span class="jde-java-font-lock-number">0</span>]).getInt());

  722.                     <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:

  723.                         prop = <span class="keyword">new</span> <span class="type">Numeric</span>

  724.                                 (property, ((<span class="type">Numeric</span>)args[<span class="jde-java-font-lock-number">0</span>]).ceiling());

  725.                         <span class="keyword">break</span>;

  726.                     <span class="keyword">default</span>:

  727.                         <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(funcNumericErrorStr());

  728.                     }

  729.                     <span class="keyword">break</span>;

  730.                 }

  731.                 <span class="keyword">if</span> (function.equals(&quot;<span class="string">round</span>&quot;)) {

  732.                     <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">1</span>);

  733.                     <span class="keyword">switch</span> (args[<span class="jde-java-font-lock-number">0</span>].getType()) {

  734.                     <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:

  735.                         args[<span class="jde-java-font-lock-number">0</span>] =

  736.                             <span class="keyword">new</span> <span class="type">Numeric</span>

  737.                                 (property, ((<span class="type">IntegerType</span>)args[<span class="jde-java-font-lock-number">0</span>]).getInt());

  738.                     <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:

  739.                         prop = <span class="keyword">new</span> <span class="type">Numeric</span>

  740.                                 (property, ((<span class="type">Numeric</span>)args[<span class="jde-java-font-lock-number">0</span>]).round());

  741.                         <span class="keyword">break</span>;

  742.                     <span class="keyword">default</span>:

  743.                         <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(funcNumericErrorStr());

  744.                     }

  745.                     <span class="keyword">break</span>;

  746.                 }

  747.                 <span class="keyword">if</span> (function.equals(&quot;<span class="string">min</span>&quot;)) {

  748.                     <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">2</span>);

  749.                     <span class="keyword">switch</span> (args[<span class="jde-java-font-lock-number">0</span>].getType()) {

  750.                     <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:

  751.                         args[<span class="jde-java-font-lock-number">0</span>] =

  752.                             <span class="keyword">new</span> <span class="type">Numeric</span>

  753.                                 (property, ((<span class="type">IntegerType</span>)args[<span class="jde-java-font-lock-number">0</span>]).getInt());

  754.                     <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:

  755.                         prop = ((<span class="type">Numeric</span>)args[<span class="jde-java-font-lock-number">0</span>]).min((<span class="type">Numeric</span>)args[<span class="jde-java-font-lock-number">1</span>]);

  756.                         <span class="keyword">break</span>;

  757.                     <span class="keyword">default</span>:

  758.                         <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(funcNumericErrorStr());

  759.                     }

  760.                     <span class="keyword">break</span>;

  761.                 }

  762.                 <span class="keyword">if</span> (function.equals(&quot;<span class="string">max</span>&quot;)) {

  763.                     <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">2</span>);

  764.                     <span class="keyword">switch</span> (args[<span class="jde-java-font-lock-number">0</span>].getType()) {

  765.                     <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:

  766.                         args[<span class="jde-java-font-lock-number">0</span>] =

  767.                             <span class="keyword">new</span> <span class="type">Numeric</span>

  768.                                 (property, ((<span class="type">IntegerType</span>)args[<span class="jde-java-font-lock-number">0</span>]).getInt());

  769.                     <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:

  770.                         prop = ((<span class="type">Numeric</span>)args[<span class="jde-java-font-lock-number">0</span>]).max((<span class="type">Numeric</span>)args[<span class="jde-java-font-lock-number">1</span>]);

  771.                         <span class="keyword">break</span>;

  772.                     <span class="keyword">default</span>:

  773.                         <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(funcNumericErrorStr());

  774.                     }

  775.                     <span class="keyword">break</span>;

  776.                 }

  777.                 <span class="keyword">if</span> (function.equals(&quot;<span class="string">abs</span>&quot;)) {

  778.                     <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">1</span>);

  779.                     <span class="keyword">switch</span> (args[<span class="jde-java-font-lock-number">0</span>].getType()) {

  780.                     <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:

  781.                         args[<span class="jde-java-font-lock-number">0</span>] =

  782.                             <span class="keyword">new</span> <span class="type">Numeric</span>

  783.                                 (property, ((<span class="type">IntegerType</span>)args[<span class="jde-java-font-lock-number">0</span>]).getInt());

  784.                     <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:

  785.                         prop = ((<span class="type">Numeric</span>)args[<span class="jde-java-font-lock-number">0</span>]).abs();

  786.                         <span class="keyword">break</span>;

  787.                     <span class="keyword">default</span>:

  788.                         <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(funcNumericErrorStr());

  789.                     }

  790.                     <span class="keyword">break</span>;

  791.                 }

  792. 

  793.                 <span class="comment">// Color functions

  794. </span>                <span class="keyword">if</span> (function.equals(&quot;<span class="string">rgb</span>&quot;)) {

  795.                     <span class="comment">// Currently arguments must all be integers.

  796. </span>                    <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">3</span>);

  797.                     <span class="keyword">switch</span> (args[<span class="jde-java-font-lock-number">0</span>].getType()) {

  798.                     <span class="keyword">case</span> <span class="reference">PropertyValue.INTEGER</span>:

  799.                         prop = <span class="keyword">new</span> <span class="type">ColorType</span>

  800.                                 (property, ((<span class="type">IntegerType</span>)args[<span class="jde-java-font-lock-number">0</span>]).getInt(),

  801.                                  ((<span class="type">IntegerType</span>)args[<span class="jde-java-font-lock-number">1</span>]).getInt(),

  802.                                  ((<span class="type">IntegerType</span>)args[<span class="jde-java-font-lock-number">2</span>]).getInt());

  803.                         <span class="keyword">break</span>;

  804.                     <span class="keyword">case</span> <span class="reference">PropertyValue.NUMERIC</span>:

  805.                         prop = <span class="keyword">new</span> <span class="type">ColorType</span>

  806.                                 (property, ((<span class="type">Numeric</span>)args[<span class="jde-java-font-lock-number">0</span>]).asInt(),

  807.                                  ((<span class="type">Numeric</span>)args[<span class="jde-java-font-lock-number">1</span>]).asInt(),

  808.                                  ((<span class="type">Numeric</span>)args[<span class="jde-java-font-lock-number">2</span>]).asInt());

  809.                         <span class="keyword">break</span>;

  810.                     <span class="keyword">default</span>:

  811.                         <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(funcNumericErrorStr());

  812.                     }

  813.                     <span class="keyword">break</span>;

  814.                 }

  815.                 <span class="keyword">if</span> (function.equals(&quot;<span class="string">rgb-icc</span>&quot;)) {

  816.                     <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">6</span>);

  817.                     <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">FunctionNotImplementedException</span>(&quot;<span class="string">rgb-icc</span>&quot;);

  818.                     <span class="comment">//break;

  819. </span>                }

  820.                 <span class="keyword">if</span> (function.equals(&quot;<span class="string">system-color</span>&quot;)) {

  821.                     <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">1</span>);

  822.                     prop = <span class="keyword">new</span> <span class="type">ColorType</span>

  823.                             (property, ((<span class="type">StringType</span>)args[<span class="jde-java-font-lock-number">0</span>]).getString());

  824.                     <span class="keyword">break</span>;

  825.                 }

  826. 

  827.                 <span class="comment">// Font function

  828. </span>                <span class="keyword">if</span> (function.equals(&quot;<span class="string">system-font</span>&quot;)) {

  829.                     <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">1</span>, <span class="jde-java-font-lock-number">2</span>);

  830.                     <span class="keyword">if</span> (args.length == <span class="jde-java-font-lock-number">1</span>) {

  831.                         prop = SystemFontFunction.systemFontCharacteristic

  832.                                 (property,

  833.                                  ((<span class="type">StringType</span>)args[<span class="jde-java-font-lock-number">0</span>]).getString());

  834.                     } <span class="keyword">else</span> {

  835.                         <span class="comment">// 2 args

  836. </span>                        prop = SystemFontFunction.systemFontCharacteristic

  837.                                 (property,

  838.                                  ((<span class="type">StringType</span>)args[<span class="jde-java-font-lock-number">0</span>]).getString(),

  839.                                  ((<span class="type">StringType</span>)args[<span class="jde-java-font-lock-number">1</span>]).getString());

  840.                     }

  841.                     <span class="keyword">break</span>;

  842.                 }

  843. 

  844.                 <span class="comment">// Property value functions

  845. </span>                <span class="keyword">if</span> (function.equals(&quot;<span class="string">label-end</span>&quot;)) {

  846.                     <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">0</span>);

  847.                     <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">FunctionNotImplementedException</span>(&quot;<span class="string">label-end</span>&quot;);

  848.                     <span class="comment">//break;

  849. </span>                }

  850.                 <span class="keyword">if</span> (function.equals(&quot;<span class="string">body-start</span>&quot;)) {

  851.                     <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">0</span>);

  852.                     <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">FunctionNotImplementedException</span>(&quot;<span class="string">body-start</span>&quot;);

  853.                     <span class="comment">//break;

  854. </span>                }

  855.                 <span class="keyword">if</span> (function.equals(&quot;<span class="string">inherited-property-value</span>&quot;)) {

  856.                     <span class="type">int</span> <span class="variable-name" id="propindex">propindex</span> = property;

  857.                     <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">0</span>, <span class="jde-java-font-lock-number">1</span>);

  858.                     <span class="keyword">if</span> (args.length != <span class="jde-java-font-lock-number">0</span>)

  859.                         propindex = PropNames.getPropertyIndex(

  860.                                 ((<span class="type">StringType</span>)args[<span class="jde-java-font-lock-number">0</span>]).getString());

  861. 

  862.                     <span class="comment">// If it's a compound, return an InheritedValue object

  863. </span>                    <span class="keyword">if</span> (PropertyConsts.pconsts.isCompound(propindex)) {

  864.                         prop = <span class="keyword">new</span> <span class="type">InheritedValue</span>(property, propindex);

  865.                         <span class="keyword">break</span>;

  866.                     }

  867.                     <span class="comment">// Is it an inherited property?

  868. </span>                    <span class="keyword">if</span> (PropertyConsts.pconsts.inheritance(propindex)

  869.                                                             == Property.<span class="jde-java-font-lock-constant" id="NO">NO</span>)

  870.                         <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>

  871.                                 (&quot;<span class="string">inherited-property-value: </span>&quot;

  872.                                  + PropNames.getPropertyName(propindex)

  873.                                  + &quot;<span class="string"> is not inherited.</span>&quot;);

  874.                     <span class="comment">// Not a compound, and inherited - try to resolve it

  875. </span>                    prop = node.fromParent(property, propindex);

  876.                     <span class="keyword">break</span>;

  877.                 }

  878.                 <span class="comment">// N.B. see comments on classes FromNearestSpecified and

  879. </span>                <span class="comment">// FromParent for explanation of this section

  880. </span>                <span class="keyword">if</span> (function.equals(&quot;<span class="string">from-parent</span>&quot;))

  881.                     funcType = PropertyValue.<span class="jde-java-font-lock-constant" id="FROM_PARENT">FROM_PARENT</span>;

  882.                 <span class="keyword">if</span> (function.equals(&quot;<span class="string">from-nearest-specified-value</span>&quot;))

  883.                     funcType = PropertyValue.<span class="jde-java-font-lock-constant" id="FROM_NEAREST_SPECIFIED">FROM_NEAREST_SPECIFIED</span>;

  884.                 <span class="keyword">if</span> (funcType == <span class="reference">PropertyValue</span>.<span class="type">FROM_PARENT</span>

  885.                     || funcType == PropertyValue.<span class="jde-java-font-lock-constant">FROM_NEAREST_SPECIFIED</span>)

  886.                 {

  887.                     <span class="comment">// Preset the return value in case of a shorthand property

  888. </span>                    <span class="keyword">switch</span> (funcType) {

  889.                     <span class="keyword">case</span> <span class="reference">PropertyValue.FROM_PARENT</span>:

  890.                         prop = <span class="keyword">new</span> <span class="type">FromParent</span>(property);

  891.                     <span class="keyword">case</span> <span class="reference">PropertyValue.FROM_NEAREST_SPECIFIED</span>:

  892.                         prop = <span class="keyword">new</span> <span class="type">FromNearestSpecified</span>(property);

  893.                     }

  894. 

  895.                     <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">0</span>, <span class="jde-java-font-lock-number">1</span>);

  896.                     <span class="keyword">if</span> (args.length == <span class="jde-java-font-lock-number">0</span>) {

  897.                         <span class="keyword">if</span> (! (PropertyConsts.pconsts.isShorthand(property)

  898.                            || PropertyConsts.pconsts.isCompound(property))) {

  899.                             <span class="comment">// develop the function value and return it as

  900. </span>                            <span class="comment">// a property.

  901. </span>                            <span class="keyword">switch</span> (funcType) {

  902.                             <span class="keyword">case</span> <span class="reference">PropertyValue.FROM_PARENT</span>:

  903.                                 prop = node.fromParent(property);

  904.                             <span class="keyword">case</span> <span class="reference">PropertyValue.FROM_NEAREST_SPECIFIED</span>:

  905.                                 prop = node.fromNearestSpecified(property);

  906.                             }

  907.                         }

  908.                         <span class="comment">// else a shorthand/compound - do nothing;

  909. </span>                        <span class="comment">// prop has been

  910. </span>                        <span class="comment">// set to the appropriate pseudo-propertyValue

  911. </span>                    } <span class="keyword">else</span> { <span class="comment">// one argument - it must be a property name

  912. </span>                        <span class="keyword">if</span> ( ! (args[<span class="jde-java-font-lock-number">0</span>] <span class="keyword">instanceof</span> <span class="type">NCName</span>))

  913.                             <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>

  914.                                     (function + &quot;<span class="string"> function requires</span>&quot;

  915.                                      + &quot;<span class="string"> property name arg.</span>&quot;);

  916.                         <span class="comment">// else arg[0] is an NCName

  917. </span>                        <span class="type">NCName</span> <span class="variable-name" id="ncname">ncname</span> = (<span class="type">NCName</span>)args[<span class="jde-java-font-lock-number">0</span>];

  918.                         <span class="type">String</span> <span class="variable-name" id="propname">propname</span> = ncname.getNCName();

  919.                         <span class="type">int</span> <span class="variable-name" id="nameindex">nameindex</span> =

  920.                                 PropNames.getPropertyIndex(propname);

  921.                         <span class="keyword">if</span> (PropertyConsts.pconsts.isShorthand(nameindex)

  922.                             || PropertyConsts.pconsts.isCompound(nameindex)) {

  923.                             <span class="comment">// the argument is a shorthand/compound property -

  924. </span>                            <span class="comment">// it must be the same as the property being

  925. </span>                            <span class="comment">// assigned to.

  926. </span>                            <span class="comment">// see 5.10.4 Property Value Functions

  927. </span>                            <span class="keyword">if</span> ( ! (nameindex == property))

  928.                                 <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>

  929.                                         (function +

  930.                                          &quot;<span class="string"> argument </span>&quot; + propname +

  931.                                          &quot;<span class="string"> does not match property </span>&quot; +

  932.                                          PropNames.getPropertyName(property));

  933.                             <span class="comment">// else perform shorthand/compound processing

  934. </span>                            <span class="comment">// i.e. do nothing;

  935. </span>                            <span class="comment">// prop has been set to the correct

  936. </span>                            <span class="comment">// pseudo-propertyValue

  937. </span>                        }

  938.                         <span class="keyword">else</span> {   <span class="comment">// An NCName but not a shorthand/compound

  939. </span>                            <span class="comment">// Perform normal from-? processing

  940. </span>                            <span class="keyword">switch</span> (funcType) {

  941.                             <span class="keyword">case</span> <span class="reference">PropertyValue.FROM_PARENT</span>:

  942.                                 prop = node.fromParent(property, nameindex);

  943.                             <span class="keyword">case</span> <span class="reference">PropertyValue.FROM_NEAREST_SPECIFIED</span>:

  944.                                 prop = node.fromNearestSpecified

  945.                                                         (property, nameindex);

  946.                             }

  947.                         }

  948.                     }

  949.                     <span class="keyword">break</span>;

  950.                 }

  951.                 <span class="keyword">if</span> (function.equals(&quot;<span class="string">from-table-column</span>&quot;)) {

  952.                     <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">0</span>, <span class="jde-java-font-lock-number">1</span>);

  953.                     <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">FunctionNotImplementedException</span>

  954.                             (&quot;<span class="string">from-table-column</span>&quot;);

  955.                     <span class="comment">//break;

  956. </span>                }

  957.                 <span class="keyword">if</span> (function.equals(&quot;<span class="string">proportional-column-width</span>&quot;)) {

  958.                     <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">1</span>);

  959.                     <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">FunctionNotImplementedException</span>

  960.                             (&quot;<span class="string">proportional-column-width</span>&quot;);

  961.                     <span class="comment">//break;

  962. </span>                }

  963.                 <span class="keyword">if</span> (function.equals(&quot;<span class="string">merge-property-values</span>&quot;)) {

  964.                     <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = parseArgs(<span class="jde-java-font-lock-number">0</span>, <span class="jde-java-font-lock-number">1</span>);

  965.                     <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">FunctionNotImplementedException</span>

  966.                             (&quot;<span class="string">merge-property-values</span>&quot;);

  967.                     <span class="comment">//break;

  968. </span>                }

  969.                 <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">no such function: </span>&quot;

  970.                                                         + function);

  971.             } <span class="keyword">while</span> (<span class="jde-java-font-lock-constant" id="false">false</span>);

  972.             <span class="keyword">return</span> prop;

  973.         }

  974.         <span class="keyword">default</span>:

  975.             <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">syntax error</span>&quot;);

  976.         }

  977.         next();

  978.         <span class="keyword">return</span> prop;

  979.     }

  980. 

  981.     <span class="comment">/**

  982.      * Parse a comma separated list of function arguments. Each argument

  983.      * may itself be an expression. This method consumes the closing right

  984.      * parenthesis of the argument list.

  985.      * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="nbArgs">nbArgs</span><span class="comment"> The number of arguments expected by the function.

  986.      * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;PropertyValueList&lt;/tt&gt; of &lt;tt&gt;PropertyValue&lt;/tt&gt; objects

  987.      * representing the arguments found.

  988.      * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">PropertyException

  989. </span><span class="comment">     */</span>

  990.     <span class="type">PropertyValue</span>[] <span class="function-name" id="parseArgs">parseArgs</span>(<span class="type">int</span> <span class="variable-name">nbArgs</span>) <span class="keyword">throws</span> <span class="type">PropertyException</span> {

  991.         <span class="keyword">return</span> parseArgs(nbArgs, nbArgs);

  992.     }

  993. 

  994.     <span class="comment">/**

  995.      * Parse a comma separated list of function arguments. Each argument

  996.      * may itself be an expression. This method consumes the closing right

  997.      * parenthesis of the argument list.

  998.      * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="minArgs">minArgs</span><span class="comment"> The minimum number of arguments expected by the function.

  999.      * </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="maxArgs">maxArgs</span><span class="comment"> The maximum number of arguments expected by the function.

  1000.      * </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> &lt;tt&gt;PropertyValueList&lt;/tt&gt; of &lt;tt&gt;PropertyValue&lt;/tt&gt; objects

  1001.      * representing the arguments found.  N.B.  The actual number of arguments

  1002.      * returned is guaranteed to be between minArgs and maxArgs, inclusive,

  1003.      * but the actual list of args found is terminated by the end of the

  1004.      * array, or the first null element.

  1005.      * </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">PropertyException

  1006. </span><span class="comment">     */</span>

  1007.     <span class="type">PropertyValue</span>[] <span class="function-name">parseArgs</span>(<span class="type">int</span> <span class="variable-name">minArgs</span>, <span class="type">int</span> <span class="variable-name">maxArgs</span>)

  1008.         <span class="keyword">throws</span> <span class="type">PropertyException</span>

  1009.     {

  1010.         <span class="type">PropertyValue</span>[] <span class="variable-name">args</span> = <span class="keyword">new</span> <span class="type">PropertyValue</span>[maxArgs];

  1011.         <span class="type">PropertyValue</span> <span class="variable-name">prop</span>;

  1012.         <span class="type">int</span> <span class="variable-name" id="i">i</span> = <span class="jde-java-font-lock-number">0</span>;

  1013.         <span class="keyword">if</span> (currentToken == <span class="jde-java-font-lock-constant">RPAR</span>) {

  1014.             <span class="comment">// No args: func()

  1015. </span>            next();

  1016.         } <span class="keyword">else</span> {

  1017.             <span class="keyword">while</span> (<span class="jde-java-font-lock-constant">true</span>) {

  1018.                 prop = parseAdditiveExpr();

  1019.                 <span class="keyword">if</span> (i &lt; maxArgs) {

  1020.                     args[i++] = prop;

  1021.                 }

  1022.                 <span class="comment">// ignore extra args

  1023. </span>                <span class="keyword">if</span> (currentToken != <span class="jde-java-font-lock-constant">COMMA</span>)

  1024.                     <span class="keyword">break</span>;

  1025.                 next();

  1026.             }

  1027.             expectRpar();

  1028.         }

  1029.         <span class="keyword">if</span> (minArgs &gt; i || i &gt; maxArgs) {

  1030.             <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">PropertyException</span>(&quot;<span class="string">Wrong number of args for function</span>&quot;);

  1031.         }

  1032.         <span class="keyword">return</span> args;

  1033.     }

  1034. 

  1035. }

  1036. </pre>

  1037.   </body>

  1038. </html>