1 package org.gnunet.seaspider;
3 import org.gnunet.seaspider.parser.nodes.ANDExpression;
4 import org.gnunet.seaspider.parser.nodes.AdditiveExpression;
5 import org.gnunet.seaspider.parser.nodes.ArgumentExpressionList;
6 import org.gnunet.seaspider.parser.nodes.AssignmentOperator;
7 import org.gnunet.seaspider.parser.nodes.CastExpression;
8 import org.gnunet.seaspider.parser.nodes.CompoundStatement;
9 import org.gnunet.seaspider.parser.nodes.ConditionalExpression;
10 import org.gnunet.seaspider.parser.nodes.ConstantExpression;
11 import org.gnunet.seaspider.parser.nodes.DoWhileStatement;
12 import org.gnunet.seaspider.parser.nodes.EqualityExpression;
13 import org.gnunet.seaspider.parser.nodes.ExclusiveORExpression;
14 import org.gnunet.seaspider.parser.nodes.Expression;
15 import org.gnunet.seaspider.parser.nodes.ExpressionStatement;
16 import org.gnunet.seaspider.parser.nodes.ForStatement;
17 import org.gnunet.seaspider.parser.nodes.FunctionDeclaration;
18 import org.gnunet.seaspider.parser.nodes.IfStatement;
19 import org.gnunet.seaspider.parser.nodes.InclusiveORExpression;
20 import org.gnunet.seaspider.parser.nodes.InitDeclarator;
21 import org.gnunet.seaspider.parser.nodes.InitDeclaratorList;
22 import org.gnunet.seaspider.parser.nodes.Initializer;
23 import org.gnunet.seaspider.parser.nodes.InitializerList;
24 import org.gnunet.seaspider.parser.nodes.JumpStatement;
25 import org.gnunet.seaspider.parser.nodes.LogicalANDExpression;
26 import org.gnunet.seaspider.parser.nodes.LogicalORExpression;
27 import org.gnunet.seaspider.parser.nodes.MultiplicativeExpression;
28 import org.gnunet.seaspider.parser.nodes.Node;
29 import org.gnunet.seaspider.parser.nodes.NodeChoice;
30 import org.gnunet.seaspider.parser.nodes.NodeSequence;
31 import org.gnunet.seaspider.parser.nodes.NodeToken;
32 import org.gnunet.seaspider.parser.nodes.ParameterDeclaration;
33 import org.gnunet.seaspider.parser.nodes.PostfixExpression;
34 import org.gnunet.seaspider.parser.nodes.PrimaryExpression;
35 import org.gnunet.seaspider.parser.nodes.RelationalExpression;
36 import org.gnunet.seaspider.parser.nodes.ShiftExpression;
37 import org.gnunet.seaspider.parser.nodes.StructOrUnionSpecifier;
38 import org.gnunet.seaspider.parser.nodes.SwitchStatement;
39 import org.gnunet.seaspider.parser.nodes.TranslationUnit;
40 import org.gnunet.seaspider.parser.nodes.TypeDeclaration;
41 import org.gnunet.seaspider.parser.nodes.UnaryExpression;
42 import org.gnunet.seaspider.parser.nodes.UnaryOperator;
43 import org.gnunet.seaspider.parser.nodes.VariableDeclaration;
44 import org.gnunet.seaspider.parser.nodes.WhileStatement;
45 import org.gnunet.seaspider.parser.visitors.DepthFirstVisitor;
46 import org.grothoff.LineNumberInfo;
52 public class ExpressionExtractorVisitor extends DepthFirstVisitor {
54 class ExpressionBuilder {
55 String expression = "";
57 void push(String token) {
58 expression = expression + token;
61 void commit(int line) {
62 ExpressionDatabaseHandler.insertIntoExpressionTable(filename,
63 expression, line, scope_end_line);
68 final String filename;
70 ExpressionBuilder current_expression;
76 boolean skip_mode = true;
81 public ExpressionExtractorVisitor(String filename) {
82 this.filename = filename;
85 public void visit(TranslationUnit n) {
86 LineNumberInfo lin = LineNumberInfo.get(n);
87 scope_end_line = lin.lineEnd;
89 assert scope_end_line == lin.lineEnd;
92 public void visit(NodeToken n) {
95 current_expression.push(n.tokenImage);
98 public void visit(StructOrUnionSpecifier n) {
99 // do nothing -- skip!
102 public void visit(TypeDeclaration n) {
103 // do nothing -- skip!
106 public void visit(InitDeclaratorList n) {
107 assert skip_mode == true;
109 assert skip_mode == true;
112 public void visit(Initializer n) {
113 assert skip_mode == true;
114 if (n.f0.which == 0) {
115 boolean old_mode = skip_mode;
117 ExpressionBuilder old = current_expression;
118 current_expression = new ExpressionBuilder();
121 old.push(current_expression.expression);
122 LineNumberInfo lin = LineNumberInfo.get(n);
123 old.commit(lin.lineEnd);
125 current_expression = old;
126 skip_mode = old_mode;
130 assert skip_mode == true;
133 public void visit(InitializerList n) {
134 assert skip_mode == true;
136 assert skip_mode == true;
139 public void visit(VariableDeclaration n) {
140 assert skip_mode == true;
144 public void visit(FunctionDeclaration n) {
147 int old_scope = scope_end_line;
148 LineNumberInfo lin = LineNumberInfo.get(n);
149 scope_end_line = lin.lineEnd;
152 assert scope_end_line == lin.lineEnd;
153 scope_end_line = old_scope;
156 public void visit(ParameterDeclaration n) {
158 assert current_expression == null;
159 if (n.f1.present()) {
160 NodeSequence ns = (NodeSequence) n.f1.node;
161 Node var = ns.elementAt(0);
162 current_expression = new ExpressionBuilder();
164 LineNumberInfo lin = LineNumberInfo.get(var);
165 current_expression.commit(lin.lineEnd);
167 current_expression = null;
171 public void visit(InitDeclarator n) {
173 assert current_expression == null;
174 current_expression = new ExpressionBuilder();
176 current_expression = null;
181 public void visit(ExpressionStatement n) {
184 assert current_expression == null;
186 current_expression = new ExpressionBuilder();
188 LineNumberInfo lin = LineNumberInfo.get(n);
189 current_expression.commit(lin.lineEnd);
190 current_expression = null;
194 public void visit(CompoundStatement n) {
195 assert current_expression == null;
196 assert skip_mode == true;
197 int old_end = scope_end_line;
198 scope_end_line = n.f2.endLine;
200 scope_end_line = old_end;
203 public void visit(SwitchStatement n) {
204 assert current_expression == null;
206 current_expression = new ExpressionBuilder();
208 current_expression.commit(n.f0.endLine);
210 current_expression = null;
214 public void visit(IfStatement n) {
215 assert current_expression == null;
217 current_expression = new ExpressionBuilder();
219 current_expression.commit(n.f0.endLine);
221 current_expression = null;
226 public void visit(WhileStatement n) {
227 assert current_expression == null;
229 current_expression = new ExpressionBuilder();
231 current_expression.commit(n.f0.endLine);
233 current_expression = null;
237 public void visit(DoWhileStatement n) {
238 assert current_expression == null;
240 current_expression = new ExpressionBuilder();
242 current_expression.commit(n.f6.endLine);
244 current_expression = null;
248 public void visit(ForStatement n) {
249 assert current_expression == null;
251 int old_scope = scope_end_line;
252 LineNumberInfo lin = LineNumberInfo.get(n);
253 scope_end_line = lin.lineEnd;
254 if (n.f2.present()) {
255 current_expression = new ExpressionBuilder();
257 current_expression.commit(n.f3.endLine);
259 if (n.f4.present()) {
260 current_expression = new ExpressionBuilder();
262 current_expression.commit(n.f5.endLine);
264 if (n.f6.present()) {
265 current_expression = new ExpressionBuilder();
267 current_expression.commit(n.f7.endLine);
270 current_expression = null;
272 scope_end_line = old_scope;
275 public void visit(JumpStatement n) {
278 NodeSequence ns = (NodeSequence) n.f0.choice;
279 assert current_expression == null;
281 current_expression = new ExpressionBuilder();
282 ns.elementAt(1).accept(this);
283 LineNumberInfo lin = LineNumberInfo.get(n);
284 current_expression.commit(lin.lineEnd);
285 current_expression = null;
289 public void visit(Expression n) {
290 ExpressionBuilder old = current_expression;
291 current_expression = new ExpressionBuilder();
293 for (int i = 0; i < n.f1.size(); i++) {
294 NodeSequence ns = (NodeSequence) n.f1.elementAt(i);
295 current_expression = new ExpressionBuilder();
296 ns.elementAt(1).accept(this);
298 old.push(current_expression.expression);
299 current_expression = old;
302 public void visit(AssignmentOperator n) {
308 public void visit(ConditionalExpression n) {
309 ExpressionBuilder old = current_expression;
310 current_expression = new ExpressionBuilder();
312 old.push(current_expression.expression);
313 if (n.f1.present()) {
314 LineNumberInfo lin = LineNumberInfo.get(n);
315 NodeSequence ns = (NodeSequence) n.f1.node;
316 current_expression = new ExpressionBuilder();
317 ns.elementAt(1).accept(this);
318 current_expression.commit(lin.lineEnd);
320 old.push(current_expression.expression);
321 current_expression = new ExpressionBuilder();
322 ns.elementAt(3).accept(this);
323 current_expression.commit(lin.lineEnd);
325 old.push(current_expression.expression);
326 old.commit(lin.lineEnd);
328 current_expression = old;
331 public void visit(ConstantExpression n) {
335 public void visit(LogicalORExpression n) {
336 assert skip_mode == false;
337 ExpressionBuilder old = current_expression;
338 current_expression = new ExpressionBuilder();
340 if (n.f1.present()) {
341 LineNumberInfo lin = LineNumberInfo.get(n);
342 current_expression.commit(lin.lineEnd);
344 NodeSequence ns = (NodeSequence) n.f1.node;
345 ns.nodes.get(0).accept(this);
347 old.push(current_expression.expression);
348 current_expression = new ExpressionBuilder();
349 ns.nodes.get(1).accept(this);
350 current_expression.commit(lin.lineEnd);
352 old.push(current_expression.expression);
353 current_expression = old;
356 public void visit(LogicalANDExpression n) {
357 assert skip_mode == false;
358 ExpressionBuilder old = current_expression;
359 current_expression = new ExpressionBuilder();
361 if (n.f1.present()) {
362 LineNumberInfo lin = LineNumberInfo.get(n);
363 current_expression.commit(lin.lineEnd);
365 NodeSequence ns = (NodeSequence) n.f1.node;
366 ns.nodes.get(0).accept(this);
368 old.push(current_expression.expression);
369 current_expression = new ExpressionBuilder();
370 ns.nodes.get(1).accept(this);
371 current_expression.commit(lin.lineEnd);
373 old.push(current_expression.expression);
374 current_expression = old;
377 public void visit(InclusiveORExpression n) {
378 assert skip_mode == false;
379 ExpressionBuilder old = current_expression;
380 current_expression = new ExpressionBuilder();
382 if (n.f1.present()) {
384 NodeSequence ns = (NodeSequence) n.f1.node;
385 ns.nodes.get(0).accept(this);
387 ns.nodes.get(1).accept(this);
389 old.push(current_expression.expression);
390 current_expression = old;
393 public void visit(ExclusiveORExpression n) {
394 assert skip_mode == false;
395 ExpressionBuilder old = current_expression;
396 current_expression = new ExpressionBuilder();
398 if (n.f1.present()) {
400 NodeSequence ns = (NodeSequence) n.f1.node;
401 ns.nodes.get(0).accept(this);
403 ns.nodes.get(1).accept(this);
405 old.push(current_expression.expression);
406 current_expression = old;
409 public void visit(ANDExpression n) {
410 assert skip_mode == false;
411 ExpressionBuilder old = current_expression;
412 current_expression = new ExpressionBuilder();
414 if (n.f1.present()) {
416 NodeSequence ns = (NodeSequence) n.f1.node;
417 ns.nodes.get(0).accept(this);
419 ns.nodes.get(1).accept(this);
421 old.push(current_expression.expression);
422 current_expression = old;
425 // Safey: this function was fixed to commit the right hand side, the
426 // other similar functions still need to be updated accordingly...
427 public void visit(EqualityExpression n) {
428 assert skip_mode == false;
429 ExpressionBuilder old = current_expression;
430 current_expression = new ExpressionBuilder();
432 if (n.f1.present()) {
433 LineNumberInfo lin = LineNumberInfo.get(n);
434 current_expression.commit(lin.lineEnd);
436 NodeSequence ns = (NodeSequence) n.f1.node;
437 ns.nodes.get(0).accept(this);
439 old.push(current_expression.expression);
440 current_expression = new ExpressionBuilder();
441 ns.nodes.get(1).accept(this);
442 current_expression.commit(lin.lineEnd);
444 old.push(current_expression.expression);
445 current_expression = old;
448 public void visit(RelationalExpression n) {
449 assert skip_mode == false;
450 ExpressionBuilder old = current_expression;
451 current_expression = new ExpressionBuilder();
453 if (n.f1.present()) {
455 NodeSequence ns = (NodeSequence) n.f1.node;
456 ns.nodes.get(0).accept(this);
458 ns.nodes.get(1).accept(this);
460 old.push(current_expression.expression);
461 current_expression = old;
464 public void visit(ShiftExpression n) {
465 assert skip_mode == false;
466 ExpressionBuilder old = current_expression;
467 current_expression = new ExpressionBuilder();
469 if (n.f1.present()) {
471 NodeSequence ns = (NodeSequence) n.f1.node;
472 ns.nodes.get(0).accept(this);
474 ns.nodes.get(1).accept(this);
476 old.push(current_expression.expression);
477 current_expression = old;
480 public void visit(AdditiveExpression n) {
481 assert skip_mode == false;
482 ExpressionBuilder old = current_expression;
483 current_expression = new ExpressionBuilder();
485 if (n.f1.present()) {
487 NodeSequence ns = (NodeSequence) n.f1.node;
488 ns.nodes.get(0).accept(this);
490 ns.nodes.get(1).accept(this);
492 old.push(current_expression.expression);
493 current_expression = old;
496 public void visit(MultiplicativeExpression n) {
497 assert skip_mode == false;
498 ExpressionBuilder old = current_expression;
499 current_expression = new ExpressionBuilder();
501 if (n.f1.present()) {
503 NodeSequence ns = (NodeSequence) n.f1.node;
504 ns.nodes.get(0).accept(this);
506 ns.nodes.get(1).accept(this);
508 old.push(current_expression.expression);
509 current_expression = old;
512 public void visit(CastExpression n) {
513 if (n.f0.which == 1) {
517 NodeSequence ns = (NodeSequence) n.f0.choice;
518 ns.nodes.get(3).accept(this);
521 public void visit(UnaryExpression n) {
522 if ((n.f0.which == 1) || (n.f0.which == 2)) {
523 NodeSequence ns = (NodeSequence) n.f0.choice;
524 ns.nodes.get(1).accept(this);
530 public void visit(UnaryOperator n) {
536 public void visit(PostfixExpression n) {
538 for (int i = 0; i < n.f1.size(); i++) {
539 NodeChoice nc = (NodeChoice) n.f1.elementAt(i);
543 ExpressionBuilder old = current_expression;
544 current_expression = new ExpressionBuilder();
545 NodeSequence ns = (NodeSequence) nc.choice;
546 ns.elementAt(1).accept(this);
547 LineNumberInfo lin = LineNumberInfo.get(n);
548 current_expression.commit(lin.colEnd);
550 old.push(current_expression.expression);
552 current_expression = old;
556 ExpressionBuilder old = current_expression;
557 current_expression = new ExpressionBuilder();
558 NodeSequence ns = (NodeSequence) nc.choice;
559 ns.elementAt(1).accept(this);
561 old.push(current_expression.expression);
563 current_expression = old;
569 ExpressionBuilder old = current_expression;
570 LineNumberInfo lin = LineNumberInfo.get(n);
571 old.commit(lin.lineEnd);
572 current_expression = new ExpressionBuilder();
573 NodeSequence ns = (NodeSequence) nc.choice;
574 ns.elementAt(1).accept(this);
579 old.push(current_expression.expression);
580 current_expression = old;
588 throw new Error("Oops!");
593 public void visit(PrimaryExpression n) {
594 if (n.f0.which == 2) {
595 ExpressionBuilder old = current_expression;
596 current_expression = new ExpressionBuilder();
597 NodeSequence ns = (NodeSequence) n.f0.choice;
598 ns.elementAt(1).accept(this);
600 old.push(current_expression.expression);
602 LineNumberInfo lin = LineNumberInfo.get(n);
603 old.commit(lin.lineEnd);
604 current_expression = old;
609 public void visit(ArgumentExpressionList n) {
610 ExpressionBuilder old = current_expression;
611 current_expression = new ExpressionBuilder();
613 old.push(current_expression.expression);
614 for (int i = 0; i < n.f1.size(); i++) {
615 NodeSequence ns = (NodeSequence) n.f1.elementAt(i);
616 current_expression = new ExpressionBuilder();
617 ns.elementAt(1).accept(this);
619 old.push(current_expression.expression);
621 current_expression = old;