summaryrefslogtreecommitdiff
path: root/RGens/src/main/java/bjc/rgens/newparser/RGrammarFormatter.java
blob: 202d9ef777abc6787940bd78c1454cb5a5254094 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
package bjc.rgens.newparser;

import bjc.utils.funcdata.IList;

import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * Format randomized grammars to strings properly.
 * 
 * @author EVE
 *
 */
public class RGrammarFormatter {
	/**
	 * Format a grammar into a file that represents that grammar.
	 * 
	 * @param gram
	 *                The grammar to format.
	 * 
	 * @return The formatted grammar.
	 */
	public static String formatGrammar(RGrammar gram) {
		StringBuilder sb = new StringBuilder();

		Map<String, Rule> rules = gram.getRules();

		String initRuleName = gram.getInitialRule();

		Set<String> processedRules = new HashSet<>();

		if(initRuleName != null) {
			processRule(rules.get(initRuleName), sb);

			processedRules.add(initRuleName);
		}

		for(Rule rule : rules.values()) {
			if(!processedRules.contains(rule.name)) {
				sb.append("\n\n");
				
				processRule(rule, sb);
			}

			processedRules.add(rule.name);
		}

		return sb.toString().trim();
	}

	private static void processRule(Rule rule, StringBuilder sb) {
		IList<RuleCase> cases = rule.getCases();

		StringBuilder ruleBuilder = new StringBuilder();

		ruleBuilder.append(rule.name);
		ruleBuilder.append(" \u2192 ");

		int markerPos = ruleBuilder.length();

		processCase(cases.first(), ruleBuilder);

		sb.append(ruleBuilder.toString().trim());

		ruleBuilder = new StringBuilder();

		for(RuleCase cse : cases.tail()) {
			sb.append("\n\t");

			for(int i = 8; i < markerPos; i++) {
				ruleBuilder.append(" ");
			}

			processCase(cse, ruleBuilder);

			sb.append(ruleBuilder.toString());

			ruleBuilder = new StringBuilder();
		}

	}

	private static void processCase(RuleCase cse, StringBuilder sb) {
		/*
		 * Process each element, adding a space.
		 */
		for(CaseElement element : cse.getElements()) {
			sb.append(element.toString());
			sb.append(" ");
		}

		/*
		 * Remove the trailing space.
		 */
		sb.deleteCharAt(sb.length() - 1);
	}
}