1 /*
2  * reserved comment block
3  * DO NOT REMOVE OR ALTER!
4  */
5 /*
6  * Licensed to the Apache Software Foundation (ASF) under one or more
7  * contributor license agreements.  See the NOTICE file distributed with
8  * this work for additional information regarding copyright ownership.
9  * The ASF licenses this file to You under the Apache License, Version 2.0
10  * (the "License"); you may not use this file except in compliance with
11  * the License.  You may obtain a copy of the License at
12  *
13  *      http://www.apache.org/licenses/LICENSE-2.0
14  *
15  * Unless required by applicable law or agreed to in writing, software
16  * distributed under the License is distributed on an "AS IS" BASIS,
17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18  * See the License for the specific language governing permissions and
19  * limitations under the License.
20  */
21 
22 package com.sun.org.apache.xpath.internal.compiler;
23 
24 /**
25  * Operations codes for XPath.
26  *
27  * Code for the descriptions of the operations codes:
28  * [UPPER CASE] indicates a literal value,
29  * [lower case] is a description of a value,
30  *      ([length] always indicates the length of the operation,
31  *       including the operations code and the length integer.)
32  * {UPPER CASE} indicates the given production,
33  * {description} is the description of a new production,
34  *      (For instance, {boolean expression} means some expression
35  *       that should be resolved to a boolean.)
36  *  * means that it occurs zero or more times,
37  *  + means that it occurs one or more times,
38  *  ? means that it is optional.
39  *
40  * returns: indicates what the production should return.
41  */
42 public class OpCodes
43 {
44 
45   /**
46    * [ENDOP]
47    * Some operators may like to have a terminator.
48    * @xsl.usage advanced
49    */
50   public static final int ENDOP = -1;
51 
52   /**
53    * [EMPTY]
54    * Empty slot to indicate NULL.
55    */
56   public static final int EMPTY = -2;
57 
58   /**
59    * [ELEMWILDCARD]
60    * Means ELEMWILDCARD ("*"), used instead
61    * of string index in some places.
62    * @xsl.usage advanced
63    */
64   public static final int ELEMWILDCARD = -3;
65 
66   /**
67    * [OP_XPATH]
68    * [length]
69    *  {expression}
70    *
71    * returns:
72    *  XNodeSet
73    *  XNumber
74    *  XString
75    *  XBoolean
76    *  XRTree
77    *  XObject
78    * @xsl.usage advanced
79    */
80   public static final int OP_XPATH = 1;
81 
82   /**
83    * [OP_OR]
84    * [length]
85    *  {boolean expression}
86    *  {boolean expression}
87    *
88    * returns:
89    *  XBoolean
90    * @xsl.usage advanced
91    */
92   public static final int OP_OR = 2;
93 
94   /**
95    * [OP_AND]
96    * [length]
97    *  {boolean expression}
98    *  {boolean expression}
99    *
100    * returns:
101    *  XBoolean
102    * @xsl.usage advanced
103    */
104   public static final int OP_AND = 3;
105 
106   /**
107    * [OP_NOTEQUALS]
108    * [length]
109    *  {expression}
110    *  {expression}
111    *
112    * returns:
113    *  XBoolean
114    * @xsl.usage advanced
115    */
116   public static final int OP_NOTEQUALS = 4;
117 
118   /**
119    * [OP_EQUALS]
120    * [length]
121    *  {expression}
122    *  {expression}
123    *
124    * returns:
125    *  XBoolean
126    * @xsl.usage advanced
127    */
128   public static final int OP_EQUALS = 5;
129 
130   /**
131    * [OP_LTE] (less-than-or-equals)
132    * [length]
133    *  {number expression}
134    *  {number expression}
135    *
136    * returns:
137    *  XBoolean
138    * @xsl.usage advanced
139    */
140   public static final int OP_LTE = 6;
141 
142   /**
143    * [OP_LT] (less-than)
144    * [length]
145    *  {number expression}
146    *  {number expression}
147    *
148    * returns:
149    *  XBoolean
150    * @xsl.usage advanced
151    */
152   public static final int OP_LT = 7;
153 
154   /**
155    * [OP_GTE] (greater-than-or-equals)
156    * [length]
157    *  {number expression}
158    *  {number expression}
159    *
160    * returns:
161    *  XBoolean
162    * @xsl.usage advanced
163    */
164   public static final int OP_GTE = 8;
165 
166   /**
167    * [OP_GT] (greater-than)
168    * [length]
169    *  {number expression}
170    *  {number expression}
171    *
172    * returns:
173    *  XBoolean
174    * @xsl.usage advanced
175    */
176   public static final int OP_GT = 9;
177 
178   /**
179    * [OP_PLUS]
180    * [length]
181    *  {number expression}
182    *  {number expression}
183    *
184    * returns:
185    *  XNumber
186    * @xsl.usage advanced
187    */
188   public static final int OP_PLUS = 10;
189 
190   /**
191    * [OP_MINUS]
192    * [length]
193    *  {number expression}
194    *  {number expression}
195    *
196    * returns:
197    *  XNumber
198    * @xsl.usage advanced
199    */
200   public static final int OP_MINUS = 11;
201 
202   /**
203    * [OP_MULT]
204    * [length]
205    *  {number expression}
206    *  {number expression}
207    *
208    * returns:
209    *  XNumber
210    * @xsl.usage advanced
211    */
212   public static final int OP_MULT = 12;
213 
214   /**
215    * [OP_DIV]
216    * [length]
217    *  {number expression}
218    *  {number expression}
219    *
220    * returns:
221    *  XNumber
222    * @xsl.usage advanced
223    */
224   public static final int OP_DIV = 13;
225 
226   /**
227    * [OP_MOD]
228    * [length]
229    *  {number expression}
230    *  {number expression}
231    *
232    * returns:
233    *  XNumber
234    * @xsl.usage advanced
235    */
236   public static final int OP_MOD = 14;
237 
238   /**
239    * [OP_QUO]
240    * [length]
241    *  {number expression}
242    *  {number expression}
243    *
244    * returns:
245    *  XNumber
246    * @xsl.usage advanced
247    */
248   public static final int OP_QUO = 15;
249 
250   /**
251    * [OP_NEG]
252    * [length]
253    *  {number expression}
254    *
255    * returns:
256    *  XNumber
257    * @xsl.usage advanced
258    */
259   public static final int OP_NEG = 16;
260 
261   /**
262    * [OP_STRING] (cast operation)
263    * [length]
264    *  {expression}
265    *
266    * returns:
267    *  XString
268    * @xsl.usage advanced
269    */
270   public static final int OP_STRING = 17;
271 
272   /**
273    * [OP_BOOL] (cast operation)
274    * [length]
275    *  {expression}
276    *
277    * returns:
278    *  XBoolean
279    * @xsl.usage advanced
280    */
281   public static final int OP_BOOL = 18;
282 
283   /**
284    * [OP_NUMBER] (cast operation)
285    * [length]
286    *  {expression}
287    *
288    * returns:
289    *  XBoolean
290    * @xsl.usage advanced
291    */
292   public static final int OP_NUMBER = 19;
293 
294   /**
295    * [OP_UNION]
296    * [length]
297    *  {PathExpr}+
298    *
299    * returns:
300    *  XNodeSet
301    * @xsl.usage advanced
302    */
303   public static final int OP_UNION = 20;
304 
305   /**
306    * [OP_LITERAL]
307    * [3]
308    * [index to token]
309    *
310    * returns:
311    *  XString
312    * @xsl.usage advanced
313    */
314   public static final int OP_LITERAL = 21;
315 
316   /** The low opcode for nodesets, needed by getFirstPredicateOpPos and
317    *  getNextStepPos.          */
318   static final int FIRST_NODESET_OP = 22;
319 
320   /**
321    * [OP_VARIABLE]
322    * [4]
323    * [index to namespace token, or EMPTY]
324    * [index to function name token]
325    *
326    * returns:
327    *  XString
328    * @xsl.usage advanced
329    */
330   public static final int OP_VARIABLE = 22;
331 
332   /**
333    * [OP_GROUP]
334    * [length]
335    *  {expression}
336    *
337    * returns:
338    *  XNodeSet
339    *  XNumber
340    *  XString
341    *  XBoolean
342    *  XRTree
343    *  XObject
344    * @xsl.usage advanced
345    */
346   public static final int OP_GROUP = 23;
347 
348   /**
349    * [OP_EXTFUNCTION] (Extension function.)
350    * [length]
351    * [index to namespace token]
352    * [index to function name token]
353    *  {OP_ARGUMENT}
354    *
355    * returns:
356    *  XNodeSet
357    *  XNumber
358    *  XString
359    *  XBoolean
360    *  XRTree
361    *  XObject
362    * @xsl.usage advanced
363    */
364   public static final int OP_EXTFUNCTION = 24;
365 
366   /**
367    * [OP_FUNCTION]
368    * [length]
369    * [FUNC_name]
370    *  {OP_ARGUMENT}
371    * [ENDOP]
372    *
373    * returns:
374    *  XNodeSet
375    *  XNumber
376    *  XString
377    *  XBoolean
378    *  XRTree
379    *  XObject
380    * @xsl.usage advanced
381    */
382   public static final int OP_FUNCTION = 25;
383 
384   /** The last opcode for stuff that can be a nodeset.         */
385   static final int LAST_NODESET_OP = 25;
386 
387   /**
388    * [OP_ARGUMENT] (Function argument.)
389    * [length]
390    *  {expression}
391    *
392    * returns:
393    *  XNodeSet
394    *  XNumber
395    *  XString
396    *  XBoolean
397    *  XRTree
398    *  XObject
399    * @xsl.usage advanced
400    */
401   public static final int OP_ARGUMENT = 26;
402 
403   /**
404    * [OP_NUMBERLIT] (Number literal.)
405    * [3]
406    * [index to token]
407    *
408    * returns:
409    *  XString
410    * @xsl.usage advanced
411    */
412   public static final int OP_NUMBERLIT = 27;
413 
414   /**
415    * [OP_LOCATIONPATH]
416    * [length]
417    *   {FROM_stepType}
418    * | {function}
419    * {predicate}
420    * [ENDOP]
421    *
422    * (Note that element and attribute namespaces and
423    * names can be wildcarded '*'.)
424    *
425    * returns:
426    *  XNodeSet
427    * @xsl.usage advanced
428    */
429   public static final int OP_LOCATIONPATH = 28;
430 
431   // public static final int LOCATIONPATHEX_MASK = 0x0000FFFF;
432   // public static final int LOCATIONPATHEX_ISSIMPLE = 0x00010000;
433   // public static final int OP_LOCATIONPATH_EX = (28 | 0x00010000);
434 
435   /**
436    * [OP_PREDICATE]
437    * [length]
438    *  {expression}
439    * [ENDOP] (For safety)
440    *
441    * returns:
442    *  XBoolean or XNumber
443    * @xsl.usage advanced
444    */
445   public static final int OP_PREDICATE = 29;
446 
447   /**
448    * [OP_MATCHPATTERN]
449    * [length]
450    *  {PathExpr}+
451    *
452    * returns:
453    *  XNodeSet
454    * @xsl.usage advanced
455    */
456   public static final int OP_MATCHPATTERN = 30;
457 
458   /**
459    * [OP_LOCATIONPATHPATTERN]
460    * [length]
461    *   {FROM_stepType}
462    * | {function}{predicate}
463    * [ENDOP]
464    * returns:
465    *  XNodeSet
466    * @xsl.usage advanced
467    */
468   public static final int OP_LOCATIONPATHPATTERN = 31;
469 
470   /**
471    * [NODETYPE_COMMENT]
472    * No size or arguments.
473    * Note: must not overlap function OP number!
474    *
475    * returns:
476    *  XBoolean
477    * @xsl.usage advanced
478    */
479   public static final int NODETYPE_COMMENT = 1030;
480 
481   /**
482    * [NODETYPE_TEXT]
483    * No size or arguments.
484    * Note: must not overlap function OP number!
485    *
486    * returns:
487    *  XBoolean
488    * @xsl.usage advanced
489    */
490   public static final int NODETYPE_TEXT = 1031;
491 
492   /**
493    * [NODETYPE_PI]
494    * [index to token]
495    * Note: must not overlap function OP number!
496    *
497    * returns:
498    *  XBoolean
499    * @xsl.usage advanced
500    */
501   public static final int NODETYPE_PI = 1032;
502 
503   /**
504    * [NODETYPE_NODE]
505    * No size or arguments.
506    * Note: must not overlap function OP number!
507    *
508    * returns:
509    *  XBoolean
510    * @xsl.usage advanced
511    */
512   public static final int NODETYPE_NODE = 1033;
513 
514   /**
515    * [NODENAME]
516    * [index to ns token or EMPTY]
517    * [index to name token]
518    *
519    * returns:
520    *  XBoolean
521    * @xsl.usage advanced
522    */
523   public static final int NODENAME = 34;
524 
525   /**
526    * [NODETYPE_ROOT]
527    * No size or arguments.
528    *
529    * returns:
530    *  XBoolean
531    * @xsl.usage advanced
532    */
533   public static final int NODETYPE_ROOT = 35;
534 
535   /**
536    * [NODETYPE_ANY]
537    * No size or arguments.
538    *
539    * returns:
540    *  XBoolean
541    * @xsl.usage advanced
542    */
543   public static final int NODETYPE_ANYELEMENT = 36;
544 
545   /**
546    * [NODETYPE_ANY]
547    * No size or arguments.
548    *
549    * returns:
550    *  XBoolean
551    * @xsl.usage advanced
552    */
553   public static final int NODETYPE_FUNCTEST = 1034;
554 
555   /**
556    * [FROM_stepType]
557    * [length, including predicates]
558    * [length of just the step, without the predicates]
559    * {node test}
560    * {predicates}?
561    *
562    * returns:
563    *  XBoolean
564    * @xsl.usage advanced
565    */
566   public static final int AXES_START_TYPES = 37;
567 
568   /** ancestor axes opcode.         */
569   public static final int FROM_ANCESTORS = 37;
570 
571   /** ancestor-or-self axes opcode.         */
572   public static final int FROM_ANCESTORS_OR_SELF = 38;
573 
574   /** attribute axes opcode.         */
575   public static final int FROM_ATTRIBUTES = 39;
576 
577   /** children axes opcode.         */
578   public static final int FROM_CHILDREN = 40;
579 
580   /** descendants axes opcode.         */
581   public static final int FROM_DESCENDANTS = 41;
582 
583   /** descendants-of-self axes opcode.         */
584   public static final int FROM_DESCENDANTS_OR_SELF = 42;
585 
586   /** following axes opcode.         */
587   public static final int FROM_FOLLOWING = 43;
588 
589   /** following-siblings axes opcode.         */
590   public static final int FROM_FOLLOWING_SIBLINGS = 44;
591 
592   /** parent axes opcode.         */
593   public static final int FROM_PARENT = 45;
594 
595   /** preceding axes opcode.         */
596   public static final int FROM_PRECEDING = 46;
597 
598   /** preceding-sibling axes opcode.         */
599   public static final int FROM_PRECEDING_SIBLINGS = 47;
600 
601   /** self axes opcode.         */
602   public static final int FROM_SELF = 48;
603 
604   /** namespace axes opcode.         */
605   public static final int FROM_NAMESPACE = 49;
606 
607   /** '/' axes opcode.         */
608   public static final int FROM_ROOT = 50;
609 
610   /**
611    * For match patterns.
612    * @xsl.usage advanced
613    */
614   public static final int MATCH_ATTRIBUTE = 51;
615 
616   /**
617    * For match patterns.
618    * @xsl.usage advanced
619    */
620   public static final int MATCH_ANY_ANCESTOR = 52;
621 
622   /**
623    * For match patterns.
624    * @xsl.usage advanced
625    */
626   public static final int MATCH_IMMEDIATE_ANCESTOR = 53;
627 
628   /** The end of the axes types.    */
629   public static final int AXES_END_TYPES = 53;
630 
631   /** The next free ID.  Please keep this up to date.  */
632   private static final int NEXT_FREE_ID = 99;
633 }
634