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 public class NewArrayExpr extends Expr 023 { 024 /** 025 * The type of the elements being given zero-default values, or (if 026 * an array initializer is present), the type of the array 027 * initializer elements. 028 * 029 * <p> E.g., new int[4][3][] yields a type of int[] and new int[][][]{a, b} 030 * yields a type of int[][]. 031 */ 032 //@ invariant type.syntax; 033 public /*@ non_null @*/ Type type; 034 035 036 /** 037 * The array initializer, if any. If it is present then dims will 038 * contain exactly 1 element, the inferred size of the array 039 * initializer. 040 * 041 * <p> E.g., new int[][]{7, 5} will generate a dims of {INTLIT(2)}. 042 */ 043 //@ invariant init != null ==> dims.count==1; 044 public ArrayInit init; 045 046 047 /** 048 * If init is null, then holds Expr's between []'s in order. If init 049 * is not null, then holds the inferred array size. (cf. init). 050 * 051 * E.g., new int[x+y][z][] will generate a dims of {<x+y>, <z>}. 052 */ 053 //@ invariant dims.count >= 1; 054 public /*@ non_null @*/ ExprVec dims; 055 056 057 //@ invariant loc != javafe.util.Location.NULL; 058 public int loc; 059 060 061 /** 062 * The locations of the open brackets for each Expr (possibly 063 * inferred if init != null) in dims. 064 * 065 * <p> The open bracket in front of dims[i] is located at 066 * locOpenBrackets[i]. 067 * 068 * @note locOpenBrackets may contain junk after the first 069 * dims.size() entries. 070 */ 071 //@ invariant locOpenBrackets.length >= dims.count; 072 /*@ invariant (\forall int i; (0 <= i && i<dims.count) ==> 073 locOpenBrackets[i] != Location.NULL); */ 074 public /*@ non_null @*/ int[] locOpenBrackets; 075 076 077 public int getStartLoc() { return loc; } 078 079 public int getEndLoc() { 080 if (init == null) { 081 if (dims.size()<1) 082 Assert.fail("Invariant failure: NewArrayExpr with init & dims>0"); 083 return dims.elementAt(dims.size()-1).getEndLoc(); 084 } else return init.locCloseBrace; 085 } 086 087 private void postCheck() { 088 Assert.notFalse(dims.size() >= 1); 089 if (init != null) 090 Assert.notFalse(dims.size()==1); 091 } 092 093 //@ requires init != null ==> dims.count==1; 094 //@ requires dims.count >= 1; 095 //@ requires locOpenBrackets.length >= dims.count; 096 /*@ requires (\forall int i; (0 <= i && i<dims.count) ==> 097 locOpenBrackets[i] != Location.NULL); */ 098 // 099 //@ requires type.syntax; 100 //@ requires loc != javafe.util.Location.NULL; 101 //@ ensures \result != null; 102 public static NewArrayExpr make(/*@ non_null @*/ Type type, 103 /*@ non_null @*/ ExprVec dims, 104 ArrayInit init, 105 int loc, 106 /*@ non_null @*/ int[] locOpenBrackets) { 107 //@ set I_will_establish_invariants_afterwards = true; 108 NewArrayExpr result = new NewArrayExpr(); 109 result.type = type; 110 result.dims = dims; 111 result.init = init; 112 result.loc = loc; 113 result.locOpenBrackets = locOpenBrackets; 114 return result; 115 } 116 117 118 // Generated boilerplate constructors: 119 120 /** 121 * Construct a raw NewArrayExpr whose class invariant(s) have not 122 * yet been established. It is the caller's job to 123 * initialize the returned node's fields so that any 124 * class invariants hold. 125 */ 126 //@ requires I_will_establish_invariants_afterwards; 127 protected NewArrayExpr() {} //@ nowarn Invariant,NonNullInit; 128 129 130 // Generated boilerplate methods: 131 132 public final int childCount() { 133 int sz = 0; 134 if (this.dims != null) sz += this.dims.size(); 135 return sz + 3; 136 } 137 138 public final Object childAt(int index) { 139 /*throws IndexOutOfBoundsException*/ 140 if (index < 0) 141 throw new IndexOutOfBoundsException("AST child index " + index); 142 int indexPre = index; 143 144 int sz; 145 146 if (index == 0) return this.type; 147 else index--; 148 149 if (index == 0) return this.init; 150 else index--; 151 152 sz = (this.dims == null ? 0 : this.dims.size()); 153 if (0 <= index && index < sz) 154 return this.dims.elementAt(index); 155 else index -= sz; 156 157 if (index == 0) return this.locOpenBrackets; 158 else index--; 159 160 throw new IndexOutOfBoundsException("AST child index " + indexPre); 161 } //@ nowarn Exception; 162 163 public final String toString() { 164 return "[NewArrayExpr" 165 + " type = " + this.type 166 + " init = " + this.init 167 + " dims = " + this.dims 168 + " loc = " + this.loc 169 + " locOpenBrackets = " + this.locOpenBrackets 170 + "]"; 171 } 172 173 public final int getTag() { 174 return TagConstants.NEWARRAYEXPR; 175 } 176 177 public final void accept(Visitor v) { v.visitNewArrayExpr(this); } 178 179 public final Object accept(VisitorArgResult v, Object o) {return v.visitNewArrayExpr(this, o); } 180 181 public void check() { 182 super.check(); 183 this.type.check(); 184 if (this.init != null) 185 this.init.check(); 186 for(int i = 0; i < this.dims.size(); i++) 187 this.dims.elementAt(i).check(); 188 if (this.locOpenBrackets == null) throw new RuntimeException(); 189 postCheck(); 190 } 191 192 }