01: package fri.patterns.interpreter.parsergenerator.syntax;
02:
03: import java.util.*;
04:
05: /**
06: Utilities in conjunction with Syntax and its input structures.
07:
08: @author (c) 2002 Fritz Ritzberger
09: */
10:
11: public abstract class SyntaxUtil {
12: /** Converts syntax String array of arrays to List of Lists. */
13: public static List ruleArrayToList(String[][] array) {
14: return appendToSyntax(array, new ArrayList(array.length));
15: }
16:
17: /** Converts rule String array to List. */
18: public static List ruleToList(String[] rule) {
19: return appendToRule(rule, new ArrayList(rule.length));
20: }
21:
22: /** Appends the syntax array to receiving List. Does not check for uniqueness. Receiver list must not be null. */
23: public static List appendToSyntax(String[][] arrays, List receiver) {
24: for (int i = 0; i < arrays.length; i++)
25: receiver.add(appendToRule(arrays[i], new ArrayList(
26: 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,
53: boolean checkUnique) {
54: int len = 0;
55: for (int i = 0; i < arrays.length; i++)
56: // count global length
57: len += arrays[i].length;
58:
59: List grammar = new ArrayList(len);
60: for (int i = 0; i < arrays.length; i++) {
61: for (int j = 0; j < arrays[i].length; j++) {
62: List rule = new ArrayList(arrays[i][j].length);
63: for (int k = 0; k < arrays[i][j].length; k++)
64: rule.add(arrays[i][j][k]);
65:
66: if (checkUnique == false || grammar.indexOf(rule) < 0)
67: grammar.add(rule);
68: }
69: }
70: return grammar;
71: }
72:
73: /** Mask backslash and double quote by backslash. */
74: public static String maskQuoteAndBackslash(String s) {
75: StringBuffer sb = new StringBuffer(s.length());
76: for (int i = 0; i < s.length(); i++) {
77: char c = s.charAt(i);
78: switch (c) {
79: case '"':
80: case '\\':
81: sb.append('\\');
82: break;
83: }
84: sb.append(c);
85: }
86: return sb.toString();
87: }
88:
89: private SyntaxUtil() {
90: }
91:
92: }
|