Mercurial > hg > graal-compiler

comparison graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/ast/CodeExecutableElement.java @ 7291:a748e4d44694

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Truffle API to specify type-specalized Node classes; annotation processor for automatic code generation of the type-specialized Node classes during the build process
author Christian Humer <christian.humer@gmail.com>
date Fri, 21 Dec 2012 10:44:31 -0800
parents
children 6343a09b2ec1
comparison
equal deleted inserted replaced
7290:a81db08fe930 7291:a748e4d44694
1 /*
2 * Copyright (c) 2012, 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.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23 package com.oracle.truffle.codegen.processor.ast;
24
25 import java.util.*;
26
27 import javax.annotation.processing.*;
28 import javax.lang.model.element.*;
29 import javax.lang.model.type.*;
30
31 import com.oracle.truffle.codegen.processor.*;
32 import com.oracle.truffle.codegen.processor.api.element.*;
33
34 public class CodeExecutableElement extends CodeElement<Element> implements WritableExecutableElement {
35
36 private final List<TypeMirror> throwables = new ArrayList<>();
37 private final List<VariableElement> parameters = parentableList(this, new ArrayList<VariableElement>());
38
39 private TypeMirror returnType;
40 private Name name;
41
42 private CodeTree bodyTree;
43 private String body;
44 private AnnotationValue defaultValue;
45 private boolean varArgs;
46
47 public CodeExecutableElement(TypeMirror returnType, String name) {
48 super(Utils.modifiers());
49 this.returnType = returnType;
50 this.name = CodeNames.of(name);
51 }
52
53 public CodeExecutableElement(Set<Modifier> modifiers, TypeMirror returnType, String name, CodeVariableElement... parameters) {
54 super(modifiers);
55 this.returnType = returnType;
56 this.name = CodeNames.of(name);
57 for (CodeVariableElement codeParameter : parameters) {
58 addParameter(codeParameter);
59 }
60 }
61
62 @Override
63 public List<TypeMirror> getThrownTypes() {
64 return throwables;
65 }
66
67 @Override
68 public TypeMirror asType() {
69 return returnType;
70 }
71
72 @Override
73 public ElementKind getKind() {
74 return ElementKind.METHOD;
75 }
76
77 @Override
78 public List< ? extends TypeParameterElement> getTypeParameters() {
79 return Collections.emptyList();
80 }
81
82 @Override
83 public void setVarArgs(boolean varargs) {
84 this.varArgs = varargs;
85 }
86
87 @Override
88 public boolean isVarArgs() {
89 return varArgs;
90 }
91
92 @Override
93 public void setDefaultValue(AnnotationValue defaultValue) {
94 this.defaultValue = defaultValue;
95 }
96
97 @Override
98 public AnnotationValue getDefaultValue() {
99 return defaultValue;
100 }
101
102 @Override
103 public Name getSimpleName() {
104 return name;
105 }
106
107 public CodeTreeBuilder createBuilder() {
108 CodeTreeBuilder builder = new CodeTreeBuilder();
109 this.bodyTree = builder.getTree();
110 this.bodyTree.setEnclosingElement(this);
111 return builder;
112 }
113
114 public void setBodyTree(CodeTree body) {
115 this.bodyTree = body;
116 }
117
118 public CodeTree getBodyTree() {
119 return bodyTree;
120 }
121
122 public TypeMirror getReturnType() {
123 return returnType;
124 }
125
126 @Override
127 public List<VariableElement> getParameters() {
128 return parameters;
129 }
130
131 public TypeMirror[] getParameterTypes() {
132 TypeMirror[] types = new TypeMirror[getParameters().size()];
133 for (int i = 0; i < types.length; i++) {
134 types[i] = parameters.get(i).asType();
135 }
136 return types;
137 }
138
139 @Override
140 public void setReturnType(TypeMirror type) {
141 returnType = type;
142 }
143
144 @Override
145 public void addParameter(VariableElement parameter) {
146 parameters.add(parameter);
147 }
148
149 @Override
150 public void removeParamter(VariableElement parameter) {
151 parameters.remove(parameter);
152 }
153
154 @Override
155 public void addThrownType(TypeMirror thrownType) {
156 throwables.add(thrownType);
157 }
158
159 @Override
160 public void removeThrownType(TypeMirror thrownType) {
161 throwables.remove(thrownType);
162 }
163
164 @Override
165 public void setSimpleName(Name name) {
166 this.name = name;
167 }
168
169 @Override
170 public void setBody(String body) {
171 this.body = body;
172 }
173
174 @Override
175 public String getBody() {
176 return body;
177 }
178
179 @Override
180 public <R, P> R accept(ElementVisitor<R, P> v, P p) {
181 return v.visitExecutable(this, p);
182 }
183
184
185 public static CodeExecutableElement clone(ProcessingEnvironment env, ExecutableElement method) {
186 CodeExecutableElement copy = new CodeExecutableElement(method.getReturnType(), method.getSimpleName().toString());
187 for (TypeMirror thrownType : method.getThrownTypes()) {
188 copy.addThrownType(thrownType);
189 }
190 copy.setDefaultValue(method.getDefaultValue());
191
192 for (AnnotationMirror mirror : method.getAnnotationMirrors()) {
193 copy.addAnnotationMirror(mirror);
194 }
195 for (VariableElement var : method.getParameters()) {
196 copy.addParameter(var);
197 }
198 for (Element element : method.getEnclosedElements()) {
199 copy.add(element);
200 }
201 copy.setBody(Utils.getMethodBody(env, method));
202 copy.getModifiers().addAll(method.getModifiers());
203 return copy;
204 }
205
206 }