io.bdrc.lucene.sa.transliteration.FSM Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of lucene-sa Show documentation
Show all versions of lucene-sa Show documentation
Sanskrit and Pali Lucene analyzer and components
//package io.bdrc.lucene.sa.transliteration;
//
//import java.util.Hashtable;
//import java.util.ArrayList;
//import java.nio.charset.Charset;
////import java.nio.charset.CharsetDecoder;
//import java.io.FileInputStream;
//import java.io.BufferedInputStream;
//import java.io.InputStreamReader;
//import java.io.BufferedReader;
//import java.io.BufferedWriter;
//import java.io.FileOutputStream;
//import java.io.BufferedOutputStream;
//import java.io.ByteArrayOutputStream;
//import java.util.regex.Pattern;
//import java.util.regex.Matcher;
//import java.io.OutputStreamWriter;
//import java.io.InputStream;
//import javax.xml.parsers.SAXParser;
//import javax.xml.parsers.SAXParserFactory;
//import org.sanskritlibrary.webservice.TransformMap;
//import org.sanskritlibrary.webservice.WebServices;
//import org.xml.sax.Attributes;
//import org.xml.sax.Locator;
//import org.xml.sax.SAXException;
//import org.xml.sax.helpers.DefaultHandler;
//
//public class FSM extends DefaultHandler {
//
// public static boolean dumpBuffers = false;
//
// public enum OptionsUnknown {
//
// FLAG, ASIS, IGNORE
// };
//
// public enum OptionsFlagged {
//
// ASIS_DELIMS, ASIS_NO_DELIMS, IGNORE
// };
// public static Hashtable punctuation = new Hashtable();
// public static Hashtable slpCharacter = new Hashtable();
// public static Hashtable slpCharacterNoAccent = new Hashtable();
// public static Hashtable slpVowel = new Hashtable();
// static boolean debug = false;
// static int matchCount = 0;
// static int processLineNum = 0;
// static public String transcodersDirectory;
// public static Hashtable unknownChars = new Hashtable();
// public static Hashtable sharedState = new Hashtable();
// String inputType;
// String outputType;
// boolean inputIsUnicodeInSecondPlane = false;
// boolean outputIsUnicodeInSecondPlane = false;
// boolean capitalsSupported = false;
// String version;
// public String sharedStateName;
// SymbolTable symtab;
// BufferManager bufferManager;
// StringBuilder resultBuffer;
// String sourceEncoding;
// Hashtable params = new Hashtable();
// String tradition = null;
// String traditionStyle = null;
// boolean updateTarget = false;
// boolean useAlternate = false;
// String currentTradition = null;
// Hashtable overriddenEntries = new Hashtable();
// FSMEntry[] fsmEntry;
// StateInfo state = null;
// boolean clearState = true;
// boolean testBlanks = false; // check if a dependant character follows a blank.
// static Hashtable> badChars = new Hashtable>();
// Hashtable> charOptions;
// Hashtable missing = new Hashtable();
// Hashtable dependantCharacters = new Hashtable();
// Hashtable edgeKeys;
// BufferInfo wb = null;
// String addto; // if this FSM extends another, this is name of file containing the other FSM
// // SAX stuff
// ArrayList elements;
// FSMEntry wfe;
// ArrayList fsmEntries;
// Locator locator;
// ArrayList mib;
// ArrayList mergeb;
// FSMEntry ligfse;
// Buffer workingBuffer;
// boolean foundEntries = false;
// boolean foundLigatures = false;
// boolean foundMerges = false;
// boolean foundBuffers = false;
// boolean createNewBuffers = true;
// boolean buffersExist = false;
// Cacher cacher = null;
//
// static {
// punctuation.put('~', true);
// punctuation.put('`', true);
// punctuation.put('!', true);
// punctuation.put('@', true);
// punctuation.put('#', true);
// punctuation.put('$', true);
// punctuation.put('%', true);
// punctuation.put('^', true);
// punctuation.put('&', true);
// punctuation.put('*', true);
// punctuation.put('(', true);
// punctuation.put(')', true);
// punctuation.put('_', true);
// punctuation.put('-', true);
// punctuation.put('+', true);
// punctuation.put('=', true);
// punctuation.put('{', true);
// punctuation.put('}', true);
// punctuation.put('[', true);
// punctuation.put(']', true);
// punctuation.put('|', true);
// punctuation.put('\\', true);
// punctuation.put(':', true);
// punctuation.put(';', true);
// punctuation.put('"', true);
// punctuation.put('\'', true);
// punctuation.put('<', true);
// punctuation.put(',', true);
// punctuation.put('>', true);
// punctuation.put('.', true);
// punctuation.put('?', true);
// punctuation.put('/', true);
//
// slpCharacter.put(' ', true);
// slpCharacter.put((char) 0x09, true);
// slpCharacter.put((char) 0x0d, true);
// slpCharacter.put((char) 0x0a, true);
// slpCharacter.put('0', true);
// slpCharacter.put('1', true);
// slpCharacter.put('2', true);
// slpCharacter.put('3', true);
// slpCharacter.put('4', true);
// slpCharacter.put('5', true);
// slpCharacter.put('6', true);
// slpCharacter.put('7', true);
// slpCharacter.put('8', true);
// slpCharacter.put('9', true);
//
// slpCharacter.put('a', true);
// slpCharacter.put('A', true);
// slpCharacter.put('i', true);
// slpCharacter.put('I', true);
// slpCharacter.put('u', true);
// slpCharacter.put('U', true);
// slpCharacter.put('f', true);
// slpCharacter.put('F', true);
// slpCharacter.put('x', true);
// slpCharacter.put('X', true);
// slpCharacter.put('e', true);
// slpCharacter.put('E', true);
// slpCharacter.put('o', true);
// slpCharacter.put('O', true);
// slpCharacter.put('M', true);
// slpCharacter.put('H', true);
// slpCharacter.put('k', true);
// slpCharacter.put('K', true);
// slpCharacter.put('g', true);
// slpCharacter.put('G', true);
// slpCharacter.put('N', true);
// slpCharacter.put('c', true);
// slpCharacter.put('C', true);
// slpCharacter.put('j', true);
// slpCharacter.put('J', true);
// slpCharacter.put('Y', true);
// slpCharacter.put('w', true);
// slpCharacter.put('W', true);
// slpCharacter.put('q', true);
// slpCharacter.put('Q', true);
// slpCharacter.put('R', true);
// slpCharacter.put('t', true);
// slpCharacter.put('T', true);
// slpCharacter.put('d', true);
// slpCharacter.put('D', true);
// slpCharacter.put('|', true);
// slpCharacter.put('n', true);
// slpCharacter.put('p', true);
// slpCharacter.put('P', true);
// slpCharacter.put('b', true);
// slpCharacter.put('B', true);
// slpCharacter.put('m', true);
// slpCharacter.put('y', true);
// slpCharacter.put('r', true);
// slpCharacter.put('l', true);
// slpCharacter.put('v', true);
// slpCharacter.put('S', true);
// slpCharacter.put('z', true);
// slpCharacter.put('s', true);
// slpCharacter.put('h', true);
// slpCharacter.put('\'', true);
// slpCharacter.put('/', true);
// slpCharacter.put('\\', true);
// slpCharacter.put('^', true);
// slpCharacter.put('~', true);
// slpCharacter.put('?', true);
// slpCharacter.put('.', true);
//
//
// slpCharacterNoAccent.put('a', true);
// slpCharacterNoAccent.put('A', true);
// slpCharacterNoAccent.put('i', true);
// slpCharacterNoAccent.put('I', true);
// slpCharacterNoAccent.put('u', true);
// slpCharacterNoAccent.put('U', true);
// slpCharacterNoAccent.put('f', true);
// slpCharacterNoAccent.put('F', true);
// slpCharacterNoAccent.put('x', true);
// slpCharacterNoAccent.put('X', true);
// slpCharacterNoAccent.put('e', true);
// slpCharacterNoAccent.put('E', true);
// slpCharacterNoAccent.put('o', true);
// slpCharacterNoAccent.put('O', true);
// slpCharacterNoAccent.put('M', true);
// slpCharacterNoAccent.put('H', true);
// slpCharacterNoAccent.put('k', true);
// slpCharacterNoAccent.put('K', true);
// slpCharacterNoAccent.put('g', true);
// slpCharacterNoAccent.put('G', true);
// slpCharacterNoAccent.put('N', true);
// slpCharacterNoAccent.put('c', true);
// slpCharacterNoAccent.put('C', true);
// slpCharacterNoAccent.put('j', true);
// slpCharacterNoAccent.put('J', true);
// slpCharacterNoAccent.put('Y', true);
// slpCharacterNoAccent.put('w', true);
// slpCharacterNoAccent.put('W', true);
// slpCharacterNoAccent.put('q', true);
// slpCharacterNoAccent.put('Q', true);
// slpCharacterNoAccent.put('R', true);
// slpCharacterNoAccent.put('t', true);
// slpCharacterNoAccent.put('T', true);
// slpCharacterNoAccent.put('d', true);
// slpCharacterNoAccent.put('D', true);
// slpCharacterNoAccent.put('|', true);
// slpCharacterNoAccent.put('n', true);
// slpCharacterNoAccent.put('p', true);
// slpCharacterNoAccent.put('P', true);
// slpCharacterNoAccent.put('b', true);
// slpCharacterNoAccent.put('B', true);
// slpCharacterNoAccent.put('m', true);
// slpCharacterNoAccent.put('y', true);
// slpCharacterNoAccent.put('r', true);
// slpCharacterNoAccent.put('l', true);
// slpCharacterNoAccent.put('v', true);
// slpCharacterNoAccent.put('S', true);
// slpCharacterNoAccent.put('z', true);
// slpCharacterNoAccent.put('s', true);
// slpCharacterNoAccent.put('h', true);
// slpCharacterNoAccent.put('\'', true);
//
//
// slpVowel.put('a', true);
// slpVowel.put('A', true);
// slpVowel.put('i', true);
// slpVowel.put('I', true);
// slpVowel.put('u', true);
// slpVowel.put('U', true);
// slpVowel.put('f', true);
// slpVowel.put('F', true);
// slpVowel.put('x', true);
// slpVowel.put('X', true);
// slpVowel.put('e', true);
// slpVowel.put('E', true);
// slpVowel.put('o', true);
// slpVowel.put('O', true);
// slpVowel.put('M', true);
// slpVowel.put('~', true);
// slpVowel.put('H', true);
//
// }
//
// public static String getVersion() {
// return "2";
// }
//
// public static String createTexInput(String filename, ResourceInputStream ris, Hashtable fsmh) throws Exception {
// String text = IOAssistance.readEntireFile(filename);
// StringBuilder sb = new StringBuilder();
// StringBuilder source = new StringBuilder();
// TransformMap tmdeva = new TransformMap("*:slp1->skttex", ris, fsmh);
// TransformMap tmroman = new TransformMap("*:slp1->texRoman", ris, fsmh);
//
// int len = text.length();
// int lineno = 1;
// int charno = 1;
// for (int i = 0; i < len; i++) {
// char ch = text.charAt(i);
// if (ch == '<') {
// TransformMap tm = null;
// String tag = text.substring(i, i + 6);
// int taglen = tag.length();
// boolean isdeva = false;
// String endtag = "";
// if (tag.equals("")) {
// tm = tmroman;
// endtag = " ";
// } else if (tag.equals("")) {
// tm = tmdeva;
// isdeva = true;
// endtag = " ";
// } else if (tag.substring(0, 5).equals("")) {
// tm = tmroman;
// taglen = 5;
// endtag = " ";
// }
//
// if (tm == null) {
// sb.append(ch);
// } else {
// i = getSource(text, endtag, i + taglen, source, lineno, charno);
// String src = source.toString();
// if (isdeva) {
// src = String.format("{\\skt %s}", src);
// }
// String result = WebServices.transformString(src, tm);
// sb.append(result);
// }
// } else {
// sb.append(ch);
// }
//
// if (ch == '\n') {
// lineno++;
// charno = 0;
// }
// charno++;
// }
//
// return sb.toString();
// }
//
// public static int getSource(String text, String endtag, int i, StringBuilder source, int lineno, int charno) throws Exception {
// source.setLength(0);
// int len = text.length();
// int taglen = endtag.length();
// for (; i < len; i++) {
// char ch = text.charAt(i);
// if (ch == '<' && text.substring(i, i + taglen).equals(endtag)) {
// i += taglen - 1; // point to > of end tag
// break;
// } else {
// source.append(ch);
// }
// }
//
// if (i == len) // end tag not found
// {
// throw new Exception(String.format("Tag %s at line %d, char %d has no matching end tag",
// endtag, lineno, charno));
// }
// return i;
// }
//
// // REB: This assumes that delimiters are [ and ]
// public static ArrayList partition(String word, boolean isSLP1, StringBuilder sb, Hashtable h) {
// ArrayList a = new ArrayList();
//
// if (!isSLP1) {
// a.add(new SLP1Partition(word, false));
// } else {
// sb.setLength(0);
// int len = word.length();
// for (int i = 0; i < len; i++) {
// char ch = word.charAt(i);
// if (ch == '[') {
// if (sb.length() > 0) {
// a.add(new SLP1Partition(sb.toString(), true));
// sb.setLength(0);
// }
// i = getPassThrough(word, i, sb, ']');
// a.add(new SLP1Partition(String.format("[%s]", sb.toString()), false));
// sb.setLength(0);
// i--; // let this loop increment past the ].
// } else if (h.get(ch) != null) {
// sb.append(ch);
// } else {
// if (sb.length() > 0) {
// a.add(new SLP1Partition(sb.toString(), true));
// sb.setLength(0);
// }
// a.add(new SLP1Partition(word.substring(i, i + 1), false));
// }
// }
// if (sb.length() > 0) {
// a.add(new SLP1Partition(sb.toString(), true));
// }
// }
//
// return a;
// }
//
// private FSM(String sourceEncoding) {
// this.sourceEncoding = sourceEncoding;
// }
//
// private FSM(String sourceEncoding, Hashtable params) {
// this.sourceEncoding = sourceEncoding;
// this.params = params;
// if (params != null) {
// tradition = params.get("trad");
// traditionStyle = params.get("tradstyle");
// if (tradition != null && traditionStyle == null) {
// traditionStyle = "1";
// }
// }
// }
//
// public int getNumEntries() {
// return fsmEntry.length;
// }
//
// public FSMEntry getEntry(int n) {
// return fsmEntry[n];
// }
//
// private void resolveMatchItems() throws Exception {
// for (FSMEntry fs : fsmEntry) {
// if (fs.context != null) {
// for (MatchItem mi : fs.context) {
// mi.resolveclassCollection(symtab);
// }
// }
//
// if (fs.extension != null) {
// for (MatchItem mi : fs.extension) {
// mi.resolveclassCollection(symtab);
// }
// }
// }
//
// }
//
// public void computeDependantCharacters() throws Exception {
// String error = "dependency cannot be determined by looking at first character.";
// for (FSMEntry fse : fsmEntry) {
// if (fse.dependant) {
// if (fse.edge != null) {
// char ch = fse.edge.charAt(0);
// if (dependancyConflict(ch)) {
// throw new Exception(error);
// }
// dependantCharacters.put(ch, true);
// } else {
// for (String s : fse.edges) {
// char ch = s.charAt(0);
// if (dependancyConflict(ch)) {
// throw new Exception(error);
// }
// dependantCharacters.put(ch, true);
// }
// }
// }
// }
// }
//
// private boolean dependancyConflict(char ch) {
// for (FSMEntry test : fsmEntry) {
// if (!test.dependant) // check if it begins with character of the dependant element
// {
// if (test.edge != null) {
// if (test.edge.charAt(0) == ch) {
// return true;
// }
// } else {
// for (String ss : test.edges) {
// if (ss.charAt(0) == ch) {
// return true;
// }
// }
// }
// }
// }
//
// return false;
// }
//
// public boolean validate() throws Exception {
// return true;
// }
//
// public void setClearState(boolean b) {
// clearState = b;
// }
//
// public boolean isDependantCharacter(char ch) {
// return dependantCharacters.get(ch) != null;
// }
//
// public String processLine(Cacher cacher, TransformMap tm, String line, StringBuilder accumulateBuffer) throws Exception {
// boolean is8Bit = inputType.equals("8bit");
// MatchResult holdResult = null;
// if (!capitalsSupported) {
// line = removeCapitalizationBraces(line);
// }
//
// if (bufferManager != null) {
// bufferManager.setCacher(cacher);
// }
//
// char startDelim = tm.getLeftFlag();
// char endDelim = tm.getRightFlag();
// int n = 0;
// while (n < line.length()) {
// boolean processed = false;
//
// if (!is8Bit && line.charAt(n) == startDelim) { // deal with a flagged character
// StringBuilder passthrough = new StringBuilder();
// n = getPassThrough(line, n, passthrough, endDelim);
// OptionsFlagged option = tm.getUnknownOption();
// if (option != OptionsFlagged.IGNORE) {
// if (option == OptionsFlagged.ASIS_DELIMS) { // send through with delimiters
// state.updateResult(String.format("%c%s%c",
// startDelim, passthrough.toString(), endDelim), true);
// } else if (option == OptionsFlagged.ASIS_NO_DELIMS) {
// state.updateResult(passthrough.toString(), true);
// }
// }
// processed = true;
// } else {
// if (!is8Bit && line.charAt(n) == '\u0004') // marker used for converting offsets in one encoding to another
// {
// state.setOffsetMark(); // send it through as is.
// n++;
// continue;
// }
//
// MatchResult mr = getMatchResult(line, n);
// if (mr != null) {
// if (testBlanks && " ".equals(mr.bestFE.edge)) // see if dependant character follows blank
// {
// int nextn = n + mr.best.length();
// if (nextn < line.length()) {
// if (RTF2.debug == 1223) {
// RTF2.debug = 1223;
// }
// MatchResult mr2 = getMatchResult(line, nextn);
// if (mr2 == null || mr2.bestFE == null) {
// System.out.println(RTF2.debug);
// }
// if (mr2.bestFE.dependant) {
// updateBuffer(mr2.best, mr2.bestFE, state); // calls state.updateBuffer(mr2.bestFE), process dependant character first, then the space will be processed
// n += mr2.best.length();
// }
// }
// }
//
// if (mr.bestFE.swap) // e.g diagonal r appears before letter
// {
// holdResult = mr;
// } else {
// if (!mr.bestFE.ignore) {
// updateBuffer(mr.best, mr.bestFE, state); // calls state.updateBuffer(m4.bestFE)
// }
// if (holdResult != null) {
// updateBuffer(holdResult.best, holdResult.bestFE, state); // calls state.updateBuffer(holdResult.bestFE);
// holdResult = null;
// }
// }
// n += mr.best.length();
// processed = true;
// }
// }
//
// if (!processed) // determine what to do with unknown character
// {
// int cnt = 0;
// char ch = line.charAt(n);
// if (missing.get(ch) != null) {
// cnt = missing.get(ch);
// }
// cnt++;
// missing.put(ch, cnt);
// String target = tm.getMapping(ch);
// if (target != null) {
// state.updateResult(target, true);
// } else {
// OptionsUnknown option = tm.getOptionUnknown();
// if (option != OptionsUnknown.IGNORE) {
// if (option == OptionsUnknown.FLAG) {
// state.updateResult(String.format("%c%s%c",
// startDelim, line.substring(n, n + 1), endDelim), true);
// } else if (option == OptionsUnknown.ASIS) {
// state.updateResult(String.format("%s", line.substring(n, n + 1)), true);
// }
// }
// }
// n++;
// }
// }
//
// String result = null;
// if (clearState) // if clearState is false, then rest of syllable will come later
// {
// state.updateResult(true);
// if (FSM.dumpBuffers) {
// System.out.println(state.getBufferManager().toString());
// }
// result = state.getResult().toString();
// } else // keep intermediate syllable in state for next time.
// {
// result = state.getResult().toString();
// clearState = true; // clearState is only for x->slp1, slp1->will always do a clearState because it does not see the stuff that x->slp1 kept in the buffer.
// }
//
// state.getResult().setLength(0);
// if (accumulateBuffer != null) {
// accumulateBuffer.append(result);
// }
//
// return result;
// }
//
// private static int getPassThrough(String line, int n, StringBuilder passthrough, char endDelim) {
// n++; // move past [
// char lastch = '\0';
// if (n < line.length()) {
// do {
// char ch = line.charAt(n);
// if (ch != '\\') {
// passthrough.append(ch);
// } else if (lastch == '\\') {
// if (ch == '\\') {
// passthrough.append(ch);
// } else {
// // what to do with \t, \n, etc if they are encountered?
// }
// }
// lastch = ch;
// n++;
// } while (n < line.length() && (lastch == '\\' || line.charAt(n) != endDelim));
// }
//
// if (n == line.length()) {
// passthrough.insert(0, "[");
// //throw new Exception("end ] not found");
// } else {
// n++; // move past the ]
// }
// return n;
// }
//
// private MatchResult getMatchResult(String line, int n) {
// ArrayList list = null;
// if (charOptions.containsKey(line.charAt(n))) {
// FSMEntry bestFE = null;
// String best = "";
// list = charOptions.get(line.charAt(n));
// matchCount++;
// for (FSMEntry fe : list) {
// String match = test(line, n, fe);
// if (match.length() > best.length()) {
// best = match;
// if (fe.mappedTo != null) {
// bestFE = fe.mappedTo;
// } else {
// bestFE = fe;
// }
// }
// }
//
// if (bestFE != null) {
// return new MatchResult(best, bestFE);
// } else {
// return null;
// }
// }
//
// return null;
// }
//
// private String removeCapitalizationBraces(String line) {
// StringBuilder sb = new StringBuilder();
// int len = line.length();
// for (int i = 0; i < len; i++) {
// char ch = line.charAt(i);
// if (ch == '{') {
// if (i + 2 < len && line.charAt(i + 2) == '}') {
// sb.append(line.charAt(i + 1));
// i += 2;
// } else {
// sb.append(ch);
// }
// } else {
// sb.append(ch);
// }
// }
//
// return sb.toString();
// }
//
// private void updateBuffer(String match, FSMEntry fe, StateInfo state) throws Exception {
// if (debug) {
// matchCount++;
// System.out.format("%d. %s %s -->%s [%s]\n",
// matchCount,
// TextFormatter.charToSlashU(match),
// fe.klass == null ? "multiple classes" : fe.klass,
// fe.target,
// state.getBufferManager().toString());
// System.out.flush();
// }
//
// state.updateBuffer(fe);
// if (FSM.dumpBuffers) {
// System.out.println(state.getBufferManager().toString());
// }
// }
//
// public Hashtable getMissing() {
// return missing;
// }
//
// public static String toUnicodeString(String s) {
// StringBuilder sb = new StringBuilder();
// for (int i = 0; i < s.length(); i++) {
// char ch = s.charAt(i);
// if (ch < '\u0080') {
// sb.append(ch);
// } else {
// String uc = String.format("%x", (int) ch);
// switch (uc.length()) // there has got to be a better way to do this!
// {
// case 1:
// sb.append(String.format("\\u000%s", uc));
// break;
// case 2:
// sb.append(String.format("\\u00%s", uc));
// break;
// case 3:
// sb.append(String.format("\\u0%s", uc));
// break;
// case 4:
// sb.append(String.format("\\u%s", uc));
// break;
// }
// }
// }
//
// return sb.toString();
// }
//
// private static String fixup(String s) {
// StringBuilder sb = new StringBuilder();
// int i = 0;
// while (i < s.length()) {
// Pattern p = Pattern.compile("^[\\\\]u([0-9a-fA-F]{4})");
// Matcher m = p.matcher(s.substring(i));
// if (m.find()) {
// String hex = m.group(1);
// sb.append((char) Integer.parseInt(hex, 16));
// i += 6;
// } else {
// sb.append(s.charAt(i));
// i++;
// }
// }
//
// return sb.toString();
// }
//
// private String test(String line, int n, FSMEntry fe) {
// if (fe.edge != null) {
// return _test(line, n, fe);
// } else // test each edge in edges and return the longest match
// {
// String longestMatch = "";
// for (String edge : fe.edges) {
// fe.edge = edge;
// String match = _test(line, n, fe);
// if (match.length() > longestMatch.length()) {
// longestMatch = match;
// }
// }
// fe.edge = null;
// return longestMatch;
// }
// }
//
// private String _test(String line, int n, FSMEntry fe) {
// int idx = 0;
// String match = "";
// boolean b = true;
// int lenfe = fe.edge.length();
// int lensb = line.length();
// int j = n;
// int k = 0;
// while (j < lensb && k < lenfe && b) {
// b = line.charAt(j++) == fe.edge.charAt(k++);
// }
//
// if (k == lenfe && b) {
// try {
// boolean found = true;
// match = fe.edge;
// idx = n + match.length();
//
// if (fe.extension != null && fe.extension.length > 0) // continue the match
// {
// found = false;
// for (MatchItem mi : fe.extension) {
// if (mi.leftToRight) {
// int previdx = idx;
// idx = searchEdgeCollectionRight(mi, line, idx);
// if (previdx != idx || mi.option.equals("*")) {
// found = true;
// } else {
// found = false;
// break; // failure
// }
// } else {
// throw new Exception("before not implemented for ");
// }
// }
// }
//
// if (found && fe.context != null && fe.context.length > 0) // if this exists then fe.regex is probably null but it does no harm to check both
// {
// found = false;
// int nextidx = idx; // used by left to right
// int currentidx = idx - match.length(); // used by right to left
//
// for (MatchItem ci : fe.context) {
// if (ci.leftToRight) // look to the right
// {
// int previdx = nextidx;
// nextidx = searchEdgeCollectionRight(ci, line, nextidx);
// found = checkStatus(ci, previdx, nextidx, nextidx == line.length());
// } else // look to the left
// {
// int beforeidx = searchEdgeCollectionLeft(ci, line, currentidx);
// found = checkStatus(ci, currentidx, beforeidx, beforeidx == 0);
// if (found && ci.exists) // prepare for a another possible peek to the left
// {
// currentidx = beforeidx - 1;
// }
// }
//
// if (!found) {
// break;
// }
// }
// }
//
// if (!found) {
// match = "";
// } else {
// match = line.substring(n, idx);
// }
// } catch (Throwable ex) {
// System.out.println(ex);
// }
// }
// return match;
// }
//
// boolean checkStatus(MatchItem ci, int previdx, int idx, boolean atend) {
// boolean rc = false;
//
// if (ci.eolOverride && atend && previdx == idx) // if eol is OK and nothing was matched because we are at the end (or beginning) of the line this overrides everything else.
// {
// rc = true;
// } else if (idx != previdx) // something was matched
// {
// rc = ci.exists;
// } else // no match found
// {
// if (!ci.exists) // if it is not supposed to exist then mark it found
// {
// rc = true;
// } else if (ci.option.equals("*")) // if it is okay for it not to exist, then mark it found
// {
// rc = true; // don't break, there may be another
// } else // something must exist, so fail
// {
// rc = false;
// }
// }
//
// return rc;
// }
//
// // move through line+idx until a character not in mi's edgeCollection is encountered.
// private int searchEdgeCollectionRight(MatchItem mi, String line, int idx) {
// String card = mi.option;
// String prefix = null;
// do {
// prefix = mi.matchRight(line, idx);
// if (prefix != null) {
// idx += prefix.length();
// }
// if (card.equals("1")) {
// break;
// }
// } while (prefix != null);
//
// return idx;
// }
//
// private int searchEdgeCollectionLeft(MatchItem mi, String line, int idx) {
// String card = mi.option;
// String prefix = null;
// do {
// prefix = mi.matchLeft(line, idx);
// if (prefix != null) {
// idx -= prefix.length();
// }
// if (card.equals("1")) {
// break;
// }
// } while (prefix != null);
//
// return idx;
// }
//
// public static String transform(Cacher cacher, TransformMap tm, String inputFile, StringBuilder accumulateBuffer, boolean isFileName, String outputFile, String eol, FSM... fsm)
// throws Exception {
// String[] lines = null;
// processLineNum = 0;
// BufferedReader reader = null;
// if (isFileName) {
// BufferedInputStream bis = null;
// InputStreamReader isr = null;
// FileInputStream fis = new FileInputStream(inputFile);
// bis = new BufferedInputStream(fis);
// if (fsm[0].inputType.equals("8bit")) {
// isr = new InputStreamReader(bis, new RawDecoder(Charset.forName("UTF-8"), 1F, 1F));
// } else {
// isr = new InputStreamReader(bis, Charset.forName("UTF-8"));
// }
// reader = new BufferedReader(isr);
// } else {
// lines = new String[]{inputFile}; // inputFile.split("\n");
// }
//
//
//
// BufferedOutputStream bos = null;
// OutputStreamWriter osw = null;
// ByteArrayOutputStream baos = null;
// if (outputFile != null) {
// FileOutputStream fos = new FileOutputStream(outputFile);
// bos = new BufferedOutputStream(fos);
// } else {
// baos = new ByteArrayOutputStream();
// bos = new BufferedOutputStream(baos);
// }
//
// int lastfsm = fsm.length - 1;
// while (fsm[lastfsm] == null) {
// lastfsm--;
// }
//
// if (fsm[lastfsm].outputType.equals("8bit")) // hope this is rare
// {
// osw = new OutputStreamWriter(bos, new RawEncoder(Charset.forName("UTF-8"), 1F, 1F));
// } else {
// osw = new OutputStreamWriter(bos, Charset.forName("UTF-8"));
// }
//
// BufferedWriter writer = new BufferedWriter(osw);
// String line = null;
// int j = 0;
// while (true) {
// if (isFileName) {
// line = reader.readLine();
// if (line == null) {
// break;
// }
// } else {
// if (j >= lines.length) {
// break;
// } else {
// line = lines[j++];
// }
// }
//
// int len = fsm.length;
// if (len > 0 && accumulateBuffer != null) {
// len = 1;
// }
//
// for (int i = 0; i < len; i++) {
// if (fsm[i] != null) {
// line = fsm[i].processLine(cacher, tm, line, accumulateBuffer);
// }
// }
// writer.write(line);
// writer.write(eol);
// }
//
// if (reader != null) {
// reader.close();
// }
// String result = null;
// writer.flush();
//
// if (baos != null) {
// result = baos.toString("UTF-8");
// }
//
// writer.close();
// return result;
// }
//
// public static String transform(TransformMap tm, String inputFile, boolean isFileName, String outputFile, String eol, FSM... fsm)
// throws Exception {
// return transform(null, tm, inputFile, null, isFileName, outputFile, eol, fsm);
// }
//
// static public byte[] toBytes(String s) {
// byte[] b = new byte[s.length()];
// for (int i = 0; i < b.length; i++) {
// b[i] = (byte) s.charAt(i);
// }
// return b;
// }
//
// static public String toUTF8(String s) {
// try {
// byte[] b = toBytes(s);
// return new String(b, "utf-8");
// } catch (Exception ex) {
// // since utf-8 is hard-coded, it is very likely we will ever reach here
// return s;
// }
// }
//
// static public String transformString(Cacher cacher, TransformMap tm, String s, StringBuilder accumulateBuffer, FSM... fsm) throws Exception {
// String result = null;
// try {
// if (fsm[0] != null) {
// result = FSM.transform(cacher, tm, s, accumulateBuffer, false, null, "", fsm);
// } else {
// result = s;
// }
// } catch (Exception ex) {
// throw ex;
// }
//
// return result;
// }
//
// static public String[] createFileNames(String prefix, String source, String target) {
// String fileName[] = null;
// if (!prefix.endsWith("/")) {
// prefix += "/";
// }
// if (source.equals("slp1")) {
// fileName = new String[1];
// fileName[0] = String.format("%sslp1_%s.xml", prefix, target);
// } else if (target.equals("slp1")) {
// fileName = new String[1];
// fileName[0] = String.format("%s%s_slp1.xml", prefix, source);
// } else {
// fileName = new String[2];
// fileName[0] = String.format("%s%s_slp1.xml", prefix, source);
// fileName[1] = String.format("%sslp1_%s.xml", prefix, target);
// }
//
// return fileName;
// }
//
// static public RawDecoder getSourceDecoder(String originalEncoding, String targetEncoding, Hashtable fsmh) {
// RawDecoder result = null;
// String key = String.format("%s/%s", originalEncoding, targetEncoding);
// FSM[] fsm = fsmh.get(key);
// if (fsm != null) {
// String inputDecoding = fsm[0].inputType;
// if (inputDecoding != null && inputDecoding.equals("8bit")) {
// result = new RawDecoder();
// }
// }
// return result;
// }
//
// static public RawEncoder getTargetEncoder(String originalEncoding, String targetEncoding, Hashtable fsmh) {
// RawEncoder result = null;
// if (!originalEncoding.equals(targetEncoding)) {
// String key = String.format("%s/%s", originalEncoding, targetEncoding);
// FSM[] fsm = fsmh.get(key);
// if (fsm != null) {
// int idx = 1;
// if (fsm[idx] == null) {
// idx = 0;
// }
// String outputType = fsm[idx].outputType;
// if (outputType != null && outputType.equals("8bit")) {
// result = new RawEncoder();
// }
// }
// } else {
// // ?? how to find encoding. There is no x_x.xml file to read in.
// }
//
// return result;
// }
//
// public String[] getEdges() {
// String[] edges = new String[fsmEntry.length];
//
// for (int i = 0; i < fsmEntry.length; i++) {
// edges[i] = fsmEntry[i].edge;
// }
// return edges;
// }
//
// public String getCharClass(char ch) {
// for (int i = 0; i < fsmEntry.length; i++) {
// FSMEntry fe = fsmEntry[i];
// String edge = fe.edge;
// if (edge.length() == 1 && edge.charAt(0) == ch) {
// return fsmEntry[i].klass;
// }
// }
//
// return "";
// }
//
// static public FSM fromXML(String fileName, String sourceEncoding) throws Exception {
// return fromXML_SAX(fileName, sourceEncoding, null);
// }
//
// static public FSM fromXML(String fileName, String sourceEncoding, Hashtable params) throws Exception {
// return fromXML_SAX(fileName, sourceEncoding, params);
// }
//
// static public FSM fromXML(InputStream xmlFile, String sourceEncoding) throws Exception {
// return fromXML_SAX(xmlFile, sourceEncoding, null);
// }
//
// static public FSM fromXML(InputStream xmlFile, String sourceEncoding, Hashtable params) throws Exception {
// return fromXML_SAX(xmlFile, sourceEncoding, params);
// }
//
// // The follow methods are for SAX
// static public FSM fromXML_SAX(String fileName, String sourceEncoding, Hashtable params) throws Exception {
// InputStream is = new FileInputStream(fileName);
// return fromXML_SAX(is, sourceEncoding, params);
// }
//
// static public FSM fromXML_SAX(InputStream xmlFile, String sourceEncoding, Hashtable params) throws Exception {
// FSM fsm = new FSM(sourceEncoding, params);
// fsm.doSax(xmlFile); // initialize from SAX
// if (fsm.addto != null) {
// InputStream parentXmlFile = new FileInputStream(String.format("%s/%s", transcodersDirectory, fsm.addto));
// FSM fsmParent = new FSM(sourceEncoding);
// fsmParent.doSax(parentXmlFile, fsm.fsmEntries);
// fsm = fsmParent;
// }
// return fsm;
// }
//
// private void doSax(InputStream xmlFile) {
// doSax(xmlFile, new ArrayList());
// }
//
// private void doSax(InputStream xmlFile, ArrayList childFSMEntry) {
// SAXParserFactory factory = SAXParserFactory.newInstance();
// try {
// fsmEntries = childFSMEntry;
// // Parse the input
// SAXParser saxParser = factory.newSAXParser();
// saxParser.parse(xmlFile, this);
// } catch (Throwable t) // probably XML is not well-formed
// {
// StringBuilder sb = new StringBuilder();
// int count = 0;
// for (FSMEntry fe : childFSMEntry) {
// if (fe.edge != null && fe.target != null) {
// sb.append(String.format("%s->%s\n", fe.edge, fe.target));
// } else {
// sb.append("Unknown edge or target");
// }
// count++;
// if (count == 10) {
// break;
// }
// }
//
// System.out.println(sb.toString());
//
// try {
// xmlFile.close();
// } catch (Exception ex) {
// } // close the file since SAX won't do it.
// t.printStackTrace();
// }
// }
//
// @Override
// public void setDocumentLocator(Locator locator) {
// this.locator = locator;
// }
//
// @Override
// public void startDocument() throws SAXException {
// elements = new ArrayList();
// mib = new ArrayList();
// }
//
// @Override
// public void endDocument() throws SAXException {
// //System.out.println(bufferManager.toString());
// }
//
// @Override
// public void startElement(String uri, String localName, String qName, Attributes atts) throws SAXException {
// elements.add(qName);
//
// if (qName.equals("fsm")) {
// process_fsm(atts);
// } else if (qName.equals("e")) {
// process_e(atts);
// } else if (qName.equals("ext")) {
// checkPath("fsm", "edges", "e");
// MatchItem mi = new MatchItem(atts);
// if (mi.eolOverride || !mi.exists) {
// throw new SAXException("Attribute x is used in ext element");
// }
//
// mib.add(mi);
// } else if (qName.equals("ctx")) {
// checkPath("fsm", "edges", "e");
// mib.add(new MatchItem(atts));
// } else if (qName.equals("ligatures")) // would have been better if parent of e elements was not fsm
// {
// checkPath("fsm");
// if (!foundEntries || foundMerges || foundBuffers) {
// msg("ligatures element must come immediately after e entries");
// }
// foundLigatures = true;
// } else if (qName.equals("ligature")) {
// checkPath("fsm", "ligatures");
// String ligtype = atts.getValue("type");
// if (ligtype == null) {
// msg("Ligature element missing type attribute");
// }
//
// // find the ligature in fsmEntry
// for (FSMEntry fse : fsmEntry) {
// if (ligtype.equals(fse.ligature)) {
// ligfse = fse;
// break;
// }
// }
//
// if (ligfse == null) {
// msg(String.format("Ligature %s not found", ligtype));
// }
//
// } else if (qName.equals("char")) {
// checkPath("fsm", "ligatures", "ligature");
// String key = atts.getValue("key");
// if (key == null) {
// msg("char element missing key attribute");
// }
//
// FSMEntry value = edgeKeys.get(key);
// if (value == null) {
// msg(String.format("Ligature key: %s not found", key));
// } else {
// ligfse.addLigatureComponent(value);
// }
// } else if (qName.equals("merges")) {
// checkPath("fsm");
// if (!foundEntries || foundBuffers) {
// msg("merges element must come after entries but before buffers");
// }
// foundMerges = true;
// mergeb = new ArrayList();
// } else if (qName.equals("merge")) {
// checkPath("fsm", "merges");
// mergeb.add(new Merge(atts)); // now need to get action children
// } else if (qName.equals("action")) {
// checkPath("fsm", "merges", "merge");
// mergeb.get(mergeb.size() - 1).setAction(new Action(atts));
// } else if (qName.equals("buffers")) {
// checkPath("fsm");
// if (!foundEntries) {
// msg("buffers element must come after entries");
// }
// foundBuffers = true;
// } else if (qName.equals("buffer")) {
// checkPath("fsm", "buffers");
// if (createNewBuffers) {
// buffersExist = true;
// try {
// workingBuffer = new Buffer(bufferManager, atts);
// } catch (Exception ex) {
// throw new SAXException(ex.getMessage());
// }
// }
// } else if (qName.equals("member")) {
// checkPath("fsm", "buffers", "buffer");
// if (createNewBuffers) // otherwise use wb.buffers
// {
// workingBuffer.addMember(new Member(workingBuffer, atts));
// }
// } else if (qName.equals("errorMessage")) {
// if (createNewBuffers) {
// workingBuffer.addErrorMessage(new ErrorMessage(atts));
// }
// } else if (qName.equals("out")) // because if out has no content, characters will never be called.
// {
// checkPath("fsm", "edges", "e");
// String trad = atts.getValue("trad");
//
// if (wfe.target == null) {
// wfe.target = "";
// }
// useAlternate = trad != null; // if there is a trad attribute, get value of out from an alt child
// if (useAlternate) {
// currentTradition = trad;
// }
// } else if (qName.equals("alt")) {
// checkPath("fsm", "edges", "e", "out");
// if (traditionStyle != null) {
// String n = atts.getValue("n");
// if (currentTradition.equals(tradition) && n != null && n.equals(traditionStyle)) {
// updateTarget = true;
// } else {
// updateTarget = false;
// }
// }
// } else if (qName.equals("dependant")) // must be done here since it has no content and hence characters won't be called.
// {
// wfe.dependant = true;
// } else if (qName.equals("zerowidth")) // must be done here since it has no content and hence characters won't be called.
// {
// wfe.zeroWidth = true;
// } else if (qName.equals("swap")) // must be done here since it has no content and hence characters won't be called.
// {
// wfe.swap = true;
// } else if (qName.equals("ignore")) // must be done here since it has no content and hence characters won't be called.
// {
// wfe.ignore = true;
// }
//
// // otherwise characters will assign content of currentElementName correctly
// }
//
// @Override
// public void endElement(String uri, String localName, String qName) throws SAXException {
// String element = elements.remove(elements.size() - 1);
// if (element.equals("e")) {
// if (wfe.id == null) {
// msg("The in element is mandatory");
// } else {
// wfe.convertEdge();
// }
//
// if (qName.equals("alt")) {
// updateTarget = false; // force it to be reset to true.
// } else if (qName.equals("out")) {
// useAlternate = false; // next out may not have styles
// currentTradition = null;
// }
// if (outputType.equals("slp1")) {
// if (wfe.target == null) {
// wfe.target = wfe.edge;
// } else if (wfe.target.length() == 0) {
// if (wfe.key == null) {
// throw new SAXException(String.format("id: %s If out is empty string, then key must be specified", wfe.id));
// }
// }
// }
// wfe.convertTarget();
//
// boolean found = false;
// int i = 0;
// for (FSMEntry fe : fsmEntries) {
// i++;
// if (fe.id.equals(wfe.id)) {
// found = true;
// break;
// }
// }
// if (!found) {
// fsmEntries.add(wfe);
// }
// // if found, then presumably it is a child from another XML document, so use that.
// } else if (element.equals("edges")) {
// prepareDataStructures();
// } else if (element.equals("merges")) {
// for (Merge m : mergeb) {
// try {
// bufferManager.addMerge(m);
// } catch (Exception ex) {
// throw new SAXException(ex.getMessage());
// }
// }
// mergeb.clear();
// } else if (element.equals("ext")) {
// wfe.extension = convertMatchItemBuffer(mib); // this also clears mib
// } else if (element.equals("ctx")) {
// wfe.context = convertMatchItemBuffer(mib); // this also clears mib
// } else if (element.equals("fsm")) {
// if (!createNewBuffers) {
// bufferManager.initialize(wb.bufferManager); // use merges and buffer elements of shared buffers
// } else if (wb != null && wb.bufferManager == null) {
// wb.bufferManager = bufferManager; // so that these buffers can be shared by other FSMs
// }
// if (buffersExist) {
// try {
// BufferManager b = wb != null ? wb.bufferManager : bufferManager;
// symtab.validateClassNames(b);
// } catch (Exception ex) {
// throw new SAXException(ex.getMessage());
// }
// }
// } else if (element.equals("buffer")) {
// try {
// if (createNewBuffers) {
// workingBuffer.parseAccumulatedExistsString();
// bufferManager.addBuffer(workingBuffer);
// }
// } catch (Exception ex) {
// throw new SAXException(ex.getMessage());
// }
// }
// }
//
// @Override
// // TODO: Do not assume that all text content of element is returned at the same time. Logic here needs to be handled in endElement
// public void characters(char[] ch, int start, int length) throws SAXException {
// if (elements.size() <= 1) {
// return;
// }
//
// String parent = elements.get(elements.size() - 2);
// String child = elements.get(elements.size() - 1);
// String content = new String(ch, start, length).trim();
//
// if (parent.equals("out") && child.equals("alt") && updateTarget) // have an alt that contains the out value
// {
// wfe.target = assign(wfe.target, content);
// } else if (parent.equals("e")) {
// if (child.equals("in")) {
// if (inputIsUnicodeInSecondPlane) {
// content = TextFormatter.rewriteWithSurrogates(content);
// }
// wfe.edge = assign(wfe.edge, content);
// } else if (child.equals("out")) {
// if (!useAlternate) {
// if (outputIsUnicodeInSecondPlane) {
// content = TextFormatter.rewriteWithSurrogates(content);
// }
// wfe.target = assign(wfe.target, content);
// }
// } else if (child.equals("map")) {
// wfe.map = assign(wfe.map, content);
// } else if (child.equals("lig")) {
// wfe.ligature = assign(wfe.ligature, content);
// } else if (child.equals("cl")) {
// wfe.klass = assign(wfe.klass, content);
// } else if (child.equals("key")) {
// wfe.key = assign(wfe.key, content); // used if out value is null
// } else if (child.equals("comment")) {
// wfe.comment = assign(wfe.comment, content);
// } else if (child.equals("ext") || child.equals("ctx")) {
// mib.get(mib.size() - 1)._classCollection = assign(mib.get(mib.size() - 1)._classCollection, content);
// } else if (child.equals("mac")) { // ignore
// } else {
// msg("Unknown child of element e");
// }
// } else if (createNewBuffers && parent.equals("buffer")) {
// if (child.equals("exists")) // need to accumulate before parsing!!
// {
// workingBuffer.accumulateContent(content); // formerly workingBuffer.parseExistsString(content)
// }
// }
// }
//
// private String assign(String target, String value) {
// if (target == null) {
// return value;
// } else {
// return target + value;
// }
// }
//
// private void process_fsm(Attributes atts) throws SAXException {
// checkPath();
// addto = atts.getValue("addto");
//
// inputType = atts.getValue("inputType");
// if (inputType == null) {
// inputType = "UTF-8";
// }
//
// outputType = atts.getValue("outputType");
// if (outputType == null) {
// outputType = "UTF-8";
// }
//
// inputIsUnicodeInSecondPlane = atts.getValue("inputIsUnicodeInSecondPlane") != null;
//
// outputIsUnicodeInSecondPlane = atts.getValue("outputIsUnicodeInSecondPlane") != null;
//
// String value = atts.getValue("capitalsSupported");
// if (value == null) {
// capitalsSupported = false;
// } else {
// capitalsSupported = value.toLowerCase().equals("y");
// }
//
// value = atts.getValue("testBlanks");
// if (value == null) {
// testBlanks = false;
// } else {
// testBlanks = value.toLowerCase().equals("y");
// }
//
// version = atts.getValue("version");
// if (version == null) {
// version = "2";
// }
//
// sharedStateName = atts.getValue("sharedState");
//
// }
//
// private void process_e(Attributes atts) throws SAXException {
// checkPath("fsm", "edges");
// foundEntries = true;
// wfe = new FSMEntry();
// String id = atts.getValue("n");
// if (id.equals("107")) {
// id = "107";
// }
// if (id == null) {
// throw new SAXException(String.format("%d.%d id cannot be null", locator.getLineNumber(), locator.getColumnNumber()));
// }
// wfe.id = id;
// }
//
// private void copyFSMEntries() throws SAXException {
// if (fsmEntry != null) {
// return;
// }
//
// fsmEntry = new FSMEntry[fsmEntries.size()];
// int i = 0;
// for (FSMEntry fe : fsmEntries) {
// fsmEntry[i++] = fe;
// }
//
// if (outputType.equals("slp1") && edgeKeys == null) {
// try {
// edgeKeys = FSMEntry.resolveKeys(fsmEntry);
// } catch (Exception ex) {
// throw new SAXException(ex.getMessage());
// }
// }
// }
//
// // This is called when is hit and before is encountered!
// private void prepareDataStructures() throws SAXException {
// try {
// if (fsmEntry == null) {
// copyFSMEntries();
// }
//
// charOptions = FSMEntry.getCharOptions(fsmEntry);
// symtab = new SymbolTable(fsmEntry);
// resolveMatchItems();
// computeDependantCharacters();
//
// wb = null;
// createNewBuffers = true;
// if (sharedStateName == null) {
// resultBuffer = new StringBuilder(); // each FSM gets a different buffer
// } else {
// wb = sharedState.get(sharedStateName); // buffer of this FSM will potentially be shared by other FSMs
// if (wb == null) {
// wb = new BufferInfo();
// sharedState.put(sharedStateName, wb);
// wb.resultBuffer = new StringBuilder();
// } else {
// createNewBuffers = false;
// }
//
// resultBuffer = wb.resultBuffer; // use the shared result buffer
// }
//
// state = new StateInfo(resultBuffer, outputType.equals("slp1"));
// bufferManager = new BufferManager(symtab, state); // Note: symtab and state will be available to each buffer
// state.setBufferManager(bufferManager);
// buffersExist = false;
// } catch (Exception ex) {
// throw new SAXException(ex.getMessage());
// }
//
// }
//
// private void checkPath(String... path) throws SAXException {
// boolean okay = false;
// if (elements.size() == path.length + 1) {
// okay = true;
// for (int i = 0; i < path.length && okay; i++) {
// okay = elements.get(i).equals(path[i]);
// }
// }
//
// if (!okay) {
// StringBuilder sb = new StringBuilder();
// sb.append("elements: ");
// for (String s : elements) {
// sb.append(String.format("%s ", s));
// }
//
// sb.append("||path: ");
// for (String s : path) {
// sb.append(String.format("%s ", s));
// }
//
// msg(sb.toString());
// }
// }
//
// public void msg(String text) throws SAXException {
// throw new SAXException(String.format("%d.%d %s", locator.getLineNumber(), locator.getColumnNumber(), text));
// }
//
// private MatchItem[] convertMatchItemBuffer(ArrayList a) {
// MatchItem[] mis = new MatchItem[a.size()];
// int i = 0;
// for (MatchItem mi : a) {
// mis[i] = mi;
// }
// a.clear();
// return mis;
// }
//}