SyntaxUtil


1   package fri.patterns.interpreter.parsergenerator.syntax;
2   
3   import java.util.*;
4   
5   /**
6       Utilities in conjunction with Syntax and its input structures.
7   
8       @author (c) 2002 Fritz Ritzberger
9   */
10  
11  public abstract class SyntaxUtil
12  {
13      /** Converts syntax String array of arrays to List of Lists. */
14      public static List ruleArrayToList(String   [][] array)   {
15          return appendToSyntax(array, new ArrayList(array.length));
16      }
17  
18      /** Converts rule String array to List. */
19      public static List ruleToList(String   [] rule)   {
20          return appendToRule(rule, new ArrayList(rule.length));
21      }
22  
23      /** Appends the syntax array to receiving List. Does not check for uniqueness. Receiver list must not be null. */
24      public static List appendToSyntax(String   [][] arrays, List receiver)    {
25          for (int i = 0; i < arrays.length; i++)
26              receiver.add(appendToRule(arrays[i], new ArrayList(arrays[i].length)));
27          return receiver;
28      }
29  
30      /** Appends the rule array to receiving List. Receiver list must not be null. */
31      public static List appendToRule(String   [] array, List receiver) {
32          for (int i = 0; i < array.length; i++)
33              receiver.add(array[i]);
34          return receiver;
35      }
36  
37      /**
38          Build together some syntaxes to one List of Lists. Does not check for uniqueness.
39      */
40      public static List catenizeRules(String   [][][] arrays)  {
41          return catenizeRules(arrays, false);
42      }
43      
44      /**
45          Build together some syntaxes to one List of Lists. Checks for uniqueness
46          (this is not really needed as Syntax checks for uniqueness on construction or when adding rules).
47      */
48      public static final List catenizeRulesUnique(String   [][][] arrays)  {
49          return catenizeRules(arrays, true);
50      }
51      
52      private static final List catenizeRules(String   [][][] arrays, boolean checkUnique)  {
53          int len = 0;
54          for (int i = 0; i < arrays.length; i++) // count global length
55              len += arrays[i].length;
56              
57          List grammar = new ArrayList(len);
58          for (int i = 0; i < arrays.length; i++) {
59              for (int j = 0; j < arrays[i].length; j++)  {
60                  List rule = new ArrayList(arrays[i][j].length);
61                  for (int k = 0; k < arrays[i][j].length; k++)
62                      rule.add(arrays[i][j][k]);
63                  
64                  if (checkUnique == false || grammar.indexOf(rule) < 0)
65                      grammar.add(rule);
66              }
67          }
68          return grammar;
69      }
70  
71  
72      /** Mask backslash and double quote by backslash. */
73      public static String   maskQuoteAndBackslash(String   s)    {
74          StringBuffer   sb = new StringBuffer  (s.length());
75          for (int i = 0; i < s.length(); i++)    {
76              char c = s.charAt(i);
77              switch (c)  {
78                  case '"':
79                  case '\\':
80                      sb.append('\\');
81                      break;
82              }
83              sb.append(c);
84          }
85          return sb.toString();
86      }
87  
88  
89      private SyntaxUtil()    {}
90  
91  }
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags