]> gerrit.simantics Code Review - simantics/platform.git/blob
cc8f3e0c5ab5a7f5dfefb8cf43b77b28b76c756e
[simantics/platform.git] /
1 package org.simantics.scl.compiler.internal.codegen.utils;
2
3 import java.util.Arrays;
4
5 import org.cojen.classfile.TypeDesc;
6 import org.objectweb.asm.Label;
7 import org.objectweb.asm.Opcodes;
8 import org.simantics.scl.compiler.internal.codegen.references.Val;
9 import org.simantics.scl.compiler.internal.codegen.types.JavaTypeTranslator;
10 import org.simantics.scl.compiler.types.Type;
11
12 public class CodeBuilderUtils {
13     
14     /**
15      * Creates fields c0,...,c{N-1} to the given class, where c is fieldNamePrefix and N is the length of types.
16      * Creates also a constructor for the fields. 
17      * @param classFile
18      * @param fieldModifiers
19      * @param fieldNamePrefix
20      * @param types
21      */
22     public static void makeRecord(ClassBuilder classBuilder, String recordName, int fieldModifiers, String fieldNamePrefix, TypeDesc[] types,
23             boolean generateEqualsAndHashCode) {
24         // Create fields
25         for(int i=0;i<types.length;++i)
26             if(!types[i].equals(TypeDesc.VOID))
27                 classBuilder.addField(fieldModifiers, fieldNamePrefix+i, types[i]);
28         
29         // Create constructor        
30         MethodBuilderBase mb = classBuilder.addConstructor(
31                 types.length == 0 ? Opcodes.ACC_PRIVATE : Opcodes.ACC_PUBLIC, 
32                 JavaTypeTranslator.filterVoid(types));
33         mb.loadThis();
34         mb.invokeConstructor(classBuilder.getSuperClassName(), Constants.EMPTY_TYPEDESC_ARRAY);
35         if(types.length == 0) {  
36             TypeDesc thisClass = classBuilder.getType();
37             classBuilder.addField(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC | Opcodes.ACC_FINAL, "INSTANCE", thisClass);
38             
39             MethodBuilderBase inimb = classBuilder.addInitializerBase();
40             inimb.newObject(thisClass);
41             inimb.dup();
42             inimb.invokeConstructor(classBuilder.getClassName(), Constants.EMPTY_TYPEDESC_ARRAY);
43             inimb.storeStaticField(classBuilder.getClassName(), "INSTANCE", thisClass);
44             inimb.returnVoid();
45             inimb.finish();
46         }
47         else {
48             for(int i=0,j=0;i<types.length;++i) {
49                 if(!types[i].equals(TypeDesc.VOID)) {
50                     mb.loadThis();
51                     mb.loadLocal(mb.getParameter(j++));
52                     mb.storeField(classBuilder.getClassName(), fieldNamePrefix+i, types[i]);            
53                 }
54             }
55         }
56         mb.returnVoid();
57         mb.finish();
58         
59         // Create toString
60         {
61             MethodBuilderBase tsmb = classBuilder.addMethodBase(Opcodes.ACC_PUBLIC, "toString", TypeDesc.STRING, Constants.EMPTY_TYPEDESC_ARRAY);
62             
63             if(types.length > 0) {
64                 tsmb.newObject(TypeDesc.forClass(StringBuilder.class));
65                 tsmb.dup();
66                 tsmb.invokeConstructor("java/lang/StringBuilder", Constants.EMPTY_TYPEDESC_ARRAY);
67                 
68                 // build string
69                 tsmb.loadConstant("(" + recordName);
70                 StringBuilder_appendString(tsmb);
71                 for(int i=0;i<types.length;++i) {
72                     if(types[i].equals(TypeDesc.VOID)) {
73                         tsmb.loadConstant(" ()");
74                         StringBuilder_appendString(tsmb);
75                     }
76                     else {
77                         tsmb.loadConstant(" ");
78                         StringBuilder_appendString(tsmb);
79                         tsmb.loadThis();
80                         tsmb.loadField(classBuilder.getClassName(), fieldNamePrefix+i, types[i]);
81                         StringBuilder_appendObject(tsmb, types[i]);
82                     }
83                 }
84                 tsmb.loadConstant(")");
85                 StringBuilder_appendString(tsmb);
86                 
87                 // return
88                 tsmb.invokeVirtual("java/lang/StringBuilder", "toString", TypeDesc.STRING, Constants.EMPTY_TYPEDESC_ARRAY);
89             }
90             else
91                 tsmb.loadConstant(recordName);
92             tsmb.returnValue(TypeDesc.STRING);
93             tsmb.finish();
94         }
95         
96         if(generateEqualsAndHashCode) {
97             // Create equals
98             {
99                 TypeDesc CLASS = TypeDesc.forClass(Class.class);
100
101                 MethodBuilderBase tsmb = classBuilder.addMethodBase(Opcodes.ACC_PUBLIC, "equals", TypeDesc.BOOLEAN, Constants.OBJECTS[1]);
102                 LocalVariable parameter = tsmb.getParameter(0);
103                 Label success = tsmb.createLabel();
104                 Label failure = tsmb.createLabel();
105
106                 // Check type
107                 tsmb.loadThis();
108                 tsmb.loadLocal(parameter);
109                 tsmb.ifComparisonBranch(success, "==", TypeDesc.OBJECT);
110                 tsmb.loadLocal(parameter);
111                 tsmb.ifNullBranch(failure, true);
112                 tsmb.loadLocal(parameter);
113                 tsmb.invokeVirtual("java/lang/Object", "getClass", CLASS, Constants.EMPTY_TYPEDESC_ARRAY);
114                 tsmb.loadThis();
115                 tsmb.invokeVirtual("java/lang/Object", "getClass", CLASS, Constants.EMPTY_TYPEDESC_ARRAY);
116                 tsmb.ifComparisonBranch(failure, "!=", CLASS);
117                 tsmb.loadLocal(parameter);
118                 tsmb.checkCast(classBuilder.getType());
119                 LocalVariable other = tsmb.createLocalVariable("other", classBuilder.getType());
120                 tsmb.storeLocal(other);
121
122                 // Compare fields
123                 for(int i=0;i<types.length;++i) {
124                     TypeDesc type = types[i];
125                     if(type.equals(TypeDesc.VOID))
126                         continue;
127                     tsmb.loadThis();
128                     tsmb.loadField(classBuilder.getClassName(), fieldNamePrefix+i, type);
129                     tsmb.loadLocal(other);
130                     tsmb.loadField(classBuilder.getClassName(), fieldNamePrefix+i, type);
131                     equals(tsmb, type, failure);
132                 }
133
134                 // Return
135                 tsmb.setLocation(success);
136                 tsmb.loadConstant(true);
137                 tsmb.returnValue(TypeDesc.BOOLEAN);
138                 tsmb.setLocation(failure);
139                 tsmb.loadConstant(false);
140                 tsmb.returnValue(TypeDesc.BOOLEAN);
141                 tsmb.finish();
142             }
143
144             // Create hashCode
145             {
146                 MethodBuilderBase tsmb = classBuilder.addMethodBase(Opcodes.ACC_PUBLIC, "hashCode", TypeDesc.INT, Constants.EMPTY_TYPEDESC_ARRAY);
147                 tsmb.loadConstant(recordName.hashCode());
148                 for(int i=0;i<types.length;++i) {
149                     TypeDesc type = types[i];
150                     if(type.equals(TypeDesc.VOID))
151                         continue;
152                     tsmb.loadConstant(31);
153                     tsmb.math(Opcodes.IMUL);
154                     tsmb.loadThis();
155                     tsmb.loadField(classBuilder.getClassName(), fieldNamePrefix+i, type);
156                     hashCode(tsmb, type);
157                     tsmb.math(Opcodes.IADD);
158                 }
159                 tsmb.returnValue(TypeDesc.INT);
160                 tsmb.finish();
161             }
162         }
163     }
164     
165     public static void equals(MethodBuilderBase mb, TypeDesc typeDesc, Label failure) {
166         if(typeDesc.isPrimitive())
167             mb.ifComparisonBranch(failure, "!=", typeDesc);
168         else {
169             Label isNull = mb.createLabel();
170             Label finished = mb.createLabel();
171             mb.swap();
172             mb.dup();
173             mb.ifNullBranch(isNull, true);
174             mb.swap();
175             mb.invokeVirtual("java/lang/Object", "equals", TypeDesc.BOOLEAN, Constants.OBJECTS[1]);
176             mb.ifZeroComparisonBranch(failure, "==");
177             mb.branch(finished);
178             mb.setLocation(isNull);
179             mb.pop();
180             mb.ifNullBranch(failure, false);
181             mb.setLocation(finished);
182         }
183     }
184     
185     /**
186      * Calculates the hash code of a value in stack.
187      */
188     public static void hashCode(MethodBuilderBase mb, TypeDesc typeDesc) {
189         switch(typeDesc.getTypeCode()) {
190         case TypeDesc.INT_CODE:
191             break;
192         case TypeDesc.OBJECT_CODE: {
193             Label isNull = mb.createLabel();
194             Label finished = mb.createLabel();
195             mb.dup();
196             mb.ifNullBranch(isNull, true);
197             mb.invokeVirtual("java/lang/Object", "hashCode", TypeDesc.INT, Constants.EMPTY_TYPEDESC_ARRAY);
198             mb.branch(finished);
199             mb.setLocation(isNull);
200             mb.pop();
201             mb.loadConstant(0);
202             mb.setLocation(finished);
203         } break;
204         case TypeDesc.DOUBLE_CODE:
205             mb.invokeStatic("java/lang/Double", "doubleToLongBits", TypeDesc.LONG, new TypeDesc[] { TypeDesc.DOUBLE });
206         case TypeDesc.LONG_CODE:
207             mb.dup2();
208             mb.loadConstant(32);
209             mb.math(Opcodes.LSHR);
210             mb.math(Opcodes.LXOR);
211             mb.convert(TypeDesc.LONG, TypeDesc.INT);
212             break;
213         case TypeDesc.FLOAT_CODE:
214             mb.invokeStatic("java/lang/Float", "floatToIntBits", TypeDesc.INT, new TypeDesc[] { TypeDesc.FLOAT });
215             break;
216         default:
217             mb.convert(typeDesc, TypeDesc.INT);
218         }
219     }
220     
221     public static void constructRecord(TypeDesc clazz, MethodBuilder mb,
222             Type[] parameterTypes, Val... parameters) {
223         if(parameters.length == 0) {
224             mb.loadStaticField(clazz, "INSTANCE", clazz);
225         }
226         else {
227             mb.newObject(clazz);
228             mb.dup();
229             for(int i=0;i<parameters.length;++i)
230                 mb.push(parameters[i], parameterTypes[i]);
231             JavaTypeTranslator tt = mb.moduleBuilder.getJavaTypeTranslator();
232             mb.invokeConstructor(clazz, JavaTypeTranslator.filterVoid( 
233                     tt.toTypeDescs(Arrays.copyOf(parameterTypes, parameters.length))));
234         }
235     }
236     
237     public static void StringBuilder_appendString(MethodBuilderBase mb) {
238         mb.invokeVirtual("java/lang/StringBuilder", "append", TypeDesc.forClass("java.lang.StringBuilder"), 
239                 new TypeDesc[] {TypeDesc.STRING});
240     }
241     
242     public static void StringBuilder_appendObject(MethodBuilderBase mb, TypeDesc type) {
243         if(!type.isPrimitive() && type != TypeDesc.STRING)
244             type = TypeDesc.OBJECT;
245         mb.invokeVirtual("java/lang/StringBuilder", "append", TypeDesc.forClass("java.lang.StringBuilder"), 
246                 new TypeDesc[] {type});
247     }
248     
249 }