Debian Codegraph @

jte-jsp-converter-jakarta/src/main/java/gg/jte/convert/jsp/converter/JspExpressionConverter.java

raw
1 package gg.jte.convert.jsp.converter;
2
3 import gg.jte.runtime.StringUtils;
4 import org.apache.el.lang.ExpressionBuilder;
5 import org.apache.el.parser.*;
6
7 import java.util.HashMap;
8 import java.util.Map;
9
10 public class JspExpressionConverter {
11
12 public static String convertAttributeValue(String value) {
13 if (value != null) {
14 if ( value.trim().startsWith("${") ) {
15 return new JspExpressionConverter(value).getJavaCode();
16 } else {
17 return "\"" + value + "\"";
18 }
19 }
20
21 return "???";
22 }
23
24 private final String el;
25 private final Node root;
26 private final StringBuilder result;
27 private final Map<Class<? extends Node>, Visitor> visitorMap = new HashMap<>();
28
29 public JspExpressionConverter(String el) {
30 this.el = el;
31
32 if (el == null || StringUtils.isBlank(el)) {
33 root = null;
34 result = new StringBuilder();
35 } else {
36 root = ExpressionBuilder.createNode(el);
37 result = new StringBuilder(el.length());
38
39 visitorMap.put(AstMethodParameters.class, new AstMethodParametersVisitor());
40 visitorMap.put(AstIdentifier.class, new AstIdentifierVisitor());
41 visitorMap.put(AstEmpty.class, new AstEmptyVisitor());
42 visitorMap.put(AstNot.class, new AstNotVisitor());
43 visitorMap.put(AstOr.class, new AstOrVisitor());
44 visitorMap.put(AstAnd.class, new AstAndVisitor());
45 visitorMap.put(AstTrue.class, new AstTrueVisitor());
46 visitorMap.put(AstFalse.class, new AstFalseVisitor());
47 visitorMap.put(AstValue.class, new AstValueVisitor());
48 visitorMap.put(AstEqual.class, new AstEqualVisitor());
49 visitorMap.put(AstNotEqual.class, new AstNotEqualVisitor());
50 visitorMap.put(AstInteger.class, new AstIntegerVisitor());
51 visitorMap.put(AstDotSuffix.class, new AstDotSuffixVisitor());
52 visitorMap.put(AstChoice.class, new AstChoiceVisitor());
53 visitorMap.put(AstString.class, new AstStringVisitor());
54 visitorMap.put(AstFloatingPoint.class, new AstFloatingPointVisitor());
55 visitorMap.put(AstPlus.class, new AstPlusVisitor());
56 visitorMap.put(AstMinus.class, new AstMinusVisitor());
57 visitorMap.put(AstMult.class, new AstMultVisitor());
58 visitorMap.put(AstDiv.class, new AstDivVisitor());
59 visitorMap.put(AstMod.class, new AstModVisitor());
60 visitorMap.put(AstConcatenation.class, new AstConcatenationVisitor());
61 visitorMap.put(AstNegative.class, new AstNegativeVisitor());
62 visitorMap.put(AstGreaterThan.class, new AstGreaterThanVisitor());
63 visitorMap.put(AstLessThan.class, new AstLessThanVisitor());
64 visitorMap.put(AstGreaterThanEqual.class, new AstGreaterThanEqualVisitor());
65 visitorMap.put(AstLessThanEqual.class, new AstLessThanEqualVisitor());
66 visitorMap.put(AstLiteralExpression.class, new AstLiteralExpressionVisitor());
67 visitorMap.put(AstFunction.class, new AstFunctionVisitor());
68 visitorMap.put(AstNull.class, new AstNullVisitor());
69 visitorMap.put(AstBracketSuffix.class, new AstBracketSuffixVisitor());
70 visitorMap.put(AstCompositeExpression.class, new AstCompositeExpressionVisitor());
71 visitorMap.put(AstDynamicExpression.class, new AstDynamicExpressionVisitor());
72 visitorMap.put(AstListData.class, new AstListDataVisitor());
73
74 process(root);
75 }
76 }
77
78 public String getJavaCode() {
79 return result.toString();
80 }
81
82 private void process(Node node) {
83 Visitor visitor = visitorMap.get(node.getClass());
84 if (visitor != null) {
85 visitor.visit(node);
86 } else {
87 throw new UnsupportedOperationException("Unknown AST node " + node.getClass() + ". Expression was '" + el + "'");
88 }
89 }
90
91 private interface Visitor {
92 void visit(Node node);
93 }
94
95 private class AstMethodParametersVisitor implements Visitor {
96 @Override
97 public void visit(Node node) {
98 result.append('(');
99 for (int i = 0; i < node.jjtGetNumChildren(); ++i) {
100 if (i > 0) {
101 result.append(", ");
102 }
103 process(node.jjtGetChild(i));
104 }
105 result.append(')');
106 }
107 }
108
109 private class AstIdentifierVisitor implements Visitor {
110 @Override
111 public void visit(Node node) {
112 result.append(node.getImage());
113 }
114 }
115
116 private class AstEmptyVisitor implements Visitor {
117 @Override
118 public void visit(Node node) {
119 result.append("isEmpty(");
120 process(node.jjtGetChild(0));
121 result.append(")");
122 }
123 }
124
125 private class AstNotVisitor implements Visitor {
126 @Override
127 public void visit(Node node) {
128 result.append('!');
129 process(node.jjtGetChild(0));
130 }
131 }
132
133 private abstract class AstBinaryOperatorVisitor implements Visitor {
134 @Override
135 public void visit(Node node) {
136 boolean parenthesisNeeded = isParenthesisNeeded(node);
137 if (parenthesisNeeded) {
138 result.append('(');
139 }
140
141 process(node.jjtGetChild(0));
142 result.append(' ').append(getOperator()).append(' ');
143 process(node.jjtGetChild(1));
144
145 if (parenthesisNeeded) {
146 result.append(')');
147 }
148 }
149
150 protected abstract String getOperator();
151
152 @SuppressWarnings("RedundantIfStatement")
153 private boolean isParenthesisNeeded(Node node) {
154 if (node == root) {
155 return false;
156 }
157
158 if (node.jjtGetParent() instanceof AstChoice) {
159 return false;
160 }
161
162 return true;
163 }
164 }
165
166 private class AstOrVisitor extends AstBinaryOperatorVisitor {
167 @Override
168 protected String getOperator() {
169 return "||";
170 }
171 }
172
173 private class AstAndVisitor extends AstBinaryOperatorVisitor {
174 @Override
175 protected String getOperator() {
176 return "&&";
177 }
178 }
179
180 private class AstTrueVisitor implements Visitor {
181 @Override
182 public void visit(Node node) {
183 result.append("true");
184 }
185 }
186
187 private class AstFalseVisitor implements Visitor {
188 @Override
189 public void visit(Node node) {
190 result.append("false");
191 }
192 }
193
194 private class AstValueVisitor implements Visitor {
195 @Override
196 public void visit(Node node) {
197 for (int i = 0; i < node.jjtGetNumChildren(); i++) {
198 process(node.jjtGetChild(i));
199 }
200 }
201 }
202
203 private class AstEqualVisitor extends AstBinaryOperatorVisitor {
204 @Override
205 protected String getOperator() {
206 return "==";
207 }
208 }
209
210 private class AstNotEqualVisitor extends AstBinaryOperatorVisitor {
211 @Override
212 protected String getOperator() {
213 return "!=";
214 }
215 }
216
217 private class AstIntegerVisitor implements Visitor {
218 @Override
219 public void visit(Node node) {
220 result.append(node.getImage());
221 }
222 }
223
224 private class AstStringVisitor implements Visitor {
225 @Override
226 public void visit(Node node) {
227 AstString astString = (AstString)node;
228 result.append('"');
229 StringUtils.appendEscaped(result, astString.getString());
230 result.append('"');
231 }
232 }
233
234 private class AstDotSuffixVisitor implements Visitor {
235 @Override
236 public void visit(Node node) {
237 result.append(".").append(node.getImage());
238 }
239 }
240
241 private class AstChoiceVisitor implements Visitor {
242 @Override
243 public void visit(Node node) {
244 process(node.jjtGetChild(0));
245 result.append(" ? ");
246 process(node.jjtGetChild(1));
247 result.append(" : ");
248 process(node.jjtGetChild(2));
249 }
250 }
251
252 private class AstFloatingPointVisitor implements Visitor {
253 @Override
254 public void visit(Node node) {
255 result.append(node.getImage());
256 }
257 }
258
259 private class AstPlusVisitor extends AstBinaryOperatorVisitor {
260 @Override
261 protected String getOperator() {
262 return "+";
263 }
264 }
265
266 private class AstMinusVisitor extends AstBinaryOperatorVisitor {
267 @Override
268 protected String getOperator() {
269 return "-";
270 }
271 }
272
273 @SuppressWarnings("SpellCheckingInspection")
274 private class AstMultVisitor extends AstBinaryOperatorVisitor {
275 @Override
276 protected String getOperator() {
277 return "*";
278 }
279 }
280
281 private class AstDivVisitor extends AstBinaryOperatorVisitor {
282 @Override
283 protected String getOperator() {
284 return "/";
285 }
286 }
287
288 private class AstModVisitor extends AstBinaryOperatorVisitor {
289 @Override
290 protected String getOperator() {
291 return "%";
292 }
293 }
294
295 private class AstConcatenationVisitor extends AstBinaryOperatorVisitor {
296 @Override
297 protected String getOperator() {
298 return "+";
299 }
300 }
301
302 private class AstGreaterThanVisitor extends AstBinaryOperatorVisitor {
303 @Override
304 protected String getOperator() {
305 return ">";
306 }
307 }
308
309 private class AstLessThanVisitor extends AstBinaryOperatorVisitor {
310 @Override
311 protected String getOperator() {
312 return "<";
313 }
314 }
315
316 private class AstGreaterThanEqualVisitor extends AstBinaryOperatorVisitor {
317 @Override
318 protected String getOperator() {
319 return ">=";
320 }
321 }
322
323 private class AstLessThanEqualVisitor extends AstBinaryOperatorVisitor {
324 @Override
325 protected String getOperator() {
326 return "<=";
327 }
328 }
329
330 private class AstLiteralExpressionVisitor implements Visitor {
331 @Override
332 public void visit(Node node) {
333 result.append(node.getImage());
334 }
335 }
336
337 private class AstFunctionVisitor implements Visitor {
338 @Override
339 public void visit( Node node ) {
340 AstFunction function = (AstFunction)node;
341 result.append(function.getPrefix());
342 result.append(':');
343 result.append(function.getLocalName());
344
345 for (int i = 0; i < node.jjtGetNumChildren(); i++) {
346 if (i > 0) {
347 result.append(", ");
348 }
349 process(node.jjtGetChild(i));
350 }
351 }
352 }
353
354 private class AstNullVisitor implements Visitor {
355 @Override
356 public void visit(Node node) {
357 result.append("null");
358 }
359 }
360
361 private class AstNegativeVisitor implements Visitor {
362 @Override
363 public void visit(Node node) {
364 result.append('-');
365 process(node.jjtGetChild(0));
366 }
367 }
368
369 private class AstBracketSuffixVisitor implements Visitor {
370 @Override
371 public void visit(Node node) {
372 result.append(".get(");
373 process(node.jjtGetChild(0));
374 result.append(")");
375 }
376 }
377
378 private class AstCompositeExpressionVisitor implements Visitor {
379 @Override
380 public void visit(Node node) {
381 result.append("@`");
382 for (int i = 0; i < node.jjtGetNumChildren(); i++) {
383 process(node.jjtGetChild(i));
384 }
385 result.append("`");
386 }
387 }
388
389 private class AstDynamicExpressionVisitor implements Visitor {
390 @Override
391 public void visit(Node node) {
392 result.append("${");
393 process(node.jjtGetChild(0));
394 result.append("}");
395 }
396 }
397
398 private class AstListDataVisitor implements Visitor {
399 @Override
400 public void visit(Node node) {
401 result.append("java.util.Arrays.asList(");
402 for (int i = 0; i < node.jjtGetNumChildren(); i++) {
403 if (i > 0) {
404 result.append(", ");
405 }
406 process(node.jjtGetChild(i));
407 }
408 result.append(")");
409 }
410 }
411 }