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.AssignmentExpression;
7 import org.gnunet.seaspider.parser.nodes.AssignmentOperator;
8 import org.gnunet.seaspider.parser.nodes.CastExpression;
9 import org.gnunet.seaspider.parser.nodes.CompoundStatement;
10 import org.gnunet.seaspider.parser.nodes.ConditionalExpression;
11 import org.gnunet.seaspider.parser.nodes.ConstantExpression;
12 import org.gnunet.seaspider.parser.nodes.DoWhileStatement;
13 import org.gnunet.seaspider.parser.nodes.EqualityExpression;
14 import org.gnunet.seaspider.parser.nodes.ExclusiveORExpression;
15 import org.gnunet.seaspider.parser.nodes.Expression;
16 import org.gnunet.seaspider.parser.nodes.ExpressionStatement;
17 import org.gnunet.seaspider.parser.nodes.ForStatement;
18 import org.gnunet.seaspider.parser.nodes.FunctionDeclaration;
19 import org.gnunet.seaspider.parser.nodes.IfStatement;
20 import org.gnunet.seaspider.parser.nodes.InclusiveORExpression;
21 import org.gnunet.seaspider.parser.nodes.InitDeclarator;
22 import org.gnunet.seaspider.parser.nodes.InitDeclaratorList;
23 import org.gnunet.seaspider.parser.nodes.Initializer;
24 import org.gnunet.seaspider.parser.nodes.InitializerList;
25 import org.gnunet.seaspider.parser.nodes.JumpStatement;
26 import org.gnunet.seaspider.parser.nodes.LogicalANDExpression;
27 import org.gnunet.seaspider.parser.nodes.LogicalORExpression;
28 import org.gnunet.seaspider.parser.nodes.MultiplicativeExpression;
29 import org.gnunet.seaspider.parser.nodes.Node;
30 import org.gnunet.seaspider.parser.nodes.NodeChoice;
31 import org.gnunet.seaspider.parser.nodes.NodeSequence;
32 import org.gnunet.seaspider.parser.nodes.NodeToken;
33 import org.gnunet.seaspider.parser.nodes.ParameterDeclaration;
34 import org.gnunet.seaspider.parser.nodes.PostfixExpression;
35 import org.gnunet.seaspider.parser.nodes.PrimaryExpression;
36 import org.gnunet.seaspider.parser.nodes.RelationalExpression;
37 import org.gnunet.seaspider.parser.nodes.ShiftExpression;
38 import org.gnunet.seaspider.parser.nodes.StructOrUnionSpecifier;
39 import org.gnunet.seaspider.parser.nodes.SwitchStatement;
40 import org.gnunet.seaspider.parser.nodes.TranslationUnit;
41 import org.gnunet.seaspider.parser.nodes.TypeDeclaration;
42 import org.gnunet.seaspider.parser.nodes.UnaryExpression;
43 import org.gnunet.seaspider.parser.nodes.UnaryOperator;
44 import org.gnunet.seaspider.parser.nodes.VariableDeclaration;
45 import org.gnunet.seaspider.parser.nodes.WhileStatement;
46 import org.gnunet.seaspider.parser.visitors.DepthFirstVisitor;
47 import org.grothoff.LineNumberInfo;
53 public class ExpressionExtractorVisitor extends DepthFirstVisitor {
55 class ExpressionBuilder {
56 String expression = "";
58 void push(String token) {
59 expression = expression + token;
62 void commit(int line) {
63 ExpressionDatabaseHandler.insertIntoExpressionTable(filename,
64 expression, line, scope_end_line);
69 final String filename;
71 ExpressionBuilder current_expression;
77 boolean skip_mode = true;
82 public ExpressionExtractorVisitor(String filename) {
83 this.filename = filename;
86 public void visit(TranslationUnit n) {
87 LineNumberInfo lin = LineNumberInfo.get(n);
88 scope_end_line = lin.lineEnd;
90 assert scope_end_line == lin.lineEnd;
93 public void visit(NodeToken n) {
96 current_expression.push(n.tokenImage);
99 public void visit(StructOrUnionSpecifier n) {
100 // do nothing -- skip!
103 public void visit(TypeDeclaration n) {
104 // do nothing -- skip!
107 public void visit(InitDeclaratorList n) {
108 assert skip_mode == true;
110 assert skip_mode == true;
113 public void visit(Initializer n) {
114 assert skip_mode == true;
115 if (n.f0.which == 0) {
116 boolean old_mode = skip_mode;
118 ExpressionBuilder old = current_expression;
119 current_expression = new ExpressionBuilder();
121 LineNumberInfo lin = LineNumberInfo.get(n);
123 old.push(current_expression.expression);
124 old.commit(lin.lineEnd);
126 current_expression.commit(lin.lineEnd);
128 current_expression = old;
129 skip_mode = old_mode;
133 assert skip_mode == true;
136 public void visit(InitializerList n) {
137 assert skip_mode == true;
139 assert skip_mode == true;
142 public void visit(VariableDeclaration n) {
143 assert skip_mode == true;
147 public void visit(FunctionDeclaration n) {
150 int old_scope = scope_end_line;
151 LineNumberInfo lin = LineNumberInfo.get(n);
152 scope_end_line = lin.lineEnd;
155 assert scope_end_line == lin.lineEnd;
156 scope_end_line = old_scope;
159 public void visit(ParameterDeclaration n) {
161 assert current_expression == null;
162 if (n.f1.present()) {
163 NodeSequence ns = (NodeSequence) n.f1.node;
164 Node var = ns.elementAt(0);
165 current_expression = new ExpressionBuilder();
167 LineNumberInfo lin = LineNumberInfo.get(var);
168 current_expression.commit(lin.lineEnd);
170 current_expression = null;
174 public void visit(InitDeclarator n) {
176 assert current_expression == null;
177 current_expression = new ExpressionBuilder();
179 current_expression = null;
184 public void visit(ExpressionStatement n) {
187 assert current_expression == null;
189 current_expression = new ExpressionBuilder();
191 LineNumberInfo lin = LineNumberInfo.get(n);
192 current_expression.commit(lin.lineEnd);
193 current_expression = null;
197 public void visit(CompoundStatement n) {
198 assert current_expression == null;
199 assert skip_mode == true;
200 int old_end = scope_end_line;
201 scope_end_line = n.f2.endLine;
203 scope_end_line = old_end;
206 public void visit(SwitchStatement n) {
207 assert current_expression == null;
209 current_expression = new ExpressionBuilder();
211 current_expression.commit(n.f0.endLine);
213 current_expression = null;
217 public void visit(IfStatement n) {
218 assert current_expression == null;
220 current_expression = new ExpressionBuilder();
222 current_expression.commit(n.f0.endLine);
224 current_expression = null;
229 public void visit(WhileStatement n) {
230 assert current_expression == null;
232 current_expression = new ExpressionBuilder();
234 current_expression.commit(n.f0.endLine);
236 current_expression = null;
240 public void visit(DoWhileStatement n) {
241 assert current_expression == null;
243 current_expression = new ExpressionBuilder();
245 current_expression.commit(n.f6.endLine);
247 current_expression = null;
251 public void visit(ForStatement n) {
252 assert current_expression == null;
254 int old_scope = scope_end_line;
255 LineNumberInfo lin = LineNumberInfo.get(n);
256 scope_end_line = lin.lineEnd;
257 if (n.f2.present()) {
258 current_expression = new ExpressionBuilder();
260 current_expression.commit(n.f3.endLine);
262 if (n.f4.present()) {
263 current_expression = new ExpressionBuilder();
265 current_expression.commit(n.f5.endLine);
267 if (n.f6.present()) {
268 current_expression = new ExpressionBuilder();
270 current_expression.commit(n.f7.endLine);
273 current_expression = null;
275 scope_end_line = old_scope;
278 public void visit(JumpStatement n) {
281 NodeSequence ns = (NodeSequence) n.f0.choice;
282 assert current_expression == null;
284 current_expression = new ExpressionBuilder();
285 ns.elementAt(1).accept(this);
286 LineNumberInfo lin = LineNumberInfo.get(n);
287 current_expression.commit(lin.lineEnd);
288 current_expression = null;
292 public void visit(Expression n) {
293 ExpressionBuilder old = current_expression;
294 current_expression = new ExpressionBuilder();
296 for (int i = 0; i < n.f1.size(); i++) {
297 NodeSequence ns = (NodeSequence) n.f1.elementAt(i);
298 current_expression = new ExpressionBuilder();
299 ns.elementAt(1).accept(this);
301 old.push(current_expression.expression);
302 current_expression = old;
305 public void visit(AssignmentOperator n) {
311 public void visit(AssignmentExpression n)
315 NodeSequence ns = (NodeSequence) n.f0.choice;
316 UnaryExpression u = (UnaryExpression) ns.elementAt(0);
317 AssignmentOperator ao = (AssignmentOperator) ns.elementAt(1);
318 AssignmentExpression ae = (AssignmentExpression) ns.elementAt(2);
319 LineNumberInfo lin = LineNumberInfo.get(n);
321 ExpressionBuilder old = current_expression;
322 current_expression = new ExpressionBuilder();
324 current_expression.commit(lin.lineEnd);
326 old.push(current_expression.expression);
327 current_expression = new ExpressionBuilder();
329 current_expression.commit(lin.lineEnd);
330 old.push(current_expression.expression);
331 current_expression = old;
335 n.f0.choice.accept (this);
339 public void visit(ConditionalExpression n) {
340 ExpressionBuilder old = current_expression;
341 current_expression = new ExpressionBuilder();
343 old.push(current_expression.expression);
344 if (n.f1.present()) {
345 LineNumberInfo lin = LineNumberInfo.get(n);
346 NodeSequence ns = (NodeSequence) n.f1.node;
347 current_expression = new ExpressionBuilder();
348 ns.elementAt(1).accept(this);
349 current_expression.commit(lin.lineEnd);
351 old.push(current_expression.expression);
352 current_expression = new ExpressionBuilder();
353 ns.elementAt(3).accept(this);
354 current_expression.commit(lin.lineEnd);
356 old.push(current_expression.expression);
357 old.commit(lin.lineEnd);
359 current_expression = old;
362 public void visit(ConstantExpression n) {
366 public void visit(LogicalORExpression n) {
367 assert skip_mode == false;
368 ExpressionBuilder old = current_expression;
369 current_expression = new ExpressionBuilder();
371 if (n.f1.present()) {
372 LineNumberInfo lin = LineNumberInfo.get(n);
373 current_expression.commit(lin.lineEnd);
375 NodeSequence ns = (NodeSequence) n.f1.node;
376 ns.nodes.get(0).accept(this);
378 old.push(current_expression.expression);
379 current_expression = new ExpressionBuilder();
380 ns.nodes.get(1).accept(this);
381 current_expression.commit(lin.lineEnd);
383 old.push(current_expression.expression);
384 current_expression = old;
387 public void visit(LogicalANDExpression n) {
388 assert skip_mode == false;
389 ExpressionBuilder old = current_expression;
390 current_expression = new ExpressionBuilder();
392 if (n.f1.present()) {
393 LineNumberInfo lin = LineNumberInfo.get(n);
394 current_expression.commit(lin.lineEnd);
396 NodeSequence ns = (NodeSequence) n.f1.node;
397 ns.nodes.get(0).accept(this);
399 old.push(current_expression.expression);
400 current_expression = new ExpressionBuilder();
401 ns.nodes.get(1).accept(this);
402 current_expression.commit(lin.lineEnd);
404 old.push(current_expression.expression);
405 current_expression = old;
408 public void visit(InclusiveORExpression n) {
409 assert skip_mode == false;
410 ExpressionBuilder old = current_expression;
411 current_expression = new ExpressionBuilder();
413 if (n.f1.present()) {
415 NodeSequence ns = (NodeSequence) n.f1.node;
416 ns.nodes.get(0).accept(this);
418 ns.nodes.get(1).accept(this);
420 old.push(current_expression.expression);
421 current_expression = old;
424 public void visit(ExclusiveORExpression n) {
425 assert skip_mode == false;
426 ExpressionBuilder old = current_expression;
427 current_expression = new ExpressionBuilder();
429 if (n.f1.present()) {
431 NodeSequence ns = (NodeSequence) n.f1.node;
432 ns.nodes.get(0).accept(this);
434 ns.nodes.get(1).accept(this);
436 old.push(current_expression.expression);
437 current_expression = old;
440 public void visit(ANDExpression n) {
441 assert skip_mode == false;
442 ExpressionBuilder old = current_expression;
443 current_expression = new ExpressionBuilder();
445 if (n.f1.present()) {
447 NodeSequence ns = (NodeSequence) n.f1.node;
448 ns.nodes.get(0).accept(this);
450 ns.nodes.get(1).accept(this);
452 old.push(current_expression.expression);
453 current_expression = old;
456 // Safey: this function was fixed to commit the right hand side, the
457 // other similar functions still need to be updated accordingly...
458 public void visit(EqualityExpression n) {
459 assert skip_mode == false;
460 ExpressionBuilder old = current_expression;
461 current_expression = new ExpressionBuilder();
463 if (n.f1.present()) {
464 LineNumberInfo lin = LineNumberInfo.get(n);
465 current_expression.commit(lin.lineEnd);
467 NodeSequence ns = (NodeSequence) n.f1.node;
468 ns.nodes.get(0).accept(this);
470 old.push(current_expression.expression);
471 current_expression = new ExpressionBuilder();
472 ns.nodes.get(1).accept(this);
473 current_expression.commit(lin.lineEnd);
475 old.push(current_expression.expression);
476 current_expression = old;
479 public void visit(RelationalExpression n) {
480 assert skip_mode == false;
481 ExpressionBuilder old = current_expression;
482 current_expression = new ExpressionBuilder();
484 if (n.f1.present()) {
485 LineNumberInfo lin = LineNumberInfo.get(n);
486 current_expression.commit(lin.lineEnd);
488 NodeSequence ns = (NodeSequence) n.f1.node;
489 ns.nodes.get(0).accept(this);
491 old.push(current_expression.expression);
492 current_expression = new ExpressionBuilder();
493 ns.nodes.get(1).accept(this);
494 current_expression.commit(lin.lineEnd);
496 old.push(current_expression.expression);
497 current_expression = old;
500 public void visit(ShiftExpression n) {
501 assert skip_mode == false;
502 ExpressionBuilder old = current_expression;
503 current_expression = new ExpressionBuilder();
505 if (n.f1.present()) {
507 NodeSequence ns = (NodeSequence) n.f1.node;
508 ns.nodes.get(0).accept(this);
510 ns.nodes.get(1).accept(this);
512 old.push(current_expression.expression);
513 current_expression = old;
516 public void visit(AdditiveExpression n) {
517 assert skip_mode == false;
518 ExpressionBuilder old = current_expression;
519 current_expression = new ExpressionBuilder();
521 if (n.f1.present()) {
523 NodeSequence ns = (NodeSequence) n.f1.node;
524 ns.nodes.get(0).accept(this);
526 ns.nodes.get(1).accept(this);
528 old.push(current_expression.expression);
529 current_expression = old;
532 public void visit(MultiplicativeExpression n) {
533 assert skip_mode == false;
534 ExpressionBuilder old = current_expression;
535 current_expression = new ExpressionBuilder();
537 if (n.f1.present()) {
539 NodeSequence ns = (NodeSequence) n.f1.node;
540 ns.nodes.get(0).accept(this);
542 ns.nodes.get(1).accept(this);
544 old.push(current_expression.expression);
545 current_expression = old;
548 public void visit(CastExpression n) {
549 if (n.f0.which == 1) {
553 NodeSequence ns = (NodeSequence) n.f0.choice;
554 ns.nodes.get(3).accept(this);
557 public void visit(UnaryExpression n) {
558 if ((n.f0.which == 1) || (n.f0.which == 2)) {
559 NodeSequence ns = (NodeSequence) n.f0.choice;
560 ns.nodes.get(1).accept(this);
566 public void visit(UnaryOperator n) {
572 public void visit(PostfixExpression n) {
574 for (int i = 0; i < n.f1.size(); i++) {
575 NodeChoice nc = (NodeChoice) n.f1.elementAt(i);
579 ExpressionBuilder old = current_expression;
580 current_expression = new ExpressionBuilder();
581 NodeSequence ns = (NodeSequence) nc.choice;
582 ns.elementAt(1).accept(this);
583 LineNumberInfo lin = LineNumberInfo.get(n);
584 current_expression.commit(lin.lineEnd);
586 old.push(current_expression.expression);
588 current_expression = old;
592 ExpressionBuilder old = current_expression;
593 current_expression = new ExpressionBuilder();
594 NodeSequence ns = (NodeSequence) nc.choice;
595 ns.elementAt(1).accept(this);
596 LineNumberInfo lin = LineNumberInfo.get (ns.elementAt(1));
597 current_expression.commit(lin.lineEnd);
599 old.push(current_expression.expression);
601 current_expression = old;
607 ExpressionBuilder old = current_expression;
608 LineNumberInfo lin = LineNumberInfo.get(n);
609 old.commit(lin.lineEnd);
610 current_expression = new ExpressionBuilder();
611 NodeSequence ns = (NodeSequence) nc.choice;
612 ns.elementAt(1).accept(this);
617 old.push(current_expression.expression);
618 current_expression = old;
626 throw new Error("Oops!");
631 public void visit(PrimaryExpression n) {
632 if (n.f0.which == 2) {
633 ExpressionBuilder old = current_expression;
634 current_expression = new ExpressionBuilder();
635 NodeSequence ns = (NodeSequence) n.f0.choice;
636 ns.elementAt(1).accept(this);
638 old.push(current_expression.expression);
640 LineNumberInfo lin = LineNumberInfo.get(n);
641 old.commit(lin.lineEnd);
642 current_expression = old;
647 public void visit(ArgumentExpressionList n) {
648 ExpressionBuilder old = current_expression;
649 current_expression = new ExpressionBuilder();
651 old.push(current_expression.expression);
652 for (int i = 0; i < n.f1.size(); i++) {
653 NodeSequence ns = (NodeSequence) n.f1.elementAt(i);
654 current_expression = new ExpressionBuilder();
655 ns.elementAt(1).accept(this);
657 old.push(current_expression.expression);
659 current_expression = old;