Java > Open Source Codes > ca > mcgill > sable > soot > launching > SootSavedConfiguration


1 /* Soot - a J*va Optimization Framework
2  * Copyright (C) 2003 Jennifer Lhotak
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the
16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17  * Boston, MA 02111-1307, USA.
18  */
19
20 package ca.mcgill.sable.soot.launching;
21
22 import java.util.*;
23 public class SootSavedConfiguration {
24
25     private HashMap config;
26     private String name;
27     private String saved;
28     private ArrayList saveArray;
29     private ArrayList runArray;
30     private HashMap eclipseDefs;
31
32     
33     private static final String SPACE = " ";
34     private static final String COLON = ":";
35     private static final String DASH = "--";
36     
37     /**
38      * Constructor for SootSavedConfiguration.
39      */
40     public SootSavedConfiguration(String name, HashMap config) {
41         setName(name);
42         setConfig(config);
43     }
44     
45     /**
46      * Constructor for SootSavedConfiguration.
47      */
48     public SootSavedConfiguration(String name, String [] saveArray) {
49         setName(name);
50         
51         setSaveArray(new ArrayList());
52         for (int i = 0; i < saveArray.length; i++){
53             getSaveArray().add(saveArray[i]);
54         }
55     }
56     
57     
58     /**
59      * Constructor for SootSavedConfiguration.
60      */
61     public SootSavedConfiguration(String name, String saved) {
62         setName(name);
63         setSaved(saved);
64     }
65     
66     // same as before (removes defs from HashMap)
67 private void removeEclipseDefs(){
68         if (getEclipseDefs() == null) return;
69         Iterator it = getEclipseDefs().keySet().iterator();
70         while (it.hasNext()) {
71             String key = (String )it.next();
72             if (getConfig().containsKey(key)) {
73                 String needsToMatch = "";
74                 Object val = getEclipseDefs().get(key);
75                 if (val instanceof String ){
76                     needsToMatch = (String )val;
77                 }
78                 else if (val instanceof ArrayList){
79                     Iterator it2 = ((ArrayList)val).iterator();
80                     while (it2.hasNext()){
81                         if (needsToMatch.equals("")){
82                             needsToMatch = (String )it2.next();
83                         }
84                         else {
85                             needsToMatch = needsToMatch + "\r\n" + (String )it2.next();
86                         }
87                     }
88                 }
89                 if (getConfig().get(key).equals(needsToMatch) || getConfig().get(key).equals(val)) {
90                     getConfig().remove(key);
91                 }
92             }
93             else {
94                 getConfig().put(key, getOppositeVal(getEclipseDefs().get(key)) );
95             }
96         }
97     }
98     
99     private Object getOppositeVal(Object val) {
100         if (val instanceof Boolean ) {
101             if (((Boolean )val).booleanValue()) return new Boolean (false);
102             else return new Boolean (true);
103         }
104         else {
105             return "";
106         }
107     }
108     
109     // will use addEclipseDefs to Array instead
110 private void addEclipseDefs() {
111         if (getEclipseDefs() == null) return;
112         Iterator it = getEclipseDefs().keySet().iterator();
113         StringBuffer tempSaved = new StringBuffer (getSaved());
114         while (it.hasNext()) {
115             String key = (String )it.next();
116             if (getSaved().indexOf((DASH+key)) != -1) {
117                 // already there don't add (implies user changed val)
118 }
119             else {
120                 Object val = getEclipseDefs().get(key);
121                 if (val instanceof String ){
122                 
123                     String res = (String )val;
124                     tempSaved.append(SPACE);
125                     tempSaved.append(DASH);
126                     tempSaved.append(key);
127                     tempSaved.append(SPACE);
128                     tempSaved.append(val);
129                     tempSaved.append(SPACE);
130                 }
131                 else {
132                     Iterator it2 = ((ArrayList)val).iterator();
133                     while (it2.hasNext()){
134                         String nextVal = (String )it2.next();
135                         tempSaved.append(SPACE);
136                         tempSaved.append(DASH);
137                         tempSaved.append(key);
138                         tempSaved.append(SPACE);
139                         tempSaved.append(nextVal);
140                         tempSaved.append(SPACE);
141                     }
142                 }
143                 
144             }
145         }
146         setSaved(tempSaved.toString());
147     }
148     
149     // will use this one in future and not addEclipseDefs
150 private void addEclipseDefsToArray() {
151         if (getEclipseDefs() == null) return;
152         Iterator it = getEclipseDefs().keySet().iterator();
153         while (it.hasNext()) {
154             String key = (String )it.next();
155             if (getSaveArray().contains(DASH+key)) {
156                 // already there don't add (implies user changed val)
157 }
158             else {
159                 Object val = getEclipseDefs().get(key);
160                 if (val instanceof String ){
161
162                     String res = (String )val;
163                     getSaveArray().add(DASH+key);
164                     getSaveArray().add(res);
165                     
166                 }
167                 else if (val instanceof Boolean ){
168                     getSaveArray().add(DASH+key);
169                     getSaveArray().add(val.toString());
170                 }
171             }
172         }
173     
174     }
175     
176     public HashMap toHashMapFromArray(){
177         addEclipseDefsToArray();
178         HashMap config = new HashMap();
179         BitSet bits = new BitSet(getSaveArray().size());
180         for (int i = 0; i < getSaveArray().size(); i++){
181             if (((String )getSaveArray().get(i)).indexOf("--") != -1){
182                 bits.set(i);
183             }
184         }
185         int counter = 0;
186         
187         while (counter < getSaveArray().size()){
188             if ((bits.get(counter+2)) || ((counter+2) >= getSaveArray().size())){
189                 // non phase opt
190 // if key is already in map val = val + \n\r newVal
191 String key = ((String )getSaveArray().get(counter)).substring(2);
192                 String val = (String )getSaveArray().get(counter+1);
193                 if (config.get(key) != null){
194                     String tempVal = (String )config.get(key);
195                     tempVal = tempVal + "\r\n" + val;
196                     config.put(key, tempVal);
197                 }
198                 else {
199                     config.put(key,val);
200                 }
201                 counter = counter + 2;
202             }
203             else if ((bits.get(counter+3)) || ((counter+3) >= getSaveArray().size())){
204                 // phase opt
205 String key = getSaveArray().get(counter)+SPACE+getSaveArray().get(counter+1);
206                 StringTokenizer valTemp = new StringTokenizer((String )getSaveArray().get(counter+2), ":");
207                 key = key+SPACE+valTemp.nextToken();
208                 String val = valTemp.nextToken();
209                 config.put(key.substring(2), val);
210                 counter = counter + 3;
211             }
212         }
213         
214         return config;
215         
216     }
217     
218     // goes from save String to HashMap
219 public HashMap toHashMap() {
220         
221         // first add eclipse defs
222 addEclipseDefs();
223         HashMap config = new HashMap();
224         String temp = getSaved();
225         temp = temp.replaceAll("--", "&&");
226         StringTokenizer st = new StringTokenizer(temp, "&&");
227         while (st.hasMoreTokens()) {
228             StringTokenizer next = new StringTokenizer((String )st.nextToken());
229             switch (next.countTokens()) {
230                 case 2: {
231                     config.put(next.nextToken(), next.nextToken());
232                     break;
233                 }
234                 case 3: {
235                     // phase options
236 String key = next.nextToken()+SPACE+next.nextToken();
237                     StringTokenizer valTemp = new StringTokenizer(next.nextToken(), ":");
238                     key = key+SPACE+valTemp.nextToken();
239                     String val = valTemp.nextToken();
240                     config.put(key, val);
241                     break;
242                 }
243                 default: {
244                     //unhandled
245 break;
246                 }
247             }
248         }
249         return config;
250     }
251     
252     // goes from save Array to run Array -
253 //will use this and not toRunString in future
254 public ArrayList toRunArray() {
255         addEclipseDefsToArray();
256         if (getRunArray() == null){
257             setRunArray(new ArrayList());
258         }
259     
260         Iterator it = getSaveArray().iterator();
261         String lastKey = "";
262         while (it.hasNext()){
263             String test = (String )it.next();
264             String spliter = "\r\n";
265             if (test.indexOf("\r\n") != -1){
266                 spliter = "\r\n";
267             }
268             else if (test.indexOf('\n') != -1){
269                 spliter = "\n";
270             }
271             if (test.equals("true")){
272                 // don't send
273 }
274             else if (test.equals("false")){
275                 // don't send and also don't send key
276 int index = getRunArray().size() - 1;
277                 getRunArray().remove(index);
278             }
279             else if (test.indexOf(spliter) != -1){
280                 String [] tokens = test.split(spliter);
281                 getRunArray().add(tokens[0]);
282                 
283                 for (int i = 1; i < tokens.length; i++){
284                     getRunArray().add(lastKey);
285                     getRunArray().add(tokens[i]);
286                 }
287             }
288             else {
289                 getRunArray().add(test);
290             }
291             lastKey = test;
292         }
293         return getRunArray();
294     }
295     
296     // goes from save String to run String
297 public String toRunString() {
298         
299         // first add eclipse defs
300 addEclipseDefs();
301         StringBuffer toRun = new StringBuffer ();
302         String temp = getSaved();
303         temp = temp.replaceAll("--", "&&");
304         StringTokenizer st = new StringTokenizer(temp, "&&");
305         while (st.hasMoreTokens()) {
306             StringTokenizer next = new StringTokenizer((String )st.nextToken());
307             switch (next.countTokens()) {
308                 case 2: {
309                     String key = next.nextToken();
310                     String val = next.nextToken();
311                     val = val.trim();
312                     
313                     // if true its a boolean and want to send
314 if (val.equals("true")) {
315                         toRun.append(DASH);
316                         toRun.append(key);
317                         toRun.append(SPACE);
318                     }
319                     // if false its a boolean but don't want to send
320 else if (val.equals("false")) {
321                     }
322                     // non boolean
323 else {
324                         toRun.append(DASH);
325                         toRun.append(key);
326                         toRun.append(SPACE);
327                         toRun.append(val);
328                         toRun.append(SPACE);
329                     }
330                     break;
331                 }
332                 case 3: {
333                     // phase options
334 String key = next.nextToken()+SPACE+next.nextToken()+SPACE+next.nextToken();
335                     toRun.append(DASH);
336                     toRun.append(key);
337                     toRun.append(SPACE);
338                     break;
339                 }
340                 default: {
341                     //unhandled
342 break;
343                 }
344             }
345         }
346         return toRun.toString();
347     }
348     
349     // goes from HashMap to ArrayList -> will use this and
350 // not toSaveString in future
351 public ArrayList toSaveArray() {
352         if (getSaveArray() == null) {
353             setSaveArray(new ArrayList());
354         }
355         
356         removeEclipseDefs();
357         Iterator keysIt = getConfig().keySet().iterator();
358         while (keysIt.hasNext()) {
359             String key = (String )keysIt.next();
360             StringTokenizer st = new StringTokenizer(key);
361             Object val = getConfig().get(key);
362             switch(st.countTokens()) {
363                 case 1: {
364                     String aliasName = st.nextToken();
365                     if (aliasName.equals("sootMainClass")) continue;
366                     if (val instanceof String ) {
367                         String test = (String )val;
368                         if ((test == null) |(test.length() == 0)) { System.out.println("continuing" ); continue;}
369                     }
370                     getSaveArray().add(DASH+aliasName);
371                     if (val instanceof Boolean ) {
372                         getSaveArray().add(val.toString());
373                     }
374                     else if (val instanceof String ) {
375                         String test = (String )val;
376                         String spliter = "\r\n";
377                         if (test.indexOf("\r\n") != -1){
378                             spliter = "\r\n";
379                         }
380                         else if (test.indexOf('\n') != -1){
381                             spliter = "\n";
382                         }
383                         if (test.indexOf(spliter) != -1){
384                             String [] tokens = test.split(spliter);
385                             getSaveArray().add(tokens[0]);
386                 
387                             for (int i = 1; i < tokens.length; i++){
388                                 getSaveArray().add(DASH+aliasName);
389                                 getSaveArray().add(tokens[i]);
390                             }
391                         }
392                         else {
393                             getSaveArray().add(val);
394                         }
395                     }
396                     break;
397                 }
398                 case 3: {
399                     getSaveArray().add(DASH+st.nextToken());
400                     getSaveArray().add(st.nextToken());
401                     String realVal = st.nextToken()+COLON;
402                     if (val instanceof Boolean ) {
403                         realVal = realVal + val.toString();
404                     }
405                     else if (val instanceof String ) {
406                         realVal = realVal + val;
407                     }
408                     getSaveArray().add(realVal);
409                     break;
410                 }
411                 default: {
412                     //unhandled non option
413 break;
414                 }
415             }
416         }
417         
418         return getSaveArray();
419     }
420     
421     // goeas from HashMap to String - will use toSaveArray in future
422 public String toSaveString() {
423         
424         // first remove eclipse defs
425 removeEclipseDefs();
426         StringBuffer toSave = new StringBuffer ();
427         Iterator keysIt = getConfig().keySet().iterator();
428         while (keysIt.hasNext()) {
429             String key = (String )keysIt.next();
430             StringTokenizer st = new StringTokenizer(key);
431             Object val = getConfig().get(key);
432             switch(st.countTokens()) {
433                 case 1: {
434                     toSave.append(DASH);
435                     String aliasName = st.nextToken();
436                     toSave.append(aliasName);
437                     toSave.append(SPACE);
438                     if (val instanceof Boolean ) {
439                         toSave.append(val.toString());
440                     }
441                     else if (val instanceof String ) {
442                         if (((String )val).indexOf("\n") != -1){
443                             StringTokenizer listOptTokenizer = new StringTokenizer((String )val, "\n");
444                             while (listOptTokenizer.hasMoreTokens()){
445                                 String next = listOptTokenizer.nextToken();
446                                 toSave.append(next);
447                                 if (listOptTokenizer.hasMoreTokens()){
448                                     toSave.append(DASH);
449                                     toSave.append(aliasName);
450                                     toSave.append(SPACE);
451                                 }
452                             }
453                         }
454                         else {
455                             toSave.append(val);
456                         }
457                     }
458                     toSave.append(SPACE);
459                     break;
460                 }
461                 case 3: {
462                     toSave.append(DASH);
463                     toSave.append(st.nextToken());
464                     toSave.append(SPACE);
465                     toSave.append(st.nextToken());
466                     toSave.append(SPACE);
467                     toSave.append(st.nextToken());
468                     toSave.append(COLON);
469                     if (val instanceof Boolean ) {
470                         toSave.append(val.toString());
471                     }
472                     else if (val instanceof String ) {
473                         toSave.append(val);
474                     }
475                     toSave.append(SPACE);
476                     break;
477                 }
478                 default: {
479                     //unhandled non option
480 break;
481                 }
482             }
483             
484             
485         }
486         setSaved(toSave.toString());
487         return toSave.toString();
488     }
489     
490     /**
491      * Returns the config.
492      * @return HashMap
493      */
494     public HashMap getConfig() {
495         return config;
496     }
497
498     /**
499      * Returns the name.
500      * @return String
501      */
502     public String getName() {
503         return name;
504     }
505
506     /**
507      * Sets the config.
508      * @param config The config to set
509      */
510     public void setConfig(HashMap config) {
511         this.config = config;
512     }
513
514     /**
515      * Sets the name.
516      * @param name The name to set
517      */
518     public void setName(String name) {
519         this.name = name;
520     }
521
522     /**
523      * Returns the saved.
524      * @return String
525      */
526     public String getSaved() {
527         return saved;
528     }
529
530     /**
531      * Sets the saved.
532      * @param saved The saved to set
533      */
534     public void setSaved(String saved) {
535         this.saved = saved;
536     }
537
538     
539
540     /**
541      * Returns the eclipseDefs.
542      * @return HashMap
543      */
544     public HashMap getEclipseDefs() {
545         return eclipseDefs;
546     }
547
548     /**
549      * Sets the eclipseDefs.
550      * @param eclipseDefs The eclipseDefs to set
551      */
552     public void setEclipseDefs(HashMap eclipseDefs) {
553         this.eclipseDefs = eclipseDefs;
554     }
555
556     /**
557      * @return
558      */
559     public ArrayList getSaveArray() {
560         return saveArray;
561     }
562
563     /**
564      * @param list
565      */
566     public void setSaveArray(ArrayList list) {
567         saveArray = list;
568     }
569
570     /**
571      * @return
572      */
573     public ArrayList getRunArray() {
574         return runArray;
575     }
576
577     /**
578      * @param list
579      */
580     public void setRunArray(ArrayList list) {
581         runArray = list;
582     }
583
584 }
585

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags