get_production(short conflict_number,
DslToken tokens)
{
short entry = 0;
int index, level;
if (conflict_number <= TOTAL_CONFLICTS)
{
entry = (short)(conflict_number + (START_CONFLICT - 1));
level = 1;
while (entry >= START_CONFLICT)
{
index = Conflict_row [entry - (START_CONFLICT - 1)];
index += tokens.peek(level);
entry = Conflict [index];
++level;
}
}
return(entry);
}
public bool LoadFromString(string content, string resourceName, DslLogDelegation logCallback)
{
#if FULL_VERSION
mDslInfos.Clear();
Parser.DslLog log = new Parser.DslLog();
log.OnLog += logCallback;
Parser.DslToken tokens = new Parser.DslToken(log, content);
Parser.DslError error = new Parser.DslError(log, tokens);
Parser.RuntimeAction action = new Parser.RuntimeAction(mDslInfos);
action.onGetLastToken = () => { return tokens.getLastToken(); };
action.onGetLastLineNumber = () => { return tokens.getLastLineNumber(); };
action.onGetComment = (out bool commentOnNewLine) => { commentOnNewLine = tokens.IsCommentOnNewLine(); List<string> ret = new List<string>();ret.AddRange(tokens.GetComments()); tokens.ResetComments(); return ret; };
action.onSetStringDelimiter = (string begin, string end) => { tokens.setStringDelimiter(begin, end); };
action.onSetScriptDelimiter = (string begin, string end) => { tokens.setScriptDelimiter(begin, end); };
Parser.DslParser.parse(action, tokens, error, 0);
if (error.HasError) {
for (int i = 0; i < mDslInfos.Count; i++) {
mDslInfos[i].Clear();
}
} else {
for (int i = 0; i < mDslInfos.Count; i++) {
mDslInfos[i].SetResourceName(resourceName);
}
}
return !error.HasError;
#else
return false;
#endif
}
public string GenerateBinaryCode(string content, Dictionary<string, string> encodeTable, DslLogDelegation logCallback)
{
#if FULL_VERSION
List<DslInfo> infos = new List<DslInfo>();
Parser.DslLog log = new Parser.DslLog();
log.OnLog += logCallback;
Parser.DslToken tokens = new Parser.DslToken(log, content);
Parser.DslError error = new Parser.DslError(log, tokens);
Parser.RuntimeAction action = new Parser.RuntimeAction(infos);
action.onGetLastToken = () => { return tokens.getLastToken(); };
action.onGetLastLineNumber = () => { return tokens.getLastLineNumber(); };
action.onSetStringDelimiter = (string begin, string end) => { tokens.setStringDelimiter(begin, end); };
action.onSetScriptDelimiter = (string begin, string end) => { tokens.setScriptDelimiter(begin, end); };
Parser.DslParser.parse(action, tokens, error, 0);
if (error.HasError) {
return string.Empty;
} else {
MemoryStream stream = new MemoryStream();
List<string> identifiers = new List<string>();
foreach (DslInfo info in infos) {
Utility.writeBinary(stream, identifiers, (StatementData)info);
}
byte[] bytes = stream.ToArray();
SortedDictionary<string, int> dict = new SortedDictionary<string, int>();
int ct = identifiers.Count;
if (ct > 0x00004000) {
System.Diagnostics.Debug.Assert(false);
//Console.WriteLine("Identifiers count {0} too large than 0x04000", ct);
return string.Empty;
}
for (int i = 0; i < ct; ++i) {
string key = identifiers[i];
key = Encode(key, encodeTable);
identifiers[i] = key;
if (!dict.ContainsKey(key)) {
dict.Add(key, 0);
}
}
List<string> keys = new List<string>(dict.Keys);
byte[] bytes2;
using (MemoryStream ms = new MemoryStream()) {
for (int i = 0; i < ct; ++i) {
string key = identifiers[i];
int ix = keys.BinarySearch(key);
if (ix < 0x80) {
ms.WriteByte((byte)ix);
} else {
ms.WriteByte((byte)((ix & 0x0000007f) | 0x00000080));
ms.WriteByte((byte)(ix >> 7));
}
}
bytes2 = ms.ToArray();
}
return string.Format("{0}|{1}|{2}", Convert.ToBase64String(bytes), Convert.ToBase64String(bytes2), string.Join("`", keys.ToArray()));
}
#else
return string.Empty;
#endif
}
parse(ref DslAction action,
ref DslToken tokens,
ref DslError error,
short start_symbol)
{
short rhs, lhs;
short production_number, entry, symbol, token, new_token;
int production_length, top, index, level;
short *stack = stackalloc short[65535];
top = 65534;
stack[top] = 0;
if (start_symbol == 0)
{
start_symbol = START_SYMBOL;
}
if (top > 0)
{
stack[--top] = start_symbol;
}
else
{
error.message("DslParse: stack overflow\n", ref tokens); return;
}
token = tokens.get();
new_token = token;
for (symbol = (stack[top] != 0 ? stack[top++] : (short)0); symbol != 0;)
{
if (symbol >= START_ACTION)
{
action.execute(symbol - (START_ACTION - 1));
}
else if (symbol >= START_SYMBOL)
{
entry = 0;
level = 1;
production_number = get_conditional_production(symbol);
if (production_number != 0)
{
entry = get_predicted_entry(tokens,
production_number, token,
level, 1);
}
if (entry == 0)
{
index = Parse_row[symbol - (START_SYMBOL - 1)];
index += token;
entry = Parse[index];
}
while (entry >= START_CONFLICT)
{
index = Conflict_row[entry - (START_CONFLICT - 1)];
index += tokens.peek(level);
entry = Conflict[index];
++level;
}
if (entry != 0)
{
index = Production_row[entry];
production_length = Production[index] - 1;
lhs = Production[++index];
if (lhs == symbol)
{
action.predict(entry);
index += production_length;
for (; production_length-- > 0; --index)
{
if (top > 0)
{
stack[--top] = Production[index];
}
else
{
error.message("DslParse: stack overflow\n", ref tokens); return;
}
}
}
else
{
new_token = error.no_entry(symbol, token, level - 1, ref tokens);
}
}
else // no table entry
{
new_token = error.no_entry(symbol, token, level - 1, ref tokens);
}
}
else if (symbol > 0)
{
if (symbol == token)
{
token = tokens.get();
new_token = token;
}
else
{
new_token = error.mismatch(symbol, token, ref tokens);
}
}
else
{
error.message("\n parser error: symbol value 0\n", ref tokens);
}
if (token != new_token)
{
if (new_token != 0)
{
token = new_token;
}
if (token != END_OF_SLK_INPUT_)
{
continue;
}
}
symbol = (stack[top] != 0 ? stack[top++] : (short)0);
}
if (token != END_OF_SLK_INPUT_)
{
error.input_left(ref tokens);
}
}
internal void input_left(ref DslToken dslToken)
{
mHasError = true;
mLog.Log("[error] input left, last token {0} line {1}, cur token {2} line {3}", dslToken.getLastToken(), dslToken.getLastLineNumber(), dslToken.getCurToken(), dslToken.getLineNumber());
}
internal void message(string message, ref DslToken dslToken)
{
mHasError = true;
mLog.Log("[info] {0}, last token {1} line {2}, cur token {3} line {4}", message, dslToken.getLastToken(), dslToken.getLastLineNumber(), dslToken.getCurToken(), dslToken.getLineNumber());
}
internal short mismatch(short terminal, short token, ref DslToken dslToken)
{
mHasError = true;
mLog.Log("[error] expecting {0} but found {1}, last token {2} line {3}, cur token {4} line {5}", DslString.GetSymbolName(terminal), DslString.GetSymbolName(token), dslToken.getLastToken(), dslToken.getLastLineNumber(), dslToken.getCurToken(), dslToken.getLineNumber());
return(token);
}
internal DslError(DslLog log, DslToken tokens)
{
mLog = log;
mToken = tokens;
}
internal short no_entry(short nonterminal, short token, int level, ref DslToken dslToken)
{
mLog.Error("[error] syntax error: skipping input {0}, last token {1} line {2}, cur token {3} line {4}", DslString.GetSymbolName(token), dslToken.getLastToken(), dslToken.getLastLineNumber(), dslToken.getCurToken(), dslToken.getLineNumber());
token = dslToken.get(); // advance the input
return(token);
}
public bool LoadFromString(string content, string resourceName, DslLogDelegation logCallback)
{
#if FULL_VERSION
mDslInfos.Clear();
Parser.DslLog log = new Parser.DslLog();
log.OnLog += logCallback;
Parser.DslToken tokens = new Parser.DslToken(log, content);
Parser.DslError error = new Parser.DslError(log, tokens);
Parser.RuntimeAction action = new Parser.RuntimeAction(mDslInfos);
action.onGetLastToken = () => { return tokens.getLastToken(); };
action.onGetLastLineNumber = () => { return tokens.getLastLineNumber(); };
Parser.DslParser.parse(action,tokens,error,0);
if(error.HasError)
{
for (int i = 0; i < mDslInfos.Count; i++ )
{
mDslInfos[i].Clear();
}
}
else
{
for (int i = 0; i < mDslInfos.Count; i++)
{
mDslInfos[i].SetResourceName(resourceName);
}
}
return !error.HasError;
#else
return false;
#endif
}
internal DslError(DslLog log, DslToken tokens)
{
mLog = log;
mToken = tokens;
}
