001    /* Copyright 2000, 2001, Compaq Computer Corporation */
002    
003    /* IF THIS IS A JAVA FILE, DO NOT EDIT IT!  
004    
005       Most Java files in this directory which are part of the Javafe AST
006       are automatically generated using the astgen comment (see
007       ESCTools/Javafe/astgen) from the input file 'hierarchy.h'.  If you
008       wish to modify AST classes or introduce new ones, modify
009       'hierarchy.j.'
010     */
011    
012    package javafe.ast;
013    
014    import javafe.util.Assert;
015    import javafe.util.Location;
016    import javafe.util.ErrorSet;
017    
018    // Convention: unless otherwise noted, integer fields named "loc" refer
019    // to the location of the first character of the syntactic unit
020    
021    
022    /**
023     * Represents a Literal.
024     *
025     * <p> The tag of a LiteralExpr should be one of the *LIT (eg INTLIT)
026     * constants defined in TagConstants.  The value fields is a
027     * Character/String/Long/Double/Boolean/null, as appropriate.
028     */
029    
030    public class LiteralExpr extends Expr
031    {
032      /*@ invariant (
033            (tag==TagConstants.BOOLEANLIT) ||
034            (tag==TagConstants.BYTELIT) ||
035            (tag==TagConstants.SHORTLIT) ||
036            (tag==TagConstants.INTLIT) ||
037            (tag==TagConstants.LONGLIT) ||
038            (tag==TagConstants.FLOATLIT) ||
039            (tag==TagConstants.DOUBLELIT) ||
040            (tag==TagConstants.STRINGLIT) ||
041            (tag==TagConstants.NULLLIT) ||
042            (tag==TagConstants.CHARLIT)
043          ); */
044      public int tag;
045    
046    
047      /*@ invariant (
048            ((tag==TagConstants.BOOLEANLIT) ==> (value instanceof Boolean)) &&
049            ((tag==TagConstants.NULLLIT) ==> (value == null)) &&
050            ((tag==TagConstants.BYTELIT) ==> (value instanceof Byte)) &&
051            ((tag==TagConstants.SHORTLIT) ==> (value instanceof Short)) &&
052            ((tag==TagConstants.INTLIT) ==> (value instanceof Integer)) &&
053            ((tag==TagConstants.LONGLIT) ==> (value instanceof Long)) &&
054            ((tag==TagConstants.FLOATLIT) ==> (value instanceof Float)) &&
055            ((tag==TagConstants.DOUBLELIT) ==> (value instanceof Double)) &&
056            ((tag==TagConstants.STRINGLIT) ==> (value instanceof String)) &&
057            ((tag==TagConstants.CHARLIT) ==> (value instanceof Integer))
058          ); */
059      public Object value;
060    
061    
062      //@ invariant loc != javafe.util.Location.NULL;
063      public int loc;
064    
065      public final int getTag() { return this.tag; }
066    
067      private void postCheck() {
068        boolean goodtag =
069          (tag == TagConstants.BOOLEANLIT || tag == TagConstants.INTLIT
070           || tag == TagConstants.LONGLIT || tag == TagConstants.CHARLIT
071           || tag == TagConstants.FLOATLIT || tag == TagConstants.DOUBLELIT
072           || tag == TagConstants.BYTELIT || tag == TagConstants.SHORTLIT
073           || tag == TagConstants.STRINGLIT 
074           || tag == TagConstants.NULLLIT);
075        Assert.notFalse(goodtag);
076        if (tag == TagConstants.BOOLEANLIT && value != null)
077          Assert.notFalse(value instanceof Boolean);
078        if (tag == TagConstants.BYTELIT && value != null)
079          Assert.notFalse(value instanceof Byte);
080        if (tag == TagConstants.SHORTLIT && value != null)
081          Assert.notFalse(value instanceof Short);
082        if (tag == TagConstants.INTLIT && value != null)
083          Assert.notFalse(value instanceof Integer);
084        if (tag == TagConstants.LONGLIT && value != null)
085          Assert.notFalse(value instanceof Long);
086        if (tag == TagConstants.CHARLIT && value != null)
087          Assert.notFalse(value instanceof Integer);
088        if (tag == TagConstants.FLOATLIT && value != null)
089          Assert.notFalse(value instanceof Float);
090        if (tag == TagConstants.DOUBLELIT && value != null)
091          Assert.notFalse(value instanceof Double);
092        if (tag == TagConstants.STRINGLIT && value != null)
093          Assert.notFalse(value instanceof String);
094        if (tag == TagConstants.NULLLIT) Assert.notFalse(value == null);
095      }
096      public int getStartLoc() { return loc; }
097      public int getEndLoc() { return loc; }
098    
099      static public LiteralExpr cast(LiteralExpr lit, int t) {
100            if (!(lit.value instanceof Number)) return lit;
101            Number num = (Number)lit.value;
102            if (t == TagConstants.DOUBLELIT) {
103                return LiteralExpr.make(t,new Double(num.doubleValue()),lit.getStartLoc());
104            } else if (t == TagConstants.FLOATLIT) {
105                return LiteralExpr.make(t,new Float(num.floatValue()),lit.getStartLoc());
106            } else if (t == TagConstants.LONGLIT) {
107                return LiteralExpr.make(t,new Long(num.longValue()),lit.getStartLoc());
108            } else if (t == TagConstants.INTLIT) {
109                return LiteralExpr.make(t,new Integer(num.intValue()),lit.getStartLoc());
110            } else if (t == TagConstants.SHORTLIT) {
111                return LiteralExpr.make(t,new Short(num.shortValue()),lit.getStartLoc());
112            } else if (t == TagConstants.BYTELIT) {
113                return LiteralExpr.make(t,new Integer(num.byteValue()),lit.getStartLoc());
114            } else return lit;
115            // FIXME - what about casts to character values ???
116      }
117    
118      // Note: Java does not actually have byte and short literals.
119      // We include them here because we pre-compute literals that have been
120      // cast to other types, e.g. (short)0, as a literal of the target type
121      // FIXME - short and byte are included for completeness, but I'm not sure they actually ever get used that way
122    
123      /*@ requires (
124            (tag==TagConstants.BOOLEANLIT) ||
125            (tag==TagConstants.INTLIT) ||
126            (tag==TagConstants.LONGLIT) ||
127            (tag==TagConstants.FLOATLIT) ||
128            (tag==TagConstants.DOUBLELIT) ||
129            (tag==TagConstants.BYTELIT) ||
130            (tag==TagConstants.SHORTLIT) ||
131            (tag==TagConstants.STRINGLIT) ||
132            (tag==TagConstants.NULLLIT) ||
133            (tag==TagConstants.CHARLIT)
134          ); */
135      /*@ requires (
136            ((tag==TagConstants.BOOLEANLIT) ==> (value instanceof Boolean)) &&
137            ((tag==TagConstants.NULLLIT) ==> (value == null)) &&
138            ((tag==TagConstants.BYTELIT) ==> (value instanceof Byte)) &&
139            ((tag==TagConstants.SHORTLIT) ==> (value instanceof Short)) &&
140            ((tag==TagConstants.INTLIT) ==> (value instanceof Integer)) &&
141            ((tag==TagConstants.LONGLIT) ==> (value instanceof Long)) &&
142            ((tag==TagConstants.FLOATLIT) ==> (value instanceof Float)) &&
143            ((tag==TagConstants.DOUBLELIT) ==> (value instanceof Double)) &&
144            ((tag==TagConstants.STRINGLIT) ==> (value instanceof String)) &&
145            ((tag==TagConstants.CHARLIT) ==> (value instanceof Integer))
146          ); */
147      //
148      //@ requires loc != javafe.util.Location.NULL;
149      //@ ensures \result != null;
150      public static LiteralExpr make(int tag, Object value, int loc) {
151         //@ set I_will_establish_invariants_afterwards = true;
152         LiteralExpr result = new LiteralExpr();
153         result.tag = tag;
154         result.value = value;
155         result.loc = loc;
156         return result;
157      }
158    
159    
160    // Generated boilerplate constructors:
161    
162      /**
163       * Construct a raw LiteralExpr whose class invariant(s) have not
164       * yet been established.  It is the caller's job to
165       * initialize the returned node's fields so that any
166       * class invariants hold.
167       */
168      //@ requires I_will_establish_invariants_afterwards;
169      protected LiteralExpr() {}    //@ nowarn Invariant,NonNullInit;
170    
171    
172    // Generated boilerplate methods:
173    
174      public final int childCount() {
175         return 1;
176      }
177    
178      public final Object childAt(int index) {
179              /*throws IndexOutOfBoundsException*/
180         if (index < 0)
181            throw new IndexOutOfBoundsException("AST child index " + index);
182         int indexPre = index;
183    
184         int sz;
185    
186         if (index == 0) return this.value;
187         else index--;
188    
189         throw new IndexOutOfBoundsException("AST child index " + indexPre);
190      }   //@ nowarn Exception;
191    
192      public final String toString() {
193         return "[LiteralExpr"
194            + " tag = " + this.tag
195            + " value = " + this.value
196            + " loc = " + this.loc
197            + "]";
198      }
199    
200      public final void accept(Visitor v) { v.visitLiteralExpr(this); }
201    
202      public final Object accept(VisitorArgResult v, Object o) {return v.visitLiteralExpr(this, o); }
203    
204      public void check() {
205         super.check();
206         postCheck();
207      }
208    
209    }