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 FloatType : {@link FloatingPointType};
015     * @ast node
016     * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/java.ast:62
017     */
018    public class FloatType extends FloatingPointType 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 FloatType clone() throws CloneNotSupportedException {
034        FloatType node = (FloatType)super.clone();
035        node.typeDescriptor_computed = false;
036        node.typeDescriptor_value = null;
037        node.jvmName_computed = false;
038        node.jvmName_value = null;
039        node.boxed_computed = false;
040        node.boxed_value = null;
041        node.in$Circle(false);
042        node.is$Final(false);
043        return node;
044      }
045    /**
046     * @apilevel internal
047     */
048      @SuppressWarnings({"unchecked", "cast"})
049    public FloatType copy() {
050      
051      try {
052        FloatType node = (FloatType) clone();
053        node.parent = null;
054        if(children != null)
055          node.children = (ASTNode[]) children.clone();
056        
057        return node;
058      } catch (CloneNotSupportedException e) {
059        throw new Error("Error: clone not supported for " + getClass().getName());
060      }
061      
062    }/**
063     * Create a deep copy of the AST subtree at this node.
064     * The copy is dangling, i.e. has no parent.
065     * @return dangling copy of the subtree at this node
066     * @apilevel low-level
067     */
068      @SuppressWarnings({"unchecked", "cast"})
069    public FloatType fullCopy() {
070      
071      FloatType tree = (FloatType) copy();
072      if (children != null) {
073        for (int i = 0; i < children.length; ++i) {
074          
075          ASTNode child = (ASTNode) children[i];
076          if(child != null) {
077            child = child.fullCopy();
078            tree.setChild(child, i);
079          }
080        }
081      }
082      return tree;
083      
084    }  /**
085       * @ast method 
086       * @aspect PrettyPrint
087       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/PrettyPrint.jadd:850
088       */
089      public void toString(StringBuffer s) {
090                s.append("float");
091        }
092      /**
093       * @ast method 
094       * @aspect Attributes
095       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/Attributes.jrag:65
096       */
097      public int addConstant(ConstantPool p, Constant c)    { return p.addConstant(c.floatValue()); }
098      /**
099       * @ast method 
100       * @aspect CodeGeneration
101       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:546
102       */
103      public void emitPushConstant(CodeGeneration gen, int value) { FloatingPointLiteral.push(gen, value); }
104      /**
105       * @ast method 
106       * @aspect CodeGeneration
107       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:616
108       */
109      public void emitReturn(CodeGeneration gen)     { gen.emit(Bytecode.FRETURN);}
110      /**
111       * @ast method 
112       * @aspect CodeGeneration
113       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:653
114       */
115      public void emitLoadLocal(CodeGeneration gen, int pos) {
116        gen.maxLocals = Math.max(gen.maxLocals, pos+1);
117        if(pos == 0) gen.emit(Bytecode.FLOAD_0);
118        else if(pos == 1) gen.emit(Bytecode.FLOAD_1);
119        else if(pos == 2) gen.emit(Bytecode.FLOAD_2);
120        else if(pos == 3) gen.emit(Bytecode.FLOAD_3);
121        else if(pos < 256) gen.emit(Bytecode.FLOAD).add(pos);
122        else gen.emit(Bytecode.WIDE).emit(Bytecode.FLOAD).add2(pos);
123      }
124      /**
125       * @ast method 
126       * @aspect CodeGeneration
127       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:766
128       */
129      public void emitStoreLocal(CodeGeneration gen, int pos) {
130        gen.maxLocals = Math.max(gen.maxLocals, pos+1);
131        if(pos == 0) gen.emit(Bytecode.FSTORE_0);
132        else if(pos == 1) gen.emit(Bytecode.FSTORE_1);
133        else if(pos == 2) gen.emit(Bytecode.FSTORE_2);
134        else if(pos == 3) gen.emit(Bytecode.FSTORE_3);
135        else if(pos < 256) gen.emit(Bytecode.FSTORE).add(pos);
136        else gen.emit(Bytecode.WIDE).emit(Bytecode.FSTORE).add2(pos);
137      }
138      /**
139       * @ast method 
140       * @aspect CodeGenerationConversions
141       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:944
142       */
143      void emitCastTo(CodeGeneration gen, TypeDecl type)    { type.floatToThis(gen); }
144      /**
145       * @ast method 
146       * @aspect CodeGenerationConversions
147       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:956
148       */
149      void intToThis(CodeGeneration gen)  { gen.emit(Bytecode.I2F); }
150      /**
151       * @ast method 
152       * @aspect CodeGenerationConversions
153       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:967
154       */
155      void floatToThis(CodeGeneration gen)  { }
156      /**
157       * @ast method 
158       * @aspect CodeGenerationConversions
159       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:976
160       */
161      void doubleToThis(CodeGeneration gen)  { gen.emit(Bytecode.D2F); }
162      /**
163       * @ast method 
164       * @aspect CodeGenerationConversions
165       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:985
166       */
167      void longToThis(CodeGeneration gen)  { gen.emit(Bytecode.L2F); }
168      /**
169       * @ast method 
170       * @aspect CodeGenerationConversions
171       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:992
172       */
173      void byteToThis(CodeGeneration gen)    { gen.emit(Bytecode.I2F); }
174      /**
175       * @ast method 
176       * @aspect CodeGenerationConversions
177       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1000
178       */
179      void charToThis(CodeGeneration gen)    { gen.emit(Bytecode.I2F); }
180      /**
181       * @ast method 
182       * @aspect CodeGenerationConversions
183       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1008
184       */
185      void shortToThis(CodeGeneration gen)    { gen.emit(Bytecode.I2F); }
186      /**
187       * @ast method 
188       * @aspect CodeGenerationBinaryOperations
189       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1040
190       */
191      void neg(CodeGeneration gen)    { gen.emit(Bytecode.FNEG); }
192      /**
193       * @ast method 
194       * @aspect CodeGenerationBinaryOperations
195       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1052
196       */
197      void add(CodeGeneration gen) {gen.emit(Bytecode.FADD);}
198      /**
199       * @ast method 
200       * @aspect CodeGenerationBinaryOperations
201       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1058
202       */
203      void sub(CodeGeneration gen) {gen.emit(Bytecode.FSUB);}
204      /**
205       * @ast method 
206       * @aspect CodeGenerationBinaryOperations
207       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1064
208       */
209      void mul(CodeGeneration gen) {gen.emit(Bytecode.FMUL);}
210      /**
211       * @ast method 
212       * @aspect CodeGenerationBinaryOperations
213       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1070
214       */
215      void div(CodeGeneration gen) {gen.emit(Bytecode.FDIV);}
216      /**
217       * @ast method 
218       * @aspect CodeGenerationBinaryOperations
219       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1076
220       */
221      void rem(CodeGeneration gen) {gen.emit(Bytecode.FREM);}
222      /**
223       * @ast method 
224       * @aspect CodeGenerationBranch
225       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1111
226       */
227      public void branchLT(CodeGeneration gen, int label)    { gen.emit(Bytecode.FCMPG).emitCompare(Bytecode.IFLT, label); }
228      /**
229       * @ast method 
230       * @aspect CodeGenerationBranch
231       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1117
232       */
233      public void branchLE(CodeGeneration gen, int label)    { gen.emit(Bytecode.FCMPG).emitCompare(Bytecode.IFLE, label); }
234      /**
235       * @ast method 
236       * @aspect CodeGenerationBranch
237       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1123
238       */
239      public void branchGE(CodeGeneration gen, int label)    { gen.emit(Bytecode.FCMPL).emitCompare(Bytecode.IFGE, label); }
240      /**
241       * @ast method 
242       * @aspect CodeGenerationBranch
243       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1129
244       */
245      public void branchGT(CodeGeneration gen, int label)    { gen.emit(Bytecode.FCMPL).emitCompare(Bytecode.IFGT, label); }
246      /**
247       * @ast method 
248       * @aspect CodeGenerationBranch
249       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1135
250       */
251      public void branchEQ(CodeGeneration gen, int label)     { gen.emit(Bytecode.FCMPL).emitCompare(Bytecode.IFEQ, label); }
252      /**
253       * @ast method 
254       * @aspect CodeGenerationBranch
255       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:1144
256       */
257      public void branchNE(CodeGeneration gen, int label)     { gen.emit(Bytecode.FCMPL).emitCompare(Bytecode.IFNE, label); }
258      /**
259       * @ast method 
260       * @aspect AnnotationsCodegen
261       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Backend/AnnotationsCodegen.jrag:186
262       */
263      public int addAnnotConstant(ConstantPool p, Constant c) {
264        return addConstant(p, c);
265      }
266      /**
267       * @ast method 
268       * 
269       */
270      public FloatType() {
271        super();
272    
273    
274      }
275      /**
276       * Initializes the child array to the correct size.
277       * Initializes List and Opt nta children.
278       * @apilevel internal
279       * @ast method
280       * @ast method 
281       * 
282       */
283      public void init$Children() {
284        children = new ASTNode[3];
285        setChild(new Opt(), 1);
286        setChild(new List(), 2);
287      }
288      /**
289       * @ast method 
290       * 
291       */
292      public FloatType(Modifiers p0, String p1, Opt<Access> p2, List<BodyDecl> p3) {
293        setChild(p0, 0);
294        setID(p1);
295        setChild(p2, 1);
296        setChild(p3, 2);
297      }
298      /**
299       * @ast method 
300       * 
301       */
302      public FloatType(Modifiers p0, beaver.Symbol p1, Opt<Access> p2, List<BodyDecl> p3) {
303        setChild(p0, 0);
304        setID(p1);
305        setChild(p2, 1);
306        setChild(p3, 2);
307      }
308      /**
309       * @apilevel low-level
310       * @ast method 
311       * 
312       */
313      protected int numChildren() {
314        return 3;
315      }
316      /**
317       * @apilevel internal
318       * @ast method 
319       * 
320       */
321      public boolean mayHaveRewrite() {
322        return false;
323      }
324      /**
325       * Replaces the Modifiers child.
326       * @param node The new node to replace the Modifiers child.
327       * @apilevel high-level
328       * @ast method 
329       * 
330       */
331      public void setModifiers(Modifiers node) {
332        setChild(node, 0);
333      }
334      /**
335       * Retrieves the Modifiers child.
336       * @return The current node used as the Modifiers child.
337       * @apilevel high-level
338       * @ast method 
339       * 
340       */
341      public Modifiers getModifiers() {
342        return (Modifiers)getChild(0);
343      }
344      /**
345       * Retrieves the Modifiers child.
346       * <p><em>This method does not invoke AST transformations.</em></p>
347       * @return The current node used as the Modifiers child.
348       * @apilevel low-level
349       * @ast method 
350       * 
351       */
352      public Modifiers getModifiersNoTransform() {
353        return (Modifiers)getChildNoTransform(0);
354      }
355      /**
356       * Replaces the lexeme ID.
357       * @param value The new value for the lexeme ID.
358       * @apilevel high-level
359       * @ast method 
360       * 
361       */
362      public void setID(String value) {
363        tokenString_ID = value;
364      }
365      /**
366       * JastAdd-internal setter for lexeme ID using the Beaver parser.
367       * @apilevel internal
368       * @ast method 
369       * 
370       */
371      public void setID(beaver.Symbol symbol) {
372        if(symbol.value != null && !(symbol.value instanceof String))
373          throw new UnsupportedOperationException("setID is only valid for String lexemes");
374        tokenString_ID = (String)symbol.value;
375        IDstart = symbol.getStart();
376        IDend = symbol.getEnd();
377      }
378      /**
379       * Retrieves the value for the lexeme ID.
380       * @return The value for the lexeme ID.
381       * @apilevel high-level
382       * @ast method 
383       * 
384       */
385      public String getID() {
386        return tokenString_ID != null ? tokenString_ID : "";
387      }
388      /**
389       * Replaces the optional node for the SuperClassAccess child. This is the {@code Opt} node containing the child SuperClassAccess, not the actual child!
390       * @param opt The new node to be used as the optional node for the SuperClassAccess child.
391       * @apilevel low-level
392       * @ast method 
393       * 
394       */
395      public void setSuperClassAccessOpt(Opt<Access> opt) {
396        setChild(opt, 1);
397      }
398      /**
399       * Check whether the optional SuperClassAccess child exists.
400       * @return {@code true} if the optional SuperClassAccess child exists, {@code false} if it does not.
401       * @apilevel high-level
402       * @ast method 
403       * 
404       */
405      public boolean hasSuperClassAccess() {
406        return getSuperClassAccessOpt().getNumChild() != 0;
407      }
408      /**
409       * Retrieves the (optional) SuperClassAccess child.
410       * @return The SuperClassAccess child, if it exists. Returns {@code null} otherwise.
411       * @apilevel low-level
412       * @ast method 
413       * 
414       */
415      @SuppressWarnings({"unchecked", "cast"})
416      public Access getSuperClassAccess() {
417        return (Access)getSuperClassAccessOpt().getChild(0);
418      }
419      /**
420       * Replaces the (optional) SuperClassAccess child.
421       * @param node The new node to be used as the SuperClassAccess child.
422       * @apilevel high-level
423       * @ast method 
424       * 
425       */
426      public void setSuperClassAccess(Access node) {
427        getSuperClassAccessOpt().setChild(node, 0);
428      }
429      /**
430       * @apilevel low-level
431       * @ast method 
432       * 
433       */
434      @SuppressWarnings({"unchecked", "cast"})
435      public Opt<Access> getSuperClassAccessOpt() {
436        return (Opt<Access>)getChild(1);
437      }
438      /**
439       * Retrieves the optional node for child SuperClassAccess. This is the {@code Opt} node containing the child SuperClassAccess, not the actual child!
440       * <p><em>This method does not invoke AST transformations.</em></p>
441       * @return The optional node for child SuperClassAccess.
442       * @apilevel low-level
443       * @ast method 
444       * 
445       */
446      @SuppressWarnings({"unchecked", "cast"})
447      public Opt<Access> getSuperClassAccessOptNoTransform() {
448        return (Opt<Access>)getChildNoTransform(1);
449      }
450      /**
451       * Replaces the BodyDecl list.
452       * @param list The new list node to be used as the BodyDecl list.
453       * @apilevel high-level
454       * @ast method 
455       * 
456       */
457      public void setBodyDeclList(List<BodyDecl> list) {
458        setChild(list, 2);
459      }
460      /**
461       * Retrieves the number of children in the BodyDecl list.
462       * @return Number of children in the BodyDecl list.
463       * @apilevel high-level
464       * @ast method 
465       * 
466       */
467      public int getNumBodyDecl() {
468        return getBodyDeclList().getNumChild();
469      }
470      /**
471       * Retrieves the number of children in the BodyDecl list.
472       * Calling this method will not trigger rewrites..
473       * @return Number of children in the BodyDecl list.
474       * @apilevel low-level
475       * @ast method 
476       * 
477       */
478      public int getNumBodyDeclNoTransform() {
479        return getBodyDeclListNoTransform().getNumChildNoTransform();
480      }
481      /**
482       * Retrieves the element at index {@code i} in the BodyDecl list..
483       * @param i Index of the element to return.
484       * @return The element at position {@code i} in the BodyDecl list.
485       * @apilevel high-level
486       * @ast method 
487       * 
488       */
489      @SuppressWarnings({"unchecked", "cast"})
490      public BodyDecl getBodyDecl(int i) {
491        return (BodyDecl)getBodyDeclList().getChild(i);
492      }
493      /**
494       * Append an element to the BodyDecl list.
495       * @param node The element to append to the BodyDecl list.
496       * @apilevel high-level
497       * @ast method 
498       * 
499       */
500      public void addBodyDecl(BodyDecl node) {
501        List<BodyDecl> list = (parent == null || state == null) ? getBodyDeclListNoTransform() : getBodyDeclList();
502        list.addChild(node);
503      }
504      /**
505       * @apilevel low-level
506       * @ast method 
507       * 
508       */
509      public void addBodyDeclNoTransform(BodyDecl node) {
510        List<BodyDecl> list = getBodyDeclListNoTransform();
511        list.addChild(node);
512      }
513      /**
514       * Replaces the BodyDecl list element at index {@code i} with the new node {@code node}.
515       * @param node The new node to replace the old list element.
516       * @param i The list index of the node to be replaced.
517       * @apilevel high-level
518       * @ast method 
519       * 
520       */
521      public void setBodyDecl(BodyDecl node, int i) {
522        List<BodyDecl> list = getBodyDeclList();
523        list.setChild(node, i);
524      }
525      /**
526       * Retrieves the BodyDecl list.
527       * @return The node representing the BodyDecl list.
528       * @apilevel high-level
529       * @ast method 
530       * 
531       */
532      public List<BodyDecl> getBodyDecls() {
533        return getBodyDeclList();
534      }
535      /**
536       * Retrieves the BodyDecl list.
537       * <p><em>This method does not invoke AST transformations.</em></p>
538       * @return The node representing the BodyDecl list.
539       * @apilevel low-level
540       * @ast method 
541       * 
542       */
543      public List<BodyDecl> getBodyDeclsNoTransform() {
544        return getBodyDeclListNoTransform();
545      }
546      /**
547       * Retrieves the BodyDecl list.
548       * @return The node representing the BodyDecl list.
549       * @apilevel high-level
550       * @ast method 
551       * 
552       */
553      @SuppressWarnings({"unchecked", "cast"})
554      public List<BodyDecl> getBodyDeclList() {
555        List<BodyDecl> list = (List<BodyDecl>)getChild(2);
556        list.getNumChild();
557        return list;
558      }
559      /**
560       * Retrieves the BodyDecl list.
561       * <p><em>This method does not invoke AST transformations.</em></p>
562       * @return The node representing the BodyDecl list.
563       * @apilevel low-level
564       * @ast method 
565       * 
566       */
567      @SuppressWarnings({"unchecked", "cast"})
568      public List<BodyDecl> getBodyDeclListNoTransform() {
569        return (List<BodyDecl>)getChildNoTransform(2);
570      }
571      /**
572       * @attribute syn
573       * @aspect ConstantExpression
574       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:160
575       */
576      public Constant cast(Constant c) {
577        ASTNode$State state = state();
578        try {  return Constant.create(c.floatValue());  }
579        finally {
580        }
581      }
582      /**
583       * @attribute syn
584       * @aspect ConstantExpression
585       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:174
586       */
587      public Constant plus(Constant c) {
588        ASTNode$State state = state();
589        try {  return c;  }
590        finally {
591        }
592      }
593      /**
594       * @attribute syn
595       * @aspect ConstantExpression
596       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:183
597       */
598      public Constant minus(Constant c) {
599        ASTNode$State state = state();
600        try {  return Constant.create(-c.floatValue());  }
601        finally {
602        }
603      }
604      /**
605       * @attribute syn
606       * @aspect ConstantExpression
607       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:199
608       */
609      public Constant mul(Constant c1, Constant c2) {
610        ASTNode$State state = state();
611        try {  return Constant.create(c1.floatValue() * c2.floatValue());  }
612        finally {
613        }
614      }
615      /**
616       * @attribute syn
617       * @aspect ConstantExpression
618       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:208
619       */
620      public Constant div(Constant c1, Constant c2) {
621        ASTNode$State state = state();
622        try {  return Constant.create(c1.floatValue() / c2.floatValue());  }
623        finally {
624        }
625      }
626      /**
627       * @attribute syn
628       * @aspect ConstantExpression
629       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:217
630       */
631      public Constant mod(Constant c1, Constant c2) {
632        ASTNode$State state = state();
633        try {  return Constant.create(c1.floatValue() % c2.floatValue());  }
634        finally {
635        }
636      }
637      /**
638       * @attribute syn
639       * @aspect ConstantExpression
640       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:226
641       */
642      public Constant add(Constant c1, Constant c2) {
643        ASTNode$State state = state();
644        try {  return Constant.create(c1.floatValue() + c2.floatValue());  }
645        finally {
646        }
647      }
648      /**
649       * @attribute syn
650       * @aspect ConstantExpression
651       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:236
652       */
653      public Constant sub(Constant c1, Constant c2) {
654        ASTNode$State state = state();
655        try {  return Constant.create(c1.floatValue() - c2.floatValue());  }
656        finally {
657        }
658      }
659      /**
660       * @attribute syn
661       * @aspect ConstantExpression
662       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:290
663       */
664      public Constant questionColon(Constant cond, Constant c1, Constant c2) {
665        ASTNode$State state = state();
666        try {  return Constant.create(cond.booleanValue() ? c1.floatValue() : c2.floatValue());  }
667        finally {
668        }
669      }
670      /**
671       * @attribute syn
672       * @aspect ConstantExpression
673       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:394
674       */
675      public boolean eqIsTrue(Expr left, Expr right) {
676        ASTNode$State state = state();
677        try {  return left.constant().floatValue() == right.constant().floatValue();  }
678        finally {
679        }
680      }
681      /**
682       * @attribute syn
683       * @aspect ConstantExpression
684       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:405
685       */
686      public boolean ltIsTrue(Expr left, Expr right) {
687        ASTNode$State state = state();
688        try {  return left.constant().floatValue() < right.constant().floatValue();  }
689        finally {
690        }
691      }
692      /**
693       * @attribute syn
694       * @aspect ConstantExpression
695       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:411
696       */
697      public boolean leIsTrue(Expr left, Expr right) {
698        ASTNode$State state = state();
699        try {  return left.constant().floatValue() <= right.constant().floatValue();  }
700        finally {
701        }
702      }
703      /**
704       * @attribute syn
705       * @aspect TypeAnalysis
706       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:195
707       */
708      public boolean isFloat() {
709        ASTNode$State state = state();
710        try {  return true;  }
711        finally {
712        }
713      }
714      /**
715       * @attribute syn
716       * @aspect CodeGeneration
717       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:621
718       */
719      public byte arrayLoad() {
720        ASTNode$State state = state();
721        try {  return Bytecode.FALOAD;  }
722        finally {
723        }
724      }
725      /**
726       * @attribute syn
727       * @aspect CodeGeneration
728       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:723
729       */
730      public byte arrayStore() {
731        ASTNode$State state = state();
732        try {  return Bytecode.FASTORE;  }
733        finally {
734        }
735      }
736      /**
737       * @apilevel internal
738       */
739      protected boolean typeDescriptor_computed = false;
740      /**
741       * @apilevel internal
742       */
743      protected String typeDescriptor_value;
744      /**
745       * @attribute syn
746       * @aspect ConstantPoolNames
747       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/ConstantPoolNames.jrag:23
748       */
749      @SuppressWarnings({"unchecked", "cast"})
750      public String typeDescriptor() {
751        if(typeDescriptor_computed) {
752          return typeDescriptor_value;
753        }
754          ASTNode$State state = state();
755      int num = state.boundariesCrossed;
756      boolean isFinal = this.is$Final();
757        typeDescriptor_value = typeDescriptor_compute();
758      if(isFinal && num == state().boundariesCrossed){ typeDescriptor_computed = true; }
759            return typeDescriptor_value;
760      }
761      /**
762       * @apilevel internal
763       */
764      private String typeDescriptor_compute() {  return "F";  }
765      /**
766       * @attribute syn
767       * @aspect CreateBCode
768       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:825
769       */
770      public int arrayPrimitiveTypeDescriptor() {
771        ASTNode$State state = state();
772        try {  return 6;  }
773        finally {
774        }
775      }
776      /**
777       * @apilevel internal
778       */
779      protected boolean jvmName_computed = false;
780      /**
781       * @apilevel internal
782       */
783      protected String jvmName_value;
784      /**
785       * @attribute syn
786       * @aspect Java2Rewrites
787       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/Java2Rewrites.jrag:40
788       */
789      @SuppressWarnings({"unchecked", "cast"})
790      public String jvmName() {
791        if(jvmName_computed) {
792          return jvmName_value;
793        }
794          ASTNode$State state = state();
795      int num = state.boundariesCrossed;
796      boolean isFinal = this.is$Final();
797        jvmName_value = jvmName_compute();
798      if(isFinal && num == state().boundariesCrossed){ jvmName_computed = true; }
799            return jvmName_value;
800      }
801      /**
802       * @apilevel internal
803       */
804      private String jvmName_compute() {  return "F";  }
805      /**
806       * @attribute syn
807       * @aspect Java2Rewrites
808       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/Java2Rewrites.jrag:44
809       */
810      public String primitiveClassName() {
811        ASTNode$State state = state();
812        try {  return "Float";  }
813        finally {
814        }
815      }
816      /**
817       * @apilevel internal
818       */
819      protected boolean boxed_computed = false;
820      /**
821       * @apilevel internal
822       */
823      protected TypeDecl boxed_value;
824      /**
825       * @attribute syn
826       * @aspect AutoBoxing
827       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/AutoBoxing.jrag:42
828       */
829      @SuppressWarnings({"unchecked", "cast"})
830      public TypeDecl boxed() {
831        if(boxed_computed) {
832          return boxed_value;
833        }
834          ASTNode$State state = state();
835      int num = state.boundariesCrossed;
836      boolean isFinal = this.is$Final();
837        boxed_value = boxed_compute();
838      if(isFinal && num == state().boundariesCrossed){ boxed_computed = true; }
839            return boxed_value;
840      }
841      /**
842       * @apilevel internal
843       */
844      private TypeDecl boxed_compute() {  return lookupType("java.lang", "Float");  }
845      /**
846       * @apilevel internal
847       */
848      public ASTNode rewriteTo() {
849        return super.rewriteTo();
850      }
851    }