001    /* This file was generated with JastAdd2 (http://jastadd.org) version R20130213 */
002    package AST;
003    
004    import java.util.HashSet;
005    import java.io.File;
006    import java.util.*;
007    import beaver.*;
008    import java.util.ArrayList;
009    import java.util.zip.*;
010    import java.io.*;
011    import java.io.FileNotFoundException;
012    import java.util.Collection;
013    /**
014     * @production IntegralType : {@link NumericType};
015     * @ast node
016     * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/java.ast:55
017     */
018    public abstract class IntegralType extends NumericType implements Cloneable {
019      /**
020       * @apilevel low-level
021       */
022      public void flushCache() {
023      }
024      /**
025       * @apilevel internal
026       */
027      public void flushCollectionCache() {
028      }
029      /**
030       * @apilevel internal
031       */
032      @SuppressWarnings({"unchecked", "cast"})
033      public IntegralType clone() throws CloneNotSupportedException {
034        IntegralType node = (IntegralType)super.clone();
035        node.in$Circle(false);
036        node.is$Final(false);
037        return node;
038      }
039      /**
040       * @ast method 
041       * @aspect Attributes
042       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/Attributes.jrag:63
043       */
044      public int addConstant(ConstantPool p, Constant c) { return p.addConstant(c.intValue()); }
045      /**
046       * @ast method 
047       * @aspect CodeGeneration
048       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:543
049       */
050      public void emitPushConstant(CodeGeneration gen, int value) { IntegerLiteral.push(gen, value); }
051      /**
052       * @ast method 
053       * @aspect CodeGenerationConversions
054       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:990
055       */
056      void byteToThis(CodeGeneration gen) { }
057      /**
058       * @ast method 
059       * @aspect CodeGenerationConversions
060       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:997
061       */
062      void charToThis(CodeGeneration gen) { }
063      /**
064       * @ast method 
065       * @aspect CodeGenerationConversions
066       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1005
067       */
068      void shortToThis(CodeGeneration gen) { }
069      /**
070       * @ast method 
071       * @aspect CodeGenerationBinaryOperations
072       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1038
073       */
074      void neg(CodeGeneration gen) { gen.emit(Bytecode.INEG); }
075      /**
076       * @ast method 
077       * @aspect CodeGenerationBinaryOperations
078       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1044
079       */
080      void bitNot(CodeGeneration gen) { gen.emit(Bytecode.ICONST_M1).emit(Bytecode.IXOR); }
081      /**
082       * @ast method 
083       * @aspect CodeGenerationBinaryOperations
084       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1054
085       */
086      void add(CodeGeneration gen) {gen.emit(Bytecode.IADD);}
087      /**
088       * @ast method 
089       * @aspect CodeGenerationBinaryOperations
090       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1060
091       */
092      void sub(CodeGeneration gen) {gen.emit(Bytecode.ISUB);}
093      /**
094       * @ast method 
095       * @aspect CodeGenerationBinaryOperations
096       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1066
097       */
098      void mul(CodeGeneration gen) {gen.emit(Bytecode.IMUL);}
099      /**
100       * @ast method 
101       * @aspect CodeGenerationBinaryOperations
102       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1072
103       */
104      void div(CodeGeneration gen) {gen.emit(Bytecode.IDIV);}
105      /**
106       * @ast method 
107       * @aspect CodeGenerationBinaryOperations
108       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1078
109       */
110      void rem(CodeGeneration gen) {gen.emit(Bytecode.IREM);}
111      /**
112       * @ast method 
113       * @aspect CodeGenerationBinaryOperations
114       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1082
115       */
116      void shl(CodeGeneration gen) {gen.emit(Bytecode.ISHL);}
117      /**
118       * @ast method 
119       * @aspect CodeGenerationBinaryOperations
120       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1086
121       */
122      void shr(CodeGeneration gen) {gen.emit(Bytecode.ISHR);}
123      /**
124       * @ast method 
125       * @aspect CodeGenerationBinaryOperations
126       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1090
127       */
128      void ushr(CodeGeneration gen) {gen.emit(Bytecode.IUSHR);}
129      /**
130       * @ast method 
131       * @aspect CodeGenerationBinaryOperations
132       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1094
133       */
134      void bitand(CodeGeneration gen) {gen.emit(Bytecode.IAND);}
135      /**
136       * @ast method 
137       * @aspect CodeGenerationBinaryOperations
138       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1099
139       */
140      void bitor(CodeGeneration gen) {gen.emit(Bytecode.IOR);}
141      /**
142       * @ast method 
143       * @aspect CodeGenerationBinaryOperations
144       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1104
145       */
146      void bitxor(CodeGeneration gen) {gen.emit(Bytecode.IXOR);}
147      /**
148       * @ast method 
149       * @aspect CodeGenerationBranch
150       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1113
151       */
152      public void branchLT(CodeGeneration gen, int label) { gen.emitCompare(Bytecode.IF_ICMPLT, label); }
153      /**
154       * @ast method 
155       * @aspect CodeGenerationBranch
156       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1119
157       */
158      public void branchLE(CodeGeneration gen, int label) { gen.emitCompare(Bytecode.IF_ICMPLE, label); }
159      /**
160       * @ast method 
161       * @aspect CodeGenerationBranch
162       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1125
163       */
164      public void branchGE(CodeGeneration gen, int label) { gen.emitCompare(Bytecode.IF_ICMPGE, label); }
165      /**
166       * @ast method 
167       * @aspect CodeGenerationBranch
168       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1131
169       */
170      public void branchGT(CodeGeneration gen, int label) { gen.emitCompare(Bytecode.IF_ICMPGT, label); }
171      /**
172       * @ast method 
173       * @aspect CodeGenerationBranch
174       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1137
175       */
176      public void branchEQ(CodeGeneration gen, int label)  { gen.emitCompare(Bytecode.IF_ICMPEQ, label); }
177      /**
178       * @ast method 
179       * @aspect CodeGenerationBranch
180       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1146
181       */
182      public void branchNE(CodeGeneration gen, int label)  { gen.emitCompare(Bytecode.IF_ICMPNE, label); }
183      /**
184       * @ast method 
185       * @aspect AnnotationsCodegen
186       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Backend/AnnotationsCodegen.jrag:180
187       */
188      public int addAnnotConstant(ConstantPool p, Constant c) {
189        return addConstant(p, c);
190      }
191      /**
192       * @ast method 
193       * 
194       */
195      public IntegralType() {
196        super();
197    
198    
199      }
200      /**
201       * Initializes the child array to the correct size.
202       * Initializes List and Opt nta children.
203       * @apilevel internal
204       * @ast method
205       * @ast method 
206       * 
207       */
208      public void init$Children() {
209        children = new ASTNode[3];
210        setChild(new Opt(), 1);
211        setChild(new List(), 2);
212      }
213      /**
214       * @ast method 
215       * 
216       */
217      public IntegralType(Modifiers p0, String p1, Opt<Access> p2, List<BodyDecl> p3) {
218        setChild(p0, 0);
219        setID(p1);
220        setChild(p2, 1);
221        setChild(p3, 2);
222      }
223      /**
224       * @ast method 
225       * 
226       */
227      public IntegralType(Modifiers p0, beaver.Symbol p1, Opt<Access> p2, List<BodyDecl> p3) {
228        setChild(p0, 0);
229        setID(p1);
230        setChild(p2, 1);
231        setChild(p3, 2);
232      }
233      /**
234       * @apilevel low-level
235       * @ast method 
236       * 
237       */
238      protected int numChildren() {
239        return 3;
240      }
241      /**
242       * @apilevel internal
243       * @ast method 
244       * 
245       */
246      public boolean mayHaveRewrite() {
247        return false;
248      }
249      /**
250       * Replaces the Modifiers child.
251       * @param node The new node to replace the Modifiers child.
252       * @apilevel high-level
253       * @ast method 
254       * 
255       */
256      public void setModifiers(Modifiers node) {
257        setChild(node, 0);
258      }
259      /**
260       * Retrieves the Modifiers child.
261       * @return The current node used as the Modifiers child.
262       * @apilevel high-level
263       * @ast method 
264       * 
265       */
266      public Modifiers getModifiers() {
267        return (Modifiers)getChild(0);
268      }
269      /**
270       * Retrieves the Modifiers child.
271       * <p><em>This method does not invoke AST transformations.</em></p>
272       * @return The current node used as the Modifiers child.
273       * @apilevel low-level
274       * @ast method 
275       * 
276       */
277      public Modifiers getModifiersNoTransform() {
278        return (Modifiers)getChildNoTransform(0);
279      }
280      /**
281       * Replaces the lexeme ID.
282       * @param value The new value for the lexeme ID.
283       * @apilevel high-level
284       * @ast method 
285       * 
286       */
287      public void setID(String value) {
288        tokenString_ID = value;
289      }
290      /**
291       * JastAdd-internal setter for lexeme ID using the Beaver parser.
292       * @apilevel internal
293       * @ast method 
294       * 
295       */
296      public void setID(beaver.Symbol symbol) {
297        if(symbol.value != null && !(symbol.value instanceof String))
298          throw new UnsupportedOperationException("setID is only valid for String lexemes");
299        tokenString_ID = (String)symbol.value;
300        IDstart = symbol.getStart();
301        IDend = symbol.getEnd();
302      }
303      /**
304       * Retrieves the value for the lexeme ID.
305       * @return The value for the lexeme ID.
306       * @apilevel high-level
307       * @ast method 
308       * 
309       */
310      public String getID() {
311        return tokenString_ID != null ? tokenString_ID : "";
312      }
313      /**
314       * Replaces the optional node for the SuperClassAccess child. This is the {@code Opt} node containing the child SuperClassAccess, not the actual child!
315       * @param opt The new node to be used as the optional node for the SuperClassAccess child.
316       * @apilevel low-level
317       * @ast method 
318       * 
319       */
320      public void setSuperClassAccessOpt(Opt<Access> opt) {
321        setChild(opt, 1);
322      }
323      /**
324       * Check whether the optional SuperClassAccess child exists.
325       * @return {@code true} if the optional SuperClassAccess child exists, {@code false} if it does not.
326       * @apilevel high-level
327       * @ast method 
328       * 
329       */
330      public boolean hasSuperClassAccess() {
331        return getSuperClassAccessOpt().getNumChild() != 0;
332      }
333      /**
334       * Retrieves the (optional) SuperClassAccess child.
335       * @return The SuperClassAccess child, if it exists. Returns {@code null} otherwise.
336       * @apilevel low-level
337       * @ast method 
338       * 
339       */
340      @SuppressWarnings({"unchecked", "cast"})
341      public Access getSuperClassAccess() {
342        return (Access)getSuperClassAccessOpt().getChild(0);
343      }
344      /**
345       * Replaces the (optional) SuperClassAccess child.
346       * @param node The new node to be used as the SuperClassAccess child.
347       * @apilevel high-level
348       * @ast method 
349       * 
350       */
351      public void setSuperClassAccess(Access node) {
352        getSuperClassAccessOpt().setChild(node, 0);
353      }
354      /**
355       * @apilevel low-level
356       * @ast method 
357       * 
358       */
359      @SuppressWarnings({"unchecked", "cast"})
360      public Opt<Access> getSuperClassAccessOpt() {
361        return (Opt<Access>)getChild(1);
362      }
363      /**
364       * Retrieves the optional node for child SuperClassAccess. This is the {@code Opt} node containing the child SuperClassAccess, not the actual child!
365       * <p><em>This method does not invoke AST transformations.</em></p>
366       * @return The optional node for child SuperClassAccess.
367       * @apilevel low-level
368       * @ast method 
369       * 
370       */
371      @SuppressWarnings({"unchecked", "cast"})
372      public Opt<Access> getSuperClassAccessOptNoTransform() {
373        return (Opt<Access>)getChildNoTransform(1);
374      }
375      /**
376       * Replaces the BodyDecl list.
377       * @param list The new list node to be used as the BodyDecl list.
378       * @apilevel high-level
379       * @ast method 
380       * 
381       */
382      public void setBodyDeclList(List<BodyDecl> list) {
383        setChild(list, 2);
384      }
385      /**
386       * Retrieves the number of children in the BodyDecl list.
387       * @return Number of children in the BodyDecl list.
388       * @apilevel high-level
389       * @ast method 
390       * 
391       */
392      public int getNumBodyDecl() {
393        return getBodyDeclList().getNumChild();
394      }
395      /**
396       * Retrieves the number of children in the BodyDecl list.
397       * Calling this method will not trigger rewrites..
398       * @return Number of children in the BodyDecl list.
399       * @apilevel low-level
400       * @ast method 
401       * 
402       */
403      public int getNumBodyDeclNoTransform() {
404        return getBodyDeclListNoTransform().getNumChildNoTransform();
405      }
406      /**
407       * Retrieves the element at index {@code i} in the BodyDecl list..
408       * @param i Index of the element to return.
409       * @return The element at position {@code i} in the BodyDecl list.
410       * @apilevel high-level
411       * @ast method 
412       * 
413       */
414      @SuppressWarnings({"unchecked", "cast"})
415      public BodyDecl getBodyDecl(int i) {
416        return (BodyDecl)getBodyDeclList().getChild(i);
417      }
418      /**
419       * Append an element to the BodyDecl list.
420       * @param node The element to append to the BodyDecl list.
421       * @apilevel high-level
422       * @ast method 
423       * 
424       */
425      public void addBodyDecl(BodyDecl node) {
426        List<BodyDecl> list = (parent == null || state == null) ? getBodyDeclListNoTransform() : getBodyDeclList();
427        list.addChild(node);
428      }
429      /**
430       * @apilevel low-level
431       * @ast method 
432       * 
433       */
434      public void addBodyDeclNoTransform(BodyDecl node) {
435        List<BodyDecl> list = getBodyDeclListNoTransform();
436        list.addChild(node);
437      }
438      /**
439       * Replaces the BodyDecl list element at index {@code i} with the new node {@code node}.
440       * @param node The new node to replace the old list element.
441       * @param i The list index of the node to be replaced.
442       * @apilevel high-level
443       * @ast method 
444       * 
445       */
446      public void setBodyDecl(BodyDecl node, int i) {
447        List<BodyDecl> list = getBodyDeclList();
448        list.setChild(node, i);
449      }
450      /**
451       * Retrieves the BodyDecl list.
452       * @return The node representing the BodyDecl list.
453       * @apilevel high-level
454       * @ast method 
455       * 
456       */
457      public List<BodyDecl> getBodyDecls() {
458        return getBodyDeclList();
459      }
460      /**
461       * Retrieves the BodyDecl list.
462       * <p><em>This method does not invoke AST transformations.</em></p>
463       * @return The node representing the BodyDecl list.
464       * @apilevel low-level
465       * @ast method 
466       * 
467       */
468      public List<BodyDecl> getBodyDeclsNoTransform() {
469        return getBodyDeclListNoTransform();
470      }
471      /**
472       * Retrieves the BodyDecl list.
473       * @return The node representing the BodyDecl list.
474       * @apilevel high-level
475       * @ast method 
476       * 
477       */
478      @SuppressWarnings({"unchecked", "cast"})
479      public List<BodyDecl> getBodyDeclList() {
480        List<BodyDecl> list = (List<BodyDecl>)getChild(2);
481        list.getNumChild();
482        return list;
483      }
484      /**
485       * Retrieves the BodyDecl list.
486       * <p><em>This method does not invoke AST transformations.</em></p>
487       * @return The node representing the BodyDecl list.
488       * @apilevel low-level
489       * @ast method 
490       * 
491       */
492      @SuppressWarnings({"unchecked", "cast"})
493      public List<BodyDecl> getBodyDeclListNoTransform() {
494        return (List<BodyDecl>)getChildNoTransform(2);
495      }
496      /**
497       * @attribute syn
498       * @aspect ConstantExpression
499       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:160
500       */
501      public Constant cast(Constant c) {
502        ASTNode$State state = state();
503        try {  return Constant.create(c.intValue());  }
504        finally {
505        }
506      }
507      /**
508       * @attribute syn
509       * @aspect ConstantExpression
510       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:174
511       */
512      public Constant plus(Constant c) {
513        ASTNode$State state = state();
514        try {  return c;  }
515        finally {
516        }
517      }
518      /**
519       * @attribute syn
520       * @aspect ConstantExpression
521       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:183
522       */
523      public Constant minus(Constant c) {
524        ASTNode$State state = state();
525        try {  return Constant.create(-c.intValue());  }
526        finally {
527        }
528      }
529      /**
530       * @attribute syn
531       * @aspect ConstantExpression
532       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:192
533       */
534      public Constant bitNot(Constant c) {
535        ASTNode$State state = state();
536        try {  return Constant.create(~c.intValue());  }
537        finally {
538        }
539      }
540      /**
541       * @attribute syn
542       * @aspect ConstantExpression
543       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:199
544       */
545      public Constant mul(Constant c1, Constant c2) {
546        ASTNode$State state = state();
547        try {  return Constant.create(c1.intValue() * c2.intValue());  }
548        finally {
549        }
550      }
551      /**
552       * @attribute syn
553       * @aspect ConstantExpression
554       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:208
555       */
556      public Constant div(Constant c1, Constant c2) {
557        ASTNode$State state = state();
558        try {  return Constant.create(c1.intValue() / c2.intValue());  }
559        finally {
560        }
561      }
562      /**
563       * @attribute syn
564       * @aspect ConstantExpression
565       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:217
566       */
567      public Constant mod(Constant c1, Constant c2) {
568        ASTNode$State state = state();
569        try {  return Constant.create(c1.intValue() % c2.intValue());  }
570        finally {
571        }
572      }
573      /**
574       * @attribute syn
575       * @aspect ConstantExpression
576       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:226
577       */
578      public Constant add(Constant c1, Constant c2) {
579        ASTNode$State state = state();
580        try {  return Constant.create(c1.intValue() + c2.intValue());  }
581        finally {
582        }
583      }
584      /**
585       * @attribute syn
586       * @aspect ConstantExpression
587       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:236
588       */
589      public Constant sub(Constant c1, Constant c2) {
590        ASTNode$State state = state();
591        try {  return Constant.create(c1.intValue() - c2.intValue());  }
592        finally {
593        }
594      }
595      /**
596       * @attribute syn
597       * @aspect ConstantExpression
598       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:245
599       */
600      public Constant lshift(Constant c1, Constant c2) {
601        ASTNode$State state = state();
602        try {  return Constant.create(c1.intValue() << c2.intValue());  }
603        finally {
604        }
605      }
606      /**
607       * @attribute syn
608       * @aspect ConstantExpression
609       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:252
610       */
611      public Constant rshift(Constant c1, Constant c2) {
612        ASTNode$State state = state();
613        try {  return Constant.create(c1.intValue() >> c2.intValue());  }
614        finally {
615        }
616      }
617      /**
618       * @attribute syn
619       * @aspect ConstantExpression
620       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:259
621       */
622      public Constant urshift(Constant c1, Constant c2) {
623        ASTNode$State state = state();
624        try {  return Constant.create(c1.intValue() >>> c2.intValue());  }
625        finally {
626        }
627      }
628      /**
629       * @attribute syn
630       * @aspect ConstantExpression
631       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:266
632       */
633      public Constant andBitwise(Constant c1, Constant c2) {
634        ASTNode$State state = state();
635        try {  return Constant.create(c1.intValue() & c2.intValue());  }
636        finally {
637        }
638      }
639      /**
640       * @attribute syn
641       * @aspect ConstantExpression
642       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:274
643       */
644      public Constant xorBitwise(Constant c1, Constant c2) {
645        ASTNode$State state = state();
646        try {  return Constant.create(c1.intValue() ^ c2.intValue());  }
647        finally {
648        }
649      }
650      /**
651       * @attribute syn
652       * @aspect ConstantExpression
653       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:282
654       */
655      public Constant orBitwise(Constant c1, Constant c2) {
656        ASTNode$State state = state();
657        try {  return Constant.create(c1.intValue() | c2.intValue());  }
658        finally {
659        }
660      }
661      /**
662       * @attribute syn
663       * @aspect ConstantExpression
664       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:290
665       */
666      public Constant questionColon(Constant cond, Constant c1, Constant c2) {
667        ASTNode$State state = state();
668        try {  return Constant.create(cond.booleanValue() ? c1.intValue() : c2.intValue());  }
669        finally {
670        }
671      }
672      /**
673       * @attribute syn
674       * @aspect ConstantExpression
675       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:394
676       */
677      public boolean eqIsTrue(Expr left, Expr right) {
678        ASTNode$State state = state();
679        try {  return left.constant().intValue() == right.constant().intValue();  }
680        finally {
681        }
682      }
683      /**
684       * @attribute syn
685       * @aspect ConstantExpression
686       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:405
687       */
688      public boolean ltIsTrue(Expr left, Expr right) {
689        ASTNode$State state = state();
690        try {  return left.constant().intValue() < right.constant().intValue();  }
691        finally {
692        }
693      }
694      /**
695       * @attribute syn
696       * @aspect ConstantExpression
697       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:411
698       */
699      public boolean leIsTrue(Expr left, Expr right) {
700        ASTNode$State state = state();
701        try {  return left.constant().intValue() <= right.constant().intValue();  }
702        finally {
703        }
704      }
705      /**
706       * @attribute syn
707       * @aspect NameCheck
708       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/NameCheck.jrag:427
709       */
710      public boolean assignableToInt() {
711        ASTNode$State state = state();
712        try {  return true;  }
713        finally {
714        }
715      }
716      /**
717       * @attribute syn
718       * @aspect TypeAnalysis
719       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:177
720       */
721      public boolean isIntegralType() {
722        ASTNode$State state = state();
723        try {  return true;  }
724        finally {
725        }
726      }
727      /**
728       * @apilevel internal
729       */
730      public ASTNode rewriteTo() {
731        return super.rewriteTo();
732      }
733    }