| 1 |
/* Soros interpreter (see numbertext.org) |
| 2 |
* 2009-2010 (c) László Németh |
| 3 |
* License: LGPL/BSD dual license */ |
| 4 |
|
| 5 |
package org.numbertext; |
| 6 |
|
| 7 |
import java.util.regex.Pattern; |
| 8 |
import java.util.regex.Matcher; |
| 9 |
import java.util.ArrayList; |
| 10 |
import java.util.List; |
| 11 |
|
| 12 |
public class Soros { |
| 13 |
|
| 14 |
private List<Pattern> patterns = new ArrayList<Pattern>(); |
| 15 |
private List<String> values = new ArrayList<String>(); |
| 16 |
private List<Boolean> begins = new ArrayList<Boolean>(); |
| 17 |
private List<Boolean> ends = new ArrayList<Boolean>(); |
| 18 |
|
| 19 |
private static String m = "\\\";#"; |
| 20 |
private static String m2 = "$()|[]"; |
| 21 |
private static String c = "\uE000\uE001\uE002\uE003"; |
| 22 |
private static String c2 = "\uE004\uE005\uE006\uE007\uE008\uE009"; |
| 23 |
private static String slash = "\uE000"; |
| 24 |
private static String pipe = "\uE003"; |
| 25 |
|
| 26 |
// pattern to recognize function calls in the replacement string |
| 27 |
|
| 28 |
private static Pattern func = Pattern.compile(translate("(?:\\|?(?:\\$\\()+)?" + // optional nested calls |
| 29 |
"(\\|?\\$\\(([^\\(\\)]*)\\)\\|?)" + // inner call (2 subgroups) |
| 30 |
"(?:\uE00A?\\)+\\|?)?", // optional nested calls |
| 31 |
m2.substring(0, c.length()), c, "\\")); // \$, \(, \), \| -> \uE000..\uE003 |
| 32 |
|
| 33 |
public Soros(String source, String lang) { |
| 34 |
source = translate(source, m, c, "\\"); // \\, \", \;, \# -> \uE000..\uE003 |
| 35 |
// switch off all country-dependent lines, and switch on the requested ones |
| 36 |
source = source.replaceAll("(^|[\n;])([^\n;#]*#[^\n]*\\[:[^\n:\\]]*:][^\n]*)", "$1#$2") |
| 37 |
.replaceAll("(^|[\n;])#([^\n;#]*#[^\n]*\\[:" + lang.replace('_', '-') + ":][^\n]*)", "$1$2") |
| 38 |
.replaceAll("(#[^\n]*)?(\n|$)", ";"); // remove comments |
| 39 |
if (source.indexOf("__numbertext__") == -1) { |
| 40 |
source = "__numbertext__;" + source; |
| 41 |
} |
| 42 |
|
| 43 |
String replacement = "\"([a-z][-a-z]* )?0+(0|[1-9]\\d*)\" $(\\1\\2);"; // default left zero deletion |
| 44 |
replacement += "\"\uE00A(.*)\uE00A(.+)\uE00A(.*)\" \\1\\2\\3;"; // separator function |
| 45 |
replacement += "\"\\\"\\uE00A.*\\uE00A\\uE00A.*\\\"\");"; // no separation, if subcall returns with empty string |
| 46 |
source = source.replace("__numbertext__", replacement); |
| 47 |
|
| 48 |
final Pattern p = Pattern.compile("^\\s*(\"[^\"]*\"|[^\\s]*)\\s*(.*[^\\s])?\\s*$"); |
| 49 |
final Pattern macro = Pattern.compile("== *(.*[^ ]?) =="); |
| 50 |
String prefix = ""; |
| 51 |
for (String s : source.split(";")) { |
| 52 |
Matcher matchmacro = macro.matcher(s); |
| 53 |
if (matchmacro.matches()) { |
| 54 |
prefix = matchmacro.group(1); |
| 55 |
continue; |
| 56 |
} |
| 57 |
Matcher sp = p.matcher(s); |
| 58 |
if (!prefix.isEmpty() && !s.isEmpty() && sp.matches()) { |
| 59 |
s = sp.group(1).replaceFirst("^\"", "").replaceFirst("\"$", ""); |
| 60 |
s = "\"" + (s.startsWith("^") ? "^" : "") + prefix + (s.isEmpty() ? "" : " ") |
| 61 |
+ s.replaceFirst("^\\^", "") + "\" " + sp.group(2); |
| 62 |
sp = p.matcher(s); |
| 63 |
} |
| 64 |
if (!s.isEmpty() && sp.matches()) { |
| 65 |
s = translate(sp.group(1).replaceFirst("^\"", "").replaceFirst("\"$", ""), c.substring(1), |
| 66 |
m.substring(1), ""); |
| 67 |
s = s.replace(slash, "\\\\"); // -> \\, ", ;, # |
| 68 |
String s2 = ""; |
| 69 |
if (sp.group(2) != null) { |
| 70 |
s2 = sp.group(2).replaceFirst("^\"", "").replaceFirst("\"$", ""); |
| 71 |
} |
| 72 |
s2 = translate(s2, m2, c2, "\\"); // \$, \(, \), \|, \[, \] -> \uE004..\uE009 |
| 73 |
|
| 74 |
// call inner separator: [ ... $1 ... ] -> $(\uE00A ... \uE00A$1\uE00A ... ) |
| 75 |
s2 = s2.replaceAll("^\\[[$](\\d\\d?|\\([^\\)]+\\))", "\\$(\uE00A\uE00A|\\$$1\uE00A"); // add "|" |
| 76 |
s2 = s2.replaceAll("\\[([^$\\[\\\\]*)[$](\\d\\d?|\\([^\\)]+\\))", "\\$(\uE00A$1\uE00A\\$$2\uE00A"); |
| 77 |
s2 = s2.replaceAll("\\]", ")"); |
| 78 |
s2 = s2.replaceAll("(\\$\\d|\\))\\|\\$", "$1||\\$"); // $()|$() -> $()||$() |
| 79 |
s2 = translate(s2, c, m, ""); // \uE000..\uE003-> \, ", ;, # |
| 80 |
s2 = translate(s2, m2.substring(0, c.length()), c, ""); // $, (, ), | -> \uE000..\uE003 |
| 81 |
s2 = translate(s2, c2, m2, ""); // \uE004..\uE009 -> $, (, ), |, [, ] |
| 82 |
s2 = s2.replaceAll("[$]", "\\$"); // $ -> \$ |
| 83 |
s2 = s2.replaceAll("\uE000(\\d)", "\uE000\uE001\\$$1\uE002"); // $n -> $(\n) |
| 84 |
s2 = s2.replaceAll("\\\\(\\d)", "\\$$1"); // \[n] -> $[n] |
| 85 |
s2 = s2.replace("\\n", "\n"); // \n -> [new line] |
| 86 |
patterns.add(Pattern.compile("^" + s.replaceFirst("^\\^", "").replaceFirst("\\$$", "") + "$")); |
| 87 |
begins.add(s.startsWith("^")); |
| 88 |
ends.add(s.endsWith("$")); |
| 89 |
values.add(s2); |
| 90 |
} |
| 91 |
} |
| 92 |
} |
| 93 |
|
| 94 |
public String run(String input) { |
| 95 |
return run(input, true, true); |
| 96 |
} |
| 97 |
|
| 98 |
private String run(String input, boolean begin, boolean end) { |
| 99 |
for (int i = 0; i < patterns.size(); i++) { |
| 100 |
if ((!begin && begins.get(i)) || (!end && ends.get(i))) { |
| 101 |
continue; |
| 102 |
} |
| 103 |
Matcher m = patterns.get(i).matcher(input); |
| 104 |
if (!m.matches()) { |
| 105 |
continue; |
| 106 |
} |
| 107 |
|
| 108 |
String s = m.replaceAll(values.get(i)); |
| 109 |
Matcher n = func.matcher(s); |
| 110 |
while (n.find()) { |
| 111 |
boolean b = false; |
| 112 |
boolean e = false; |
| 113 |
if (n.group(1).startsWith(pipe) || n.group().startsWith(pipe)) { |
| 114 |
b = true; |
| 115 |
} else if (n.start() == 0) { |
| 116 |
b = begin; |
| 117 |
} |
| 118 |
|
| 119 |
if (n.group(1).endsWith(pipe) || n.group().endsWith(pipe)) { |
| 120 |
e = true; |
| 121 |
} else if (n.end() == s.length()) { |
| 122 |
e = end; |
| 123 |
} |
| 124 |
s = s.substring(0, n.start(1)) + run(n.group(2), b, e) + s.substring(n.end(1)); |
| 125 |
n = func.matcher(s); |
| 126 |
} |
| 127 |
return s; |
| 128 |
} |
| 129 |
return ""; |
| 130 |
} |
| 131 |
|
| 132 |
private static String translate(String s, String chars, String chars2, String delim) { |
| 133 |
for (int i = 0; i < chars.length(); i++) { |
| 134 |
s = s.replace(delim + chars.charAt(i), "" + chars2.charAt(i)); |
| 135 |
} |
| 136 |
return s; |
| 137 |
} |
| 138 |
} |