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()) {
414 LineNumberInfo lin = LineNumberInfo.get(n.f0);
415 current_expression.commit(lin.lineEnd);
417 NodeSequence ns = (NodeSequence) n.f1.node;
418 ns.nodes.get(0).accept(this);
420 ExpressionBuilder tmp = current_expression;
421 current_expression = new ExpressionBuilder();
422 ns.nodes.get(1).accept(this);
423 lin = LineNumberInfo.get(ns.nodes.get(1));
424 current_expression.commit(lin.lineEnd);
425 tmp.push (current_expression.expression);
426 current_expression = tmp;
428 old.push(current_expression.expression);
429 current_expression = old;
432 public void visit(ExclusiveORExpression n) {
433 assert skip_mode == false;
434 ExpressionBuilder old = current_expression;
435 current_expression = new ExpressionBuilder();
437 if (n.f1.present()) {
438 LineNumberInfo lin = LineNumberInfo.get(n.f0);
439 current_expression.commit(lin.lineEnd);
441 NodeSequence ns = (NodeSequence) n.f1.node;
442 ns.nodes.get(0).accept(this);
444 ExpressionBuilder tmp = current_expression;
445 current_expression = new ExpressionBuilder();
446 ns.nodes.get(1).accept(this);
447 lin = LineNumberInfo.get(ns.nodes.get(1));
448 current_expression.commit(lin.lineEnd);
449 tmp.push (current_expression.expression);
450 current_expression = tmp;
452 old.push(current_expression.expression);
453 current_expression = old;
456 public void visit(ANDExpression n) {
457 assert skip_mode == false;
458 ExpressionBuilder old = current_expression;
459 current_expression = new ExpressionBuilder();
461 if (n.f1.present()) {
462 LineNumberInfo lin = LineNumberInfo.get(n.f0);
463 current_expression.commit(lin.lineEnd);
465 NodeSequence ns = (NodeSequence) n.f1.node;
466 ns.nodes.get(0).accept(this);
468 ExpressionBuilder tmp = current_expression;
469 current_expression = new ExpressionBuilder();
470 ns.nodes.get(1).accept(this);
471 lin = LineNumberInfo.get(ns.nodes.get(1));
472 current_expression.commit(lin.lineEnd);
473 tmp.push (current_expression.expression);
474 current_expression = tmp;
476 old.push(current_expression.expression);
477 current_expression = old;
480 // Safey: this function was fixed to commit the right hand side, the
481 // other similar functions still need to be updated accordingly...
482 public void visit(EqualityExpression n) {
483 assert skip_mode == false;
484 ExpressionBuilder old = current_expression;
485 current_expression = new ExpressionBuilder();
487 if (n.f1.present()) {
488 LineNumberInfo lin = LineNumberInfo.get(n);
489 current_expression.commit(lin.lineEnd);
491 NodeSequence ns = (NodeSequence) n.f1.node;
492 ns.nodes.get(0).accept(this);
494 old.push(current_expression.expression);
495 current_expression = new ExpressionBuilder();
496 ns.nodes.get(1).accept(this);
497 current_expression.commit(lin.lineEnd);
499 old.push(current_expression.expression);
500 current_expression = old;
503 public void visit(RelationalExpression n) {
504 assert skip_mode == false;
505 ExpressionBuilder old = current_expression;
506 current_expression = new ExpressionBuilder();
508 if (n.f1.present()) {
509 LineNumberInfo lin = LineNumberInfo.get(n);
510 current_expression.commit(lin.lineEnd);
512 NodeSequence ns = (NodeSequence) n.f1.node;
513 ns.nodes.get(0).accept(this);
515 old.push(current_expression.expression);
516 current_expression = new ExpressionBuilder();
517 ns.nodes.get(1).accept(this);
518 current_expression.commit(lin.lineEnd);
520 old.push(current_expression.expression);
521 current_expression = old;
524 public void visit(ShiftExpression n) {
525 assert skip_mode == false;
526 ExpressionBuilder old = current_expression;
527 current_expression = new ExpressionBuilder();
529 if (n.f1.present()) {
530 LineNumberInfo lin = LineNumberInfo.get(n.f0);
531 current_expression.commit(lin.lineEnd);
533 NodeSequence ns = (NodeSequence) n.f1.node;
534 ns.nodes.get(0).accept(this);
536 ExpressionBuilder tmp = current_expression;
537 current_expression = new ExpressionBuilder();
538 ns.nodes.get(1).accept(this);
539 lin = LineNumberInfo.get(ns.nodes.get(1));
540 current_expression.commit(lin.lineEnd);
541 tmp.push (current_expression.expression);
542 current_expression = tmp;
544 old.push(current_expression.expression);
545 current_expression = old;
548 public void visit(AdditiveExpression n) {
549 assert skip_mode == false;
550 ExpressionBuilder old = current_expression;
551 current_expression = new ExpressionBuilder();
553 if (n.f1.present()) {
554 LineNumberInfo lin = LineNumberInfo.get(n.f0);
555 current_expression.commit(lin.lineEnd);
557 NodeSequence ns = (NodeSequence) n.f1.node;
558 ns.nodes.get(0).accept(this);
560 ExpressionBuilder tmp = current_expression;
561 current_expression = new ExpressionBuilder();
562 ns.nodes.get(1).accept(this);
563 lin = LineNumberInfo.get(ns.nodes.get(1));
564 current_expression.commit(lin.lineEnd);
565 tmp.push (current_expression.expression);
566 current_expression = tmp;
568 old.push(current_expression.expression);
569 current_expression = old;
572 public void visit(MultiplicativeExpression n) {
573 assert skip_mode == false;
574 ExpressionBuilder old = current_expression;
575 current_expression = new ExpressionBuilder();
577 if (n.f1.present()) {
578 LineNumberInfo lin = LineNumberInfo.get(n.f0);
579 current_expression.commit(lin.lineEnd);
581 NodeSequence ns = (NodeSequence) n.f1.node;
582 ns.nodes.get(0).accept(this);
584 ExpressionBuilder tmp = current_expression;
585 current_expression = new ExpressionBuilder();
586 ns.nodes.get(1).accept(this);
587 lin = LineNumberInfo.get(ns.nodes.get(1));
588 current_expression.commit(lin.lineEnd);
589 tmp.push (current_expression.expression);
590 current_expression = tmp;
592 old.push(current_expression.expression);
593 current_expression = old;
596 public void visit(CastExpression n) {
597 if (n.f0.which == 1) {
601 NodeSequence ns = (NodeSequence) n.f0.choice;
602 ns.nodes.get(3).accept(this);
605 public void visit(UnaryExpression n) {
606 if ((n.f0.which == 1) || (n.f0.which == 2)) {
607 NodeSequence ns = (NodeSequence) n.f0.choice;
608 ns.nodes.get(1).accept(this);
614 public void visit(UnaryOperator n) {
620 public void visit(PostfixExpression n) {
622 for (int i = 0; i < n.f1.size(); i++) {
623 NodeChoice nc = (NodeChoice) n.f1.elementAt(i);
627 ExpressionBuilder old = current_expression;
628 current_expression = new ExpressionBuilder();
629 NodeSequence ns = (NodeSequence) nc.choice;
630 ns.elementAt(1).accept(this);
631 LineNumberInfo lin = LineNumberInfo.get(n);
632 current_expression.commit(lin.lineEnd);
634 old.push(current_expression.expression);
636 current_expression = old;
640 ExpressionBuilder old = current_expression;
641 current_expression = new ExpressionBuilder();
642 NodeSequence ns = (NodeSequence) nc.choice;
643 ns.elementAt(1).accept(this);
644 LineNumberInfo lin = LineNumberInfo.get (ns.elementAt(1));
645 current_expression.commit(lin.lineEnd);
647 old.push(current_expression.expression);
649 current_expression = old;
655 ExpressionBuilder old = current_expression;
656 LineNumberInfo lin = LineNumberInfo.get(n);
657 old.commit(lin.lineEnd);
658 current_expression = new ExpressionBuilder();
659 NodeSequence ns = (NodeSequence) nc.choice;
660 ns.elementAt(1).accept(this);
665 old.push(current_expression.expression);
666 current_expression = old;
674 throw new Error("Oops!");
679 public void visit(PrimaryExpression n) {
680 if (n.f0.which == 2) {
681 ExpressionBuilder old = current_expression;
682 current_expression = new ExpressionBuilder();
683 NodeSequence ns = (NodeSequence) n.f0.choice;
684 ns.elementAt(1).accept(this);
685 LineNumberInfo lin1 = LineNumberInfo.get (ns.elementAt(1));
686 current_expression.commit(lin1.lineEnd);
688 old.push(current_expression.expression);
690 LineNumberInfo lin = LineNumberInfo.get(n);
691 old.commit(lin.lineEnd);
692 current_expression = old;
697 public void visit(ArgumentExpressionList n) {
698 ExpressionBuilder old = current_expression;
699 current_expression = new ExpressionBuilder();
701 old.push(current_expression.expression);
702 for (int i = 0; i < n.f1.size(); i++) {
703 NodeSequence ns = (NodeSequence) n.f1.elementAt(i);
704 current_expression = new ExpressionBuilder();
705 ns.elementAt(1).accept(this);
707 old.push(current_expression.expression);
709 current_expression = old;