001 package toolbus;
002
003 import java.io.File;
004 import java.io.FileOutputStream;
005 import java.io.IOException;
006 import java.io.PrintWriter;
007 import java.text.DateFormat;
008 import java.util.ArrayList;
009 import java.util.Date;
010 import java.util.HashMap;
011 import java.util.Iterator;
012 import java.util.Map;
013 import java.util.Set;
014 import aterm.ATerm;
015 import aterm.ATermAppl;
016 import aterm.ATermFactory;
017 import aterm.ATermList;
018 import aterm.ATermPlaceholder;
019 import aterm.pure.PureFactory;
020
021 public class JavaTif{
022 private ATermList tifs = null;
023
024 private final ATermFactory factory;
025
026 private final Map<ATermAppl, SpecOrderVector> doEvents;
027 private final Map<ATermAppl, SpecOrderVector> evalEvents;
028 private final Map<ATermAppl, SpecOrderVector> otherEvents;
029 private boolean hasRecAckEvent = false;
030
031 private final String package_name;
032 private final String tool_interface;
033 private final String tool_class;
034 private final String tool_bridge;
035 private final boolean swingTool;
036
037 static void usage(){
038 System.err.println("usage: tifstojava" + " -tool <tool> -tifs <tifs> " + "[-class <class>] [-package <package>] [-swing]");
039 System.exit(0);
040 }
041
042 public static void main(String[] args) throws IOException{
043 String tifsfile = null;
044 String package_name = null, tool_interface = null, tool_class = null;
045 String tool_bridge = null;
046 boolean swingTool = false;
047 String tool = null;
048
049 for(int i = 0; i < args.length; i++){
050 if(args[i].equals("-h")){
051 usage();
052 }else if(args[i].equals("-tool")){
053 tool = args[++i];
054 }else if(args[i].equals("-tifs")){
055 tifsfile = args[++i];
056 }else if(args[i].equals("-package")){
057 package_name = args[++i];
058 }else if(args[i].equals("-tool-interface")){
059 tool_interface = args[++i];
060 }else if(args[i].equals("-tool-class")){
061 tool_class = args[++i];
062 }else if(args[i].equals("-tool-bridge")){
063 tool_bridge = args[++i];
064 }else if(args[i].equals("-swing")){
065 swingTool = true;
066 }
067 }
068
069 if(tool == null || tifsfile == null){
070 usage();
071 }else{
072 String tool_name = JavaTif.capitalize(tool, true);
073 if(tool_interface == null){
074 tool_interface = tool_name + "Tif";
075 }
076 if(tool_class == null){
077 tool_class = tool_name + "Tool";
078 }
079 if(tool_bridge == null){
080 tool_bridge = tool_name + "Bridge";
081 }
082
083 JavaTif gen = new JavaTif(package_name, tool_interface, tool_class, tool_bridge, swingTool);
084 gen.readTifs(tifsfile, tool);
085 gen.genTif();
086 gen.genTool();
087 gen.genBridge();
088 }
089 }
090
091 public JavaTif(String pkg_name, String tool_interface, String tool_class, String tool_bridge, boolean swingTool){
092 doEvents = new HashMap<ATermAppl, SpecOrderVector>();
093 evalEvents = new HashMap<ATermAppl, SpecOrderVector>();
094 otherEvents = new HashMap<ATermAppl, SpecOrderVector>();
095 factory = new PureFactory();
096
097 this.package_name = pkg_name;
098 this.tool_interface = tool_interface;
099 this.tool_class = tool_class;
100 this.tool_bridge = tool_bridge;
101 this.swingTool = swingTool;
102 }
103
104 private void populateMap(ATermList signature){
105 ATermList empty = factory.makeList();
106
107 ATermList toolSignature = signature;
108 while(toolSignature != empty){
109 ATermAppl request = (ATermAppl) toolSignature.getFirst();
110
111 if(request.getAFun().getArity() == 2 && request.getAFun().getName().startsWith("rec-")){
112 ATerm pattern = request.getArgument(1);
113 if(pattern instanceof ATermAppl){
114 ATermAppl appl = (ATermAppl) request.getArgument(1);
115 appl = normalize(appl);
116 SpecOrderVector specOrderVector = new SpecOrderVector();
117 specOrderVector.insert(appl);
118
119 tifs = factory.makeList(request, tifs);
120
121 if(request.getAFun().getName().equals("rec-do")){
122 doEvents.put(appl, specOrderVector);
123 }else if(request.getAFun().getName().equals("rec-eval")){
124 evalEvents.put(appl, specOrderVector);
125 }else if(request.getAFun().getName().equals("rec-ack-event")){
126 hasRecAckEvent = true;
127 }else{
128 otherEvents.put(appl, specOrderVector);
129 }
130 }
131 }
132 toolSignature = toolSignature.getNext();
133 }
134 }
135
136 private void populateMaps(ATermList inputSignature, ATermList outputSignature, ATermList otherSignature, String tool){
137 tifs = factory.makeList();
138
139 populateMap(inputSignature);
140 populateMap(outputSignature);
141 populateMap(otherSignature);
142
143 ATermAppl recTerminate = (ATermAppl) factory.parse("rec-terminate(<"+tool+">, <term>)");
144 tifs = factory.makeList(recTerminate, tifs);
145
146 SpecOrderVector terminateSpecOrderVector = new SpecOrderVector();
147 terminateSpecOrderVector.insert((ATermAppl) factory.parse("rec-terminate(<term>)"));
148 otherEvents.put(recTerminate, terminateSpecOrderVector);
149
150 if(hasRecAckEvent){
151 ATermAppl recAckEvent = (ATermAppl) factory.parse("rec-ack-event(<"+tool+">, <term>)");
152 tifs = factory.makeList(recAckEvent, tifs);
153
154 SpecOrderVector ackEventSpecOrderVector = new SpecOrderVector();
155 ackEventSpecOrderVector.insert((ATermAppl) factory.parse("rec-ack-event(<term>)"));
156 otherEvents.put(recAckEvent, ackEventSpecOrderVector);
157 }
158 }
159
160 private static String capitalize(String str, boolean fc){
161 boolean firstCap = fc;
162 StringBuffer name = new StringBuffer();
163 for(int i = 0; i < str.length(); i++){
164 if(str.charAt(i) == '-')
165 firstCap = true;
166 else{
167 if(firstCap){
168 name.append(Character.toUpperCase(str.charAt(i)));
169 firstCap = false;
170 }else name.append(str.charAt(i));
171 }
172 }
173 return name.toString();
174 }
175
176 private void readTifs(String tifsfile, String tool) throws IOException{
177 ATermList empty = factory.makeList();
178 ATermList allSignatures = (ATermList) factory.readFromFile(tifsfile);
179 while(allSignatures != empty){
180 ATermAppl toolSignature = (ATermAppl) allSignatures.getFirst();
181
182 if(((ATermAppl) toolSignature.getArgument(0)).getAFun().getName().equals(tool)){
183 populateMaps((ATermList) toolSignature.getArgument(1), (ATermList) toolSignature.getArgument(2), (ATermList) toolSignature.getArgument(3), tool);
184 return;
185 }
186
187 allSignatures = allSignatures.getNext();
188 }
189 throw new RuntimeException("No tifs found for tool: "+tool);
190 }
191
192 private void genTif() throws IOException{
193 File path;
194 if(package_name != null){
195 path = new File(package_name.replaceAll("[.]", File.separator));
196 path.mkdirs();
197 }else{
198 path = new File(".");
199 }
200 String filename = path + File.separator + tool_interface + ".java";
201
202 System.out.println("generating file " + filename);
203 PrintWriter out = new PrintWriter(new FileOutputStream(filename));
204 genTifHeader(out);
205 genMethods(out, false);
206 out.println("}");
207 out.close();
208 }
209
210 private void genTifHeader(PrintWriter out){
211 out.println("// Java tool interface " + tool_interface);
212 out.println("// This file is generated automatically, please do not edit!");
213 out.print("// generation time: ");
214 out.println(DateFormat.getDateTimeInstance().format(new Date()));
215
216 out.println();
217 if(package_name != null){
218 out.println("package " + package_name + ";");
219 }
220 out.println();
221 out.println("import aterm.*;");
222 out.println();
223 out.println("public interface " + tool_interface + "{");
224 }
225
226 private void genTool() throws IOException{
227 File path;
228 if(package_name != null){
229 path = new File(package_name.replaceAll("[.]", File.separator));
230 path.mkdirs();
231 }else{
232 path = new File(".");
233 }
234 String filename = path + File.separator + tool_class + ".java";
235
236 System.out.println("generating file " + filename);
237
238 PrintWriter out = new PrintWriter(new FileOutputStream(filename));
239 genHeader(out);
240
241 genSigTable(out);
242 genPatternAttribs(out);
243 out.println();
244
245 genConstructor(out);
246 out.println();
247
248 genInitSigTable(out);
249 out.println();
250 genInitPatterns(out);
251 out.println();
252
253 genHandler(out);
254 out.println();
255 genCheckInputSignature(out);
256 out.println();
257 genNotInInputSignature(out);
258 out.println("}");
259 out.close();
260 }
261
262 private void genSigTable(PrintWriter out){
263 out.println(" // This table will hold the complete input signature");
264 out.println(" private final Set<ATerm> sigTable = new HashSet<ATerm>();");
265 out.println();
266 }
267
268 private void genHeader(PrintWriter out){
269 out.println("// Java tool interface class " + tool_class);
270 out.println("// This file is generated automatically, please do not edit!");
271 out.print("// generation time: ");
272 out.println(DateFormat.getDateTimeInstance().format(new Date()));
273
274 out.println();
275 if(package_name != null){
276 out.println("package " + package_name + ";");
277 }
278 out.println();
279 out.println("import java.util.HashSet;");
280 out.println("import java.util.List;");
281 out.println("import java.util.Set;");
282 out.println();
283 if(swingTool){
284 out.println("import toolbus.SwingTool;");
285 }else{
286 out.println("import toolbus.AbstractTool;");
287 }
288 out.println();
289 out.println("import aterm.ATerm;");
290 out.println("import aterm.ATermAppl;");
291 out.println("import aterm.ATermFactory;");
292 out.println("import aterm.ATermList;");
293 out.println();
294 out.print("abstract public class " + tool_class);
295 if(swingTool){
296 out.print(" extends SwingTool");
297 }else{
298 out.print(" extends AbstractTool");
299 }
300 out.print(" implements " + tool_interface);
301 out.println("{");
302 }
303
304 private void genPatternAttribs(PrintWriter out){
305 out.println(" // Patterns that are used to match against incoming terms");
306
307 Set<ATermAppl> eventKeys = doEvents.keySet();
308 Iterator<ATermAppl> eventKeysIterator = eventKeys.iterator();
309 while(eventKeysIterator.hasNext()){
310 ATermAppl key = eventKeysIterator.next();
311 SpecOrderVector v = doEvents.get(key);
312 v.genPatternAttribs(out, capitalize(key.getName(), false));
313 }
314
315 Set<ATermAppl> evalKeys = evalEvents.keySet();
316 Iterator<ATermAppl> evalKeysIterator = evalKeys.iterator();
317 while(evalKeysIterator.hasNext()){
318 ATermAppl key = evalKeysIterator.next();
319 SpecOrderVector v = evalEvents.get(key);
320 v.genPatternAttribs(out, capitalize(key.getName(), false));
321 }
322
323 Set<ATermAppl> otherEventsKeys = otherEvents.keySet();
324 Iterator<ATermAppl> otherEventsKeysIterator = otherEventsKeys.iterator();
325 while(otherEventsKeysIterator.hasNext()){
326 ATermAppl key = otherEventsKeysIterator.next();
327 SpecOrderVector v = otherEvents.get(key);
328 v.genPatternAttribs(out, capitalize(key.getName(), false));
329 }
330 }
331
332 private void genConstructor(PrintWriter out){
333 String decl = "protected " + tool_class + "(ATermFactory factory)";
334 out.println(" // Mimic the constructor from the AbstractTool class");
335 out.println(" " + decl);
336 out.println(" {");
337 out.println(" super(factory);");
338 out.println(" initSigTable();");
339 out.println(" initPatterns();");
340 out.println(" }");
341 }
342
343 private void genInitSigTable(PrintWriter out){
344 String decl = "private void initSigTable()";
345 out.println(" // This method initializes the table with input signatures");
346 out.println(" " + decl);
347 out.println(" {");
348 ATermList sigs = tifs;
349 while(!sigs.isEmpty()){
350 ATerm sig = sigs.getFirst();
351 sigs = sigs.getNext();
352 out.print(" sigTable.add(factory.parse(\"");
353 out.print(sig.toString());
354 out.println("\"));");
355 }
356 out.println(" }");
357 }
358
359 private void genInitPatterns(PrintWriter out){
360 String decl = "private void initPatterns()";
361 out.println(" // Initialize the patterns that are used to match against incoming terms");
362 out.println(" " + decl);
363 out.println(" {");
364
365 Set<ATermAppl> eventKeys = doEvents.keySet();
366 Iterator<ATermAppl> eventKeysIterator = eventKeys.iterator();
367 while(eventKeysIterator.hasNext()){
368 ATermAppl key = eventKeysIterator.next();
369 SpecOrderVector v = doEvents.get(key);
370 v.genPatterns(out, capitalize(key.getName(), false), "rec-do");
371 }
372
373 Set<ATermAppl> evalKeys = evalEvents.keySet();
374 Iterator<ATermAppl> evalKeysIterator = evalKeys.iterator();
375 while(evalKeysIterator.hasNext()){
376 ATermAppl key = evalKeysIterator.next();
377 SpecOrderVector v = evalEvents.get(key);
378 v.genPatterns(out, capitalize(key.getName(), false), "rec-eval");
379 }
380
381 Set<ATermAppl> otherEventsKeys = otherEvents.keySet();
382 Iterator<ATermAppl> otherEventsKeysIterator = otherEventsKeys.iterator();
383 while(otherEventsKeysIterator.hasNext()){
384 ATermAppl key = otherEventsKeysIterator.next();
385 SpecOrderVector v = otherEvents.get(key);
386 v.genPatterns(out, capitalize(key.getName(), false), null);
387 }
388
389 out.println(" }");
390 }
391
392 private void genHandler(PrintWriter out){
393 String decl = "public ATerm handler(ATerm term)";
394 out.println(" // The generic handler calls the specific handlers");
395 out.println(" " + decl);
396 out.println(" {");
397 out.println(" List<?> result;");
398 out.println();
399
400 Set<ATermAppl> eventKeys = doEvents.keySet();
401 Iterator<ATermAppl> eventKeysIterator = eventKeys.iterator();
402 while(eventKeysIterator.hasNext()){
403 ATermAppl key = eventKeysIterator.next();
404 SpecOrderVector v = doEvents.get(key);
405 v.genCalls(out, capitalize(key.getName(), false), false);
406 }
407
408 Set<ATermAppl> evalKeys = evalEvents.keySet();
409 Iterator<ATermAppl> evalKeysIterator = evalKeys.iterator();
410 while(evalKeysIterator.hasNext()){
411 ATermAppl key = evalKeysIterator.next();
412 SpecOrderVector v = evalEvents.get(key);
413 v.genCalls(out, capitalize(key.getName(), false), true);
414 }
415
416 Set<ATermAppl> otherEventsKeys = otherEvents.keySet();
417 Iterator<ATermAppl> otherEventsKeysIterator = otherEventsKeys.iterator();
418 while(otherEventsKeysIterator.hasNext()){
419 ATermAppl key = otherEventsKeysIterator.next();
420 SpecOrderVector v = otherEvents.get(key);
421 v.genCalls(out, capitalize(key.getName(), false), false);
422 }
423
424 out.println();
425 out.println(" notInInputSignature(term);");
426 out.println(" return null;");
427 out.println(" }");
428 }
429
430 private void genMethods(PrintWriter out, boolean gen_impl){
431 Set<ATermAppl> eventKeys = doEvents.keySet();
432 Iterator<ATermAppl> eventKeysIterator = eventKeys.iterator();
433 while(eventKeysIterator.hasNext()){
434 ATermAppl key = eventKeysIterator.next();
435 SpecOrderVector v = doEvents.get(key);
436 v.genMethods(out, capitalize(key.getName(), false), false, gen_impl);
437 }
438
439 Set<ATermAppl> evalKeys = evalEvents.keySet();
440 Iterator<ATermAppl> evalKeysIterator = evalKeys.iterator();
441 while(evalKeysIterator.hasNext()){
442 ATermAppl key = evalKeysIterator.next();
443 SpecOrderVector v = evalEvents.get(key);
444 v.genMethods(out, capitalize(key.getName(), false), true, gen_impl);
445 }
446
447 Set<ATermAppl> otherEventsKeys = otherEvents.keySet();
448 Iterator<ATermAppl> otherEventsKeysIterator = otherEventsKeys.iterator();
449 while(otherEventsKeysIterator.hasNext()){
450 ATermAppl key = otherEventsKeysIterator.next();
451 SpecOrderVector v = otherEvents.get(key);
452 v.genMethods(out, capitalize(key.getName(), false), false, gen_impl);
453 }
454 }
455
456 private void genCheckInputSignature(PrintWriter out){
457 String decl = "public void checkInputSignature(ATermList sigs)";
458 out.println(" // Check the input signature");
459 out.println(" " + decl);
460 out.println(" {");
461 out.println(" while(!sigs.isEmpty()) {");
462 out.println(" ATermAppl sig = (ATermAppl)sigs.getFirst();");
463 out.println(" sigs = sigs.getNext();");
464 out.println(" if (!sigTable.contains(sig)) {");
465 out.println(" // Sorry, but the term is not in the input signature!");
466 out.println(" notInInputSignature(sig);");
467 out.println(" }");
468 out.println(" }");
469 out.println(" }");
470 }
471
472 private void genNotInInputSignature(PrintWriter out){
473 String decl = "void notInInputSignature(ATerm t)";
474 out.println(" // This function is called when an input term");
475 out.println(" // was not in the input signature.");
476 out.println(" " + decl);
477 out.println(" {");
478 out.println(" throw new RuntimeException(" + "\"term not in input signature: \" + t);");
479 out.println(" }");
480 }
481
482 private void genBridge() throws IOException{
483 File path;
484 if(package_name != null){
485 path = new File(package_name.replaceAll("[.]", File.separator));
486 path.mkdirs();
487 }else{
488 path = new File(".");
489 }
490 String filename = path + File.separator + tool_bridge + ".java";
491
492 System.out.println("generating file " + filename);
493 PrintWriter out = new PrintWriter(new FileOutputStream(filename));
494 genBridgeHeader(out);
495
496 out.println(" private final " + tool_interface + " tool;");
497 out.println();
498 String decl = "public " + tool_bridge + "(ATermFactory factory, " + tool_interface + " tool)";
499 out.println(" " + decl + "{");
500 out.println(" super(factory);");
501 out.println(" this.tool = tool;");
502 out.println(" }");
503 out.println();
504
505 genMethods(out, true);
506 out.println("}");
507 out.close();
508 }
509
510 private void genBridgeHeader(PrintWriter out){
511 out.println("// Java tool bridge " + tool_bridge);
512 out.println("// This file is generated automatically, please do not edit!");
513 out.print("// generation time: ");
514 out.println(DateFormat.getDateTimeInstance().format(new Date()));
515
516 out.println();
517 if(package_name != null){
518 out.println("package " + package_name + ";");
519 }
520 out.println();
521 out.println("import aterm.*;");
522 out.println();
523 out.print("public class " + tool_bridge);
524 out.print(" extends " + tool_class);
525 out.println("{");
526 }
527
528 private ATermAppl normalize(ATermAppl appl){
529 ATermList args = appl.getArguments();
530 int len = args.getLength();
531 ATerm[] newargs = new ATerm[len];
532 String type = null;
533
534 for(int i = 0; i < len; i++){
535 ATerm arg = args.getFirst();
536 args = args.getNext();
537 switch(arg.getType()){
538 case ATerm.APPL:
539 type = "<term>";
540 break;
541 case ATerm.INT:
542 type = "<int>";
543 break;
544 case ATerm.REAL:
545 type = "<real>";
546 break;
547 case ATerm.PLACEHOLDER:
548 type = arg.toString();
549 if(!type.equals("<int>") && !type.equals("<str>") && !type.equals("<real>")){
550 type = "<term>";
551 }
552 // newargs[i] = arg;
553 break;
554 case ATerm.LIST:
555 type = "<term>";
556 break;
557 }
558 if(newargs[i] == null){
559 newargs[i] = factory.parse(type);
560 }
561 }
562 return factory.makeAppl(appl.getAFun(), newargs);
563 }
564 }
565
566 class SpecOrderVector extends ArrayList<ATermAppl>{
567 private static final long serialVersionUID = -864376275786608076L;
568
569 public void insert(ATermAppl appl){
570 for(int i = 0; i < size(); i++){
571 if(moreSpecific(appl, get(i))){
572 add(i, appl);
573 return;
574 }
575 }
576 add(appl);
577 }
578
579 private boolean moreSpecific(ATerm a, ATerm b){
580 if(a == b) return true;
581 if(a.equals(b)) return true;
582 if(a.getType() > b.getType()) return true;
583 if(a.getType() < b.getType()) return false;
584 switch(a.getType()){
585 case ATerm.APPL:
586 ATermAppl appl1 = (ATermAppl) a;
587 ATermAppl appl2 = (ATermAppl) b;
588 if(appl1.getName().equals(appl2.getName())) return moreSpecific(appl1.getArguments(), appl2.getArguments());
589 if(moreSpecific(appl1.getName(), appl2.getName())) return true;
590 return false;
591 case ATerm.PLACEHOLDER:
592 ATermPlaceholder p1 = (ATermPlaceholder) a;
593 ATermPlaceholder p2 = (ATermPlaceholder) b;
594 return moreSpecific(p1.getPlaceholder(), p2.getPlaceholder());
595 case ATerm.LIST:
596 ATermList terms1 = (ATermList) a;
597 ATermList terms2 = (ATermList) b;
598 if(terms1.isEmpty()) return true;
599 if(terms2.isEmpty()) return false;
600 if(terms1.getFirst().equals(terms2.getFirst())) return moreSpecific(terms1.getNext(), terms2.getNext());
601 return moreSpecific(terms1.getFirst(), terms2.getFirst());
602 }
603 return false; // compiler!
604 }
605
606 private boolean moreSpecific(String a, String b){
607 int i;
608 for(i = 0; i < a.length(); i++){
609 if(i > b.length()) return true;
610 if(a.charAt(i) < b.charAt(i)) return true;
611 }
612 return false;
613 }
614
615 public void print(PrintWriter out){
616 for(int i = 0; i < size(); i++){
617 out.println(get(i).toString());
618 }
619 }
620
621 public void genPatterns(PrintWriter out, String base, String func){
622 for(int i = 0; i < size(); i++){
623 out.print(" P" + base + i + " = factory.parse(\"");
624 if(func != null){
625 out.print(func + "(");
626 }
627 out.print(get(i).toString());
628 if(func != null){
629 out.print(")");
630 }
631 out.println("\");");
632 }
633 }
634
635 public void genPatternAttribs(PrintWriter out, String base){
636 for(int i = 0; i < size(); i++)
637 out.println(" private ATerm P" + base + i + ";");
638 }
639
640 public void genCalls(PrintWriter out, String base, boolean ret){
641 for(int i = 0; i < size(); i++){
642 ATermAppl appl = get(i);
643 out.println(" result = term.match(P" + base + i + ");");
644 out.println(" if (result != null) {");
645 if(ret){
646 out.print(" return " + base + "(");
647 }else{
648 out.print(" " + base + "(");
649 }
650
651 genArgs(out, appl.getArguments());
652 out.println(");");
653 if(!ret){
654 out.println(" return null;");
655 }
656 out.println(" }");
657 }
658 }
659
660 private static void genArgs(PrintWriter out, ATermList args){
661 ATermList arguments = args;
662 int idx = 0;
663
664 while(!arguments.isEmpty()){
665 ATermPlaceholder ph = (ATermPlaceholder) arguments.getFirst();
666 String fun = ((ATermAppl) ph.getPlaceholder()).getName();
667 arguments = arguments.getNext();
668 if(fun.equals("int"))
669 out.print("((Integer) result.get(" + idx + ")).intValue()");
670 else if(fun.equals("real"))
671 out.print("((Double) result.get(" + idx + ")).doubleValue()");
672 else if(fun.equals("term"))
673 out.print("(ATerm) result.get(" + idx + ")");
674 else if(fun.equals("appl"))
675 out.print("(ATermAppl) result.get(" + idx + ")");
676 else if(fun.equals("list"))
677 out.print("(ATermList) result.get(" + idx + ")");
678 else if(fun.equals("str"))
679 out.print("(String) result.get(" + idx + ")");
680 else out.print("(ATermAppl) result.get(" + idx + ")");
681 if(!arguments.isEmpty()) out.print(", ");
682 idx++;
683 }
684 }
685
686 public void genMethods(PrintWriter out, String base, boolean ret, boolean gen_impl){
687 for(int i = 0; i < size(); i++){
688 ATermAppl appl = get(i);
689
690 String decl;
691
692 if(ret){
693 decl = "public ATerm " + base + "(";
694 }else{
695 decl = "public void " + base + "(";
696 }
697
698 decl += buildFormals(appl.getArguments());
699 decl += ")";
700
701 out.print(" " + decl);
702
703 if(gen_impl){
704 out.println("{");
705 out.print(" " + (ret ? "return " : "") + "tool." + base + "(");
706 genActuals(out, appl.getArguments());
707 out.println(");");
708 out.println(" }");
709 out.println();
710 }else{
711 out.println(";");
712 }
713 }
714 }
715
716 private static String buildFormals(ATermList args){
717 ATermList arguments = args;
718 int idx = 0;
719 StringBuffer result = new StringBuffer();
720
721 while(!arguments.isEmpty()){
722 ATermPlaceholder ph = (ATermPlaceholder) arguments.getFirst();
723 String fun = ((ATermAppl) ph.getPlaceholder()).getName();
724 arguments = arguments.getNext();
725 if(fun.equals("int")){
726 result.append("int i" + idx);
727 }else if(fun.equals("real")){
728 result.append("double d" + idx);
729 }else if(fun.equals("term")){
730 result.append("ATerm t" + idx);
731 }else if(fun.equals("appl")){
732 result.append("ATermAppl a" + idx);
733 }else if(fun.equals("list")){
734 result.append("ATermList l" + idx);
735 }else if(fun.equals("str")){
736 result.append("String s" + idx);
737 }else{
738 result.append("ATermAppl a" + idx);
739 }
740
741 if(!arguments.isEmpty()){
742 result.append(", ");
743 }
744 idx++;
745 }
746
747 return result.toString();
748 }
749
750 private static void genActuals(PrintWriter out, ATermList args){
751 ATermList arguments = args;
752 int idx = 0;
753
754 while(!arguments.isEmpty()){
755 ATermPlaceholder ph = (ATermPlaceholder) arguments.getFirst();
756 String fun = ((ATermAppl) ph.getPlaceholder()).getName();
757 arguments = arguments.getNext();
758 if(fun.equals("int")){
759 out.print("i" + idx);
760 }else if(fun.equals("real")){
761 out.print("d" + idx);
762 }else if(fun.equals("term")){
763 out.print("t" + idx);
764 }else if(fun.equals("appl")){
765 out.print("a" + idx);
766 }else if(fun.equals("list")){
767 out.print("l" + idx);
768 }else if(fun.equals("str")){
769 out.print("s" + idx);
770 }else{
771 out.print("a" + idx);
772 }
773
774 if(!arguments.isEmpty()){
775 out.print(", ");
776 }
777 idx++;
778 }
779 }
780 }