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();
122 old.push(current_expression.expression);
123 LineNumberInfo lin = LineNumberInfo.get(n);
124 old.commit(lin.lineEnd);
126 current_expression = old;
127 skip_mode = old_mode;
131 assert skip_mode == true;
134 public void visit(InitializerList n) {
135 assert skip_mode == true;
137 assert skip_mode == true;
140 public void visit(VariableDeclaration n) {
141 assert skip_mode == true;
145 public void visit(FunctionDeclaration n) {
148 int old_scope = scope_end_line;
149 LineNumberInfo lin = LineNumberInfo.get(n);
150 scope_end_line = lin.lineEnd;
153 assert scope_end_line == lin.lineEnd;
154 scope_end_line = old_scope;
157 public void visit(ParameterDeclaration n) {
159 assert current_expression == null;
160 if (n.f1.present()) {
161 NodeSequence ns = (NodeSequence) n.f1.node;
162 Node var = ns.elementAt(0);
163 current_expression = new ExpressionBuilder();
165 LineNumberInfo lin = LineNumberInfo.get(var);
166 current_expression.commit(lin.lineEnd);
168 current_expression = null;
172 public void visit(InitDeclarator n) {
174 assert current_expression == null;
175 current_expression = new ExpressionBuilder();
177 current_expression = null;
182 public void visit(ExpressionStatement n) {
185 assert current_expression == null;
187 current_expression = new ExpressionBuilder();
189 LineNumberInfo lin = LineNumberInfo.get(n);
190 current_expression.commit(lin.lineEnd);
191 current_expression = null;
195 public void visit(CompoundStatement n) {
196 assert current_expression == null;
197 assert skip_mode == true;
198 int old_end = scope_end_line;
199 scope_end_line = n.f2.endLine;
201 scope_end_line = old_end;
204 public void visit(SwitchStatement n) {
205 assert current_expression == null;
207 current_expression = new ExpressionBuilder();
209 current_expression.commit(n.f0.endLine);
211 current_expression = null;
215 public void visit(IfStatement n) {
216 assert current_expression == null;
218 current_expression = new ExpressionBuilder();
220 current_expression.commit(n.f0.endLine);
222 current_expression = null;
227 public void visit(WhileStatement n) {
228 assert current_expression == null;
230 current_expression = new ExpressionBuilder();
232 current_expression.commit(n.f0.endLine);
234 current_expression = null;
238 public void visit(DoWhileStatement n) {
239 assert current_expression == null;
241 current_expression = new ExpressionBuilder();
243 current_expression.commit(n.f6.endLine);
245 current_expression = null;
249 public void visit(ForStatement n) {
250 assert current_expression == null;
252 int old_scope = scope_end_line;
253 LineNumberInfo lin = LineNumberInfo.get(n);
254 scope_end_line = lin.lineEnd;
255 if (n.f2.present()) {
256 current_expression = new ExpressionBuilder();
258 current_expression.commit(n.f3.endLine);
260 if (n.f4.present()) {
261 current_expression = new ExpressionBuilder();
263 current_expression.commit(n.f5.endLine);
265 if (n.f6.present()) {
266 current_expression = new ExpressionBuilder();
268 current_expression.commit(n.f7.endLine);
271 current_expression = null;
273 scope_end_line = old_scope;
276 public void visit(JumpStatement n) {
279 NodeSequence ns = (NodeSequence) n.f0.choice;
280 assert current_expression == null;
282 current_expression = new ExpressionBuilder();
283 ns.elementAt(1).accept(this);
284 LineNumberInfo lin = LineNumberInfo.get(n);
285 current_expression.commit(lin.lineEnd);
286 current_expression = null;
290 public void visit(Expression n) {
291 ExpressionBuilder old = current_expression;
292 current_expression = new ExpressionBuilder();
294 for (int i = 0; i < n.f1.size(); i++) {
295 NodeSequence ns = (NodeSequence) n.f1.elementAt(i);
296 current_expression = new ExpressionBuilder();
297 ns.elementAt(1).accept(this);
299 old.push(current_expression.expression);
300 current_expression = old;
303 public void visit(AssignmentOperator n) {
309 public void visit(AssignmentExpression n)
313 NodeSequence ns = (NodeSequence) n.f0.choice;
314 UnaryExpression u = (UnaryExpression) ns.elementAt(0);
315 AssignmentOperator ao = (AssignmentOperator) ns.elementAt(1);
316 AssignmentExpression ae = (AssignmentExpression) ns.elementAt(2);
317 LineNumberInfo lin = LineNumberInfo.get(n);
319 ExpressionBuilder old = current_expression;
320 current_expression = new ExpressionBuilder();
322 current_expression.commit(lin.lineEnd);
324 old.push(current_expression.expression);
325 current_expression = new ExpressionBuilder();
327 current_expression.commit(lin.lineEnd);
328 old.push(current_expression.expression);
329 current_expression = old;
333 n.f0.choice.accept (this);
337 public void visit(ConditionalExpression n) {
338 ExpressionBuilder old = current_expression;
339 current_expression = new ExpressionBuilder();
341 old.push(current_expression.expression);
342 if (n.f1.present()) {
343 LineNumberInfo lin = LineNumberInfo.get(n);
344 NodeSequence ns = (NodeSequence) n.f1.node;
345 current_expression = new ExpressionBuilder();
346 ns.elementAt(1).accept(this);
347 current_expression.commit(lin.lineEnd);
349 old.push(current_expression.expression);
350 current_expression = new ExpressionBuilder();
351 ns.elementAt(3).accept(this);
352 current_expression.commit(lin.lineEnd);
354 old.push(current_expression.expression);
355 old.commit(lin.lineEnd);
357 current_expression = old;
360 public void visit(ConstantExpression n) {
364 public void visit(LogicalORExpression n) {
365 assert skip_mode == false;
366 ExpressionBuilder old = current_expression;
367 current_expression = new ExpressionBuilder();
369 if (n.f1.present()) {
370 LineNumberInfo lin = LineNumberInfo.get(n);
371 current_expression.commit(lin.lineEnd);
373 NodeSequence ns = (NodeSequence) n.f1.node;
374 ns.nodes.get(0).accept(this);
376 old.push(current_expression.expression);
377 current_expression = new ExpressionBuilder();
378 ns.nodes.get(1).accept(this);
379 current_expression.commit(lin.lineEnd);
381 old.push(current_expression.expression);
382 current_expression = old;
385 public void visit(LogicalANDExpression n) {
386 assert skip_mode == false;
387 ExpressionBuilder old = current_expression;
388 current_expression = new ExpressionBuilder();
390 if (n.f1.present()) {
391 LineNumberInfo lin = LineNumberInfo.get(n);
392 current_expression.commit(lin.lineEnd);
394 NodeSequence ns = (NodeSequence) n.f1.node;
395 ns.nodes.get(0).accept(this);
397 old.push(current_expression.expression);
398 current_expression = new ExpressionBuilder();
399 ns.nodes.get(1).accept(this);
400 current_expression.commit(lin.lineEnd);
402 old.push(current_expression.expression);
403 current_expression = old;
406 public void visit(InclusiveORExpression n) {
407 assert skip_mode == false;
408 ExpressionBuilder old = current_expression;
409 current_expression = new ExpressionBuilder();
411 if (n.f1.present()) {
413 NodeSequence ns = (NodeSequence) n.f1.node;
414 ns.nodes.get(0).accept(this);
416 ns.nodes.get(1).accept(this);
418 old.push(current_expression.expression);
419 current_expression = old;
422 public void visit(ExclusiveORExpression n) {
423 assert skip_mode == false;
424 ExpressionBuilder old = current_expression;
425 current_expression = new ExpressionBuilder();
427 if (n.f1.present()) {
429 NodeSequence ns = (NodeSequence) n.f1.node;
430 ns.nodes.get(0).accept(this);
432 ns.nodes.get(1).accept(this);
434 old.push(current_expression.expression);
435 current_expression = old;
438 public void visit(ANDExpression n) {
439 assert skip_mode == false;
440 ExpressionBuilder old = current_expression;
441 current_expression = new ExpressionBuilder();
443 if (n.f1.present()) {
445 NodeSequence ns = (NodeSequence) n.f1.node;
446 ns.nodes.get(0).accept(this);
448 ns.nodes.get(1).accept(this);
450 old.push(current_expression.expression);
451 current_expression = old;
454 // Safey: this function was fixed to commit the right hand side, the
455 // other similar functions still need to be updated accordingly...
456 public void visit(EqualityExpression 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);
463 current_expression.commit(lin.lineEnd);
465 NodeSequence ns = (NodeSequence) n.f1.node;
466 ns.nodes.get(0).accept(this);
468 old.push(current_expression.expression);
469 current_expression = new ExpressionBuilder();
470 ns.nodes.get(1).accept(this);
471 current_expression.commit(lin.lineEnd);
473 old.push(current_expression.expression);
474 current_expression = old;
477 public void visit(RelationalExpression n) {
478 assert skip_mode == false;
479 ExpressionBuilder old = current_expression;
480 current_expression = new ExpressionBuilder();
482 if (n.f1.present()) {
483 LineNumberInfo lin = LineNumberInfo.get(n);
484 current_expression.commit(lin.lineEnd);
486 NodeSequence ns = (NodeSequence) n.f1.node;
487 ns.nodes.get(0).accept(this);
489 old.push(current_expression.expression);
490 current_expression = new ExpressionBuilder();
491 ns.nodes.get(1).accept(this);
492 current_expression.commit(lin.lineEnd);
494 old.push(current_expression.expression);
495 current_expression = old;
498 public void visit(ShiftExpression n) {
499 assert skip_mode == false;
500 ExpressionBuilder old = current_expression;
501 current_expression = new ExpressionBuilder();
503 if (n.f1.present()) {
505 NodeSequence ns = (NodeSequence) n.f1.node;
506 ns.nodes.get(0).accept(this);
508 ns.nodes.get(1).accept(this);
510 old.push(current_expression.expression);
511 current_expression = old;
514 public void visit(AdditiveExpression n) {
515 assert skip_mode == false;
516 ExpressionBuilder old = current_expression;
517 current_expression = new ExpressionBuilder();
519 if (n.f1.present()) {
521 NodeSequence ns = (NodeSequence) n.f1.node;
522 ns.nodes.get(0).accept(this);
524 ns.nodes.get(1).accept(this);
526 old.push(current_expression.expression);
527 current_expression = old;
530 public void visit(MultiplicativeExpression n) {
531 assert skip_mode == false;
532 ExpressionBuilder old = current_expression;
533 current_expression = new ExpressionBuilder();
535 if (n.f1.present()) {
537 NodeSequence ns = (NodeSequence) n.f1.node;
538 ns.nodes.get(0).accept(this);
540 ns.nodes.get(1).accept(this);
542 old.push(current_expression.expression);
543 current_expression = old;
546 public void visit(CastExpression n) {
547 if (n.f0.which == 1) {
551 NodeSequence ns = (NodeSequence) n.f0.choice;
552 ns.nodes.get(3).accept(this);
555 public void visit(UnaryExpression n) {
556 if ((n.f0.which == 1) || (n.f0.which == 2)) {
557 NodeSequence ns = (NodeSequence) n.f0.choice;
558 ns.nodes.get(1).accept(this);
564 public void visit(UnaryOperator n) {
570 public void visit(PostfixExpression n) {
572 for (int i = 0; i < n.f1.size(); i++) {
573 NodeChoice nc = (NodeChoice) n.f1.elementAt(i);
577 ExpressionBuilder old = current_expression;
578 current_expression = new ExpressionBuilder();
579 NodeSequence ns = (NodeSequence) nc.choice;
580 ns.elementAt(1).accept(this);
581 LineNumberInfo lin = LineNumberInfo.get(n);
582 current_expression.commit(lin.colEnd);
584 old.push(current_expression.expression);
586 current_expression = old;
590 ExpressionBuilder old = current_expression;
591 current_expression = new ExpressionBuilder();
592 NodeSequence ns = (NodeSequence) nc.choice;
593 ns.elementAt(1).accept(this);
595 old.push(current_expression.expression);
597 current_expression = old;
603 ExpressionBuilder old = current_expression;
604 LineNumberInfo lin = LineNumberInfo.get(n);
605 old.commit(lin.lineEnd);
606 current_expression = new ExpressionBuilder();
607 NodeSequence ns = (NodeSequence) nc.choice;
608 ns.elementAt(1).accept(this);
613 old.push(current_expression.expression);
614 current_expression = old;
622 throw new Error("Oops!");
627 public void visit(PrimaryExpression n) {
628 if (n.f0.which == 2) {
629 ExpressionBuilder old = current_expression;
630 current_expression = new ExpressionBuilder();
631 NodeSequence ns = (NodeSequence) n.f0.choice;
632 ns.elementAt(1).accept(this);
634 old.push(current_expression.expression);
636 LineNumberInfo lin = LineNumberInfo.get(n);
637 old.commit(lin.lineEnd);
638 current_expression = old;
643 public void visit(ArgumentExpressionList n) {
644 ExpressionBuilder old = current_expression;
645 current_expression = new ExpressionBuilder();
647 old.push(current_expression.expression);
648 for (int i = 0; i < n.f1.size(); i++) {
649 NodeSequence ns = (NodeSequence) n.f1.elementAt(i);
650 current_expression = new ExpressionBuilder();
651 ns.elementAt(1).accept(this);
653 old.push(current_expression.expression);
655 current_expression = old;