1 /* 2 * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package com.sun.codemodel.internal; 27 28 29 /** 30 * Factory methods that generate various {@link JExpression}s. 31 */ 32 public abstract class JExpr { 33 34 /** 35 * This class is not instanciable. 36 */ 37 private JExpr() { } 38 39 public static JExpression assign(JAssignmentTarget lhs, JExpression rhs) { 40 return new JAssignment(lhs, rhs); 41 } 42 43 public static JExpression assignPlus(JAssignmentTarget lhs, JExpression rhs) { 44 return new JAssignment(lhs, rhs, "+"); 45 } 46 47 public static JInvocation _new(JClass c) { 48 return new JInvocation(c); 49 } 50 51 public static JInvocation _new(JType t) { 52 return new JInvocation(t); 53 } 54 55 public static JInvocation invoke(String method) { 56 return new JInvocation((JExpression)null, method); 57 } 58 59 public static JInvocation invoke(JMethod method) { 60 return new JInvocation((JExpression)null,method); 61 } 62 63 public static JInvocation invoke(JExpression lhs, JMethod method) { 64 return new JInvocation(lhs, method); 65 } 66 67 public static JInvocation invoke(JExpression lhs, String method) { 68 return new JInvocation(lhs, method); 69 } 70 71 public static JFieldRef ref(String field) { 72 return new JFieldRef((JExpression)null, field); 73 } 74 75 public static JFieldRef ref(JExpression lhs, JVar field) { 76 return new JFieldRef(lhs,field); 77 } 78 79 public static JFieldRef ref(JExpression lhs, String field) { 80 return new JFieldRef(lhs, field); 81 } 82 83 public static JFieldRef refthis(String field) { 84 return new JFieldRef(null, field, true); 85 } 86 87 public static JExpression dotclass(final JClass cl) { 88 return new JExpressionImpl() { 89 public void generate(JFormatter f) { 90 JClass c; 91 if(cl instanceof JNarrowedClass) 92 c = ((JNarrowedClass)cl).basis; 93 else 94 c = cl; 95 f.g(c).p(".class"); 96 } 97 }; 98 } 99 100 public static JArrayCompRef component(JExpression lhs, JExpression index) { 101 return new JArrayCompRef(lhs, index); 102 } 103 104 public static JCast cast(JType type, JExpression expr) { 105 return new JCast(type, expr); 106 } 107 108 public static JArray newArray(JType type) { 109 return newArray(type,null); 110 } 111 112 /** 113 * Generates {@code new T[size]}. 114 * 115 * @param type 116 * The type of the array component. 'T' or {@code new T[size]}. 117 */ 118 public static JArray newArray(JType type, JExpression size) { 119 // you cannot create an array whose component type is a generic 120 return new JArray(type.erasure(), size); 121 } 122 123 /** 124 * Generates {@code new T[size]}. 125 * 126 * @param type 127 * The type of the array component. 'T' or {@code new T[size]}. 128 */ 129 public static JArray newArray(JType type, int size) { 130 return newArray(type,lit(size)); 131 } 132 133 134 private static final JExpression __this = new JAtom("this"); 135 /** 136 * Returns a reference to "this", an implicit reference 137 * to the current object. 138 */ 139 public static JExpression _this() { return __this; } 140 141 private static final JExpression __super = new JAtom("super"); 142 /** 143 * Returns a reference to "super", an implicit reference 144 * to the super class. 145 */ 146 public static JExpression _super() { return __super; } 147 148 149 /* -- Literals -- */ 150 151 private static final JExpression __null = new JAtom("null"); 152 public static JExpression _null() { 153 return __null; 154 } 155 156 /** 157 * Boolean constant that represents <code>true</code> 158 */ 159 public static final JExpression TRUE = new JAtom("true"); 160 161 /** 162 * Boolean constant that represents <code>false</code> 163 */ 164 public static final JExpression FALSE = new JAtom("false"); 165 166 public static JExpression lit(boolean b) { 167 return b?TRUE:FALSE; 168 } 169 170 public static JExpression lit(int n) { 171 return new JAtom(Integer.toString(n)); 172 } 173 174 public static JExpression lit(long n) { 175 return new JAtom(Long.toString(n) + "L"); 176 } 177 178 public static JExpression lit(float f) { 179 if (f == Float.NEGATIVE_INFINITY) 180 { 181 return new JAtom("java.lang.Float.NEGATIVE_INFINITY"); 182 } 183 else if (f == Float.POSITIVE_INFINITY) 184 { 185 return new JAtom("java.lang.Float.POSITIVE_INFINITY"); 186 } 187 else if (Float.isNaN(f)) 188 { 189 return new JAtom("java.lang.Float.NaN"); 190 } 191 else 192 { 193 return new JAtom(Float.toString(f) + "F"); 194 } 195 } 196 197 public static JExpression lit(double d) { 198 if (d == Double.NEGATIVE_INFINITY) 199 { 200 return new JAtom("java.lang.Double.NEGATIVE_INFINITY"); 201 } 202 else if (d == Double.POSITIVE_INFINITY) 203 { 204 return new JAtom("java.lang.Double.POSITIVE_INFINITY"); 205 } 206 else if (Double.isNaN(d)) 207 { 208 return new JAtom("java.lang.Double.NaN"); 209 } 210 else 211 { 212 return new JAtom(Double.toString(d) + "D"); 213 } 214 } 215 216 static final String charEscape = "\b\t\n\f\r\"\'\\"; 217 static final String charMacro = "btnfr\"'\\"; 218 219 /** 220 * Escapes the given string, then surrounds it by the specified 221 * quotation mark. 222 */ 223 public static String quotify(char quote, String s) { 224 int n = s.length(); 225 StringBuilder sb = new StringBuilder(n + 2); 226 sb.append(quote); 227 for (int i = 0; i < n; i++) { 228 char c = s.charAt(i); 229 int j = charEscape.indexOf(c); 230 if(j>=0) { 231 if((quote=='"' && c=='\'') || (quote=='\'' && c=='"')) { 232 sb.append(c); 233 } else { 234 sb.append('\\'); 235 sb.append(charMacro.charAt(j)); 236 } 237 } else { 238 // technically Unicode escape shouldn't be done here, 239 // for it's a lexical level handling. 240 // 241 // However, various tools are so broken around this area, 242 // so just to be on the safe side, it's better to do 243 // the escaping here (regardless of the actual file encoding) 244 // 245 // see bug 246 if( c<0x20 || 0x7E<c ) { 247 // not printable. use Unicode escape 248 sb.append("\\u"); 249 String hex = Integer.toHexString(((int)c)&0xFFFF); 250 for( int k=hex.length(); k<4; k++ ) 251 sb.append('0'); 252 sb.append(hex); 253 } else { 254 sb.append(c); 255 } 256 } 257 } 258 sb.append(quote); 259 return sb.toString(); 260 } 261 262 public static JExpression lit(char c) { 263 return new JAtom(quotify('\'', "" + c)); 264 } 265 266 public static JExpression lit(String s) { 267 return new JStringLiteral(s); 268 } 269 270 /** 271 * Creates an expression directly from a source code fragment. 272 * 273 * <p> 274 * This method can be used as a short-cut to create a JExpression. 275 * For example, instead of <code>_a.gt(_b)</code>, you can write 276 * it as: {@code JExpr.direct("a>b")}. 277 * 278 * <p> 279 * Be warned that there is a danger in using this method, 280 * as it obfuscates the object model. 281 */ 282 public static JExpression direct( final String source ) { 283 return new JExpressionImpl(){ 284 public void generate( JFormatter f ) { 285 f.p('(').p(source).p(')'); 286 } 287 }; 288 } 289 }