public void UpdateFromToken(ExtractStatement exToken)
{
if (exToken == null)
{
throw new ArgumentNullException("exToken");
}
if (_name != exToken.Name)
{
throw new ArgumentException("Extract token does not have the same name as FFPermEx.");
}
var nameToken = exToken.FindFirstChild <ExtractTableToken>();
if (nameToken != null)
{
_def = nameToken.SourceDefinition as ExtractTableDefinition;
}
else
{
_def = new ExtractTableDefinition(_name, exToken.FilePosition, true);
}
_fields.Clear();
_fields.AddRange(exToken.Fields);
_filePos = exToken.FilePosition;
}
public FFPermEx(FFFile file, ExtractStatement exToken, ExtractTableDefinition exDef)
{
_file = file;
_name = exToken.Name;
_def = exDef;
_fields.AddRange(exToken.Fields);
_filePos = exToken.FilePosition;
}
public FFPermEx(FFFile file, SQLiteDataReader rdr)
{
_file = file;
_name = rdr.GetString(rdr.GetOrdinal("name"));
_id = rdr.GetInt32(rdr.GetOrdinal("rowid"));
var fileName = rdr.GetStringOrNull(rdr.GetOrdinal("alt_file_name"));
if (string.IsNullOrEmpty(fileName))
{
fileName = file.FileName;
}
var pos = rdr.GetInt32(rdr.GetOrdinal("pos"));
_filePos = new FilePosition(fileName, pos);
_def = new ExtractTableDefinition(_name, _filePos, true);
}
private void ReadExtract(Span extractWordSpan)
{
var errorSpan = extractWordSpan;
var permanent = _code.ReadExact("permanent");
if (permanent)
{
errorSpan = _code.Span;
}
// Table name
if (!_code.ReadWord())
{
return;
}
var name = _code.Text;
ExtractTableDefinition exDef = null;
if (!_defProv.GetGlobalFromFile <ExtractTableDefinition>(name).Any()) // Don't add a definition if it's already there (extracts can be called multiple times)
{
var localPos = _source.GetFilePosition(_code.TokenStartPostion);
exDef = new ExtractTableDefinition(name, localPos, permanent);
}
string lastToken = null;
var lastTokenPos = 0;
var fields = new List <string>();
if (exDef != null)
{
var rownoDef = new ExtractFieldDefinition("rowno", exDef.FilePosition, exDef);
rownoDef.SetDataType(DataType.Unsigned9);
exDef.AddField(rownoDef);
}
var done = false;
while (!_code.EndOfFile && !done)
{
if (!_code.PeekExact("==") && _code.ReadExact('=') && lastToken != null)
{
if (exDef != null)
{
var localPos = _source.GetFilePosition(lastTokenPos);
var fieldDef = new ExtractFieldDefinition(lastToken, localPos, exDef);
exDef.AddField(fieldDef);
}
if (fields == null)
{
fields = new List <string>();
}
fields.Add(lastToken);
lastToken = null;
}
else if (_code.ReadWord())
{
lastToken = _code.Text;
lastTokenPos = _code.TokenStartPostion;
}
else
{
_code.Read();
switch (_code.Text)
{
case ";":
done = true;
break;
case "{":
case "}":
done = true;
break;
case "(":
ReadNestable(")");
break;
case "[":
ReadNestable("]");
break;
}
}
}
if (exDef != null)
{
_defProv.AddGlobalFromFile(exDef);
}
}
private static bool TryParseColumn(Scope scope, GroupToken parent, bool allowRelInd, ExtractTableDefinition extractDef)
{
var code = scope.Code;
if (code.ReadWord())
{
var wordPos = code.TokenStartPostion;
var table = DkDict.Dict.GetTable(code.Text);
if (table != null)
{
var tableToken = new TableToken(scope, code.Span, code.Text, table.Definition);
if (code.ReadExact('.'))
{
var dotToken = new DotToken(scope, code.Span);
if (code.ReadWord())
{
var field = table.GetColumn(code.Text);
if (field != null)
{
var fieldName = code.Text;
var fieldSpan = code.Span;
var fieldToken = new TableFieldToken(scope, fieldSpan, fieldName, field);
parent.AddToken(new TableAndFieldToken(scope, tableToken, dotToken, fieldToken));
}
else
{
parent.AddToken(new CompositeToken(scope, null, tableToken, dotToken, new UnknownToken(scope, code.Span, code.Text)));
}
}
else
{
parent.AddToken(new CompositeToken(scope, null, tableToken, dotToken));
}
}
else
{
parent.AddToken(tableToken);
}
return(true);
}
if (allowRelInd)
{
var relind = DkDict.Dict.GetRelInd(code.Text);
if (relind != null)
{
parent.AddToken(new RelIndToken(scope, code.Span, code.Text, relind.Definition));
return(true);
}
}
if (extractDef != null && code.Text == extractDef.Name)
{
parent.AddToken(new IdentifierToken(scope, code.Span, code.Text, extractDef));
if (code.ReadExact('.'))
{
parent.AddToken(new DotToken(scope, code.Span));
var word = code.PeekWordR();
if (!string.IsNullOrEmpty(word))
{
var childDef = extractDef.GetChildDefinitions(word).FirstOrDefault();
if (childDef != null)
{
parent.AddToken(new IdentifierToken(scope, code.MovePeekedSpan(), word, childDef));
}
}
}
return(true);
}
// Word was not recognized, so set parser back to before the word so it can get picked up later.
code.Position = wordPos;
}
return(false);
}
public static SelectStatement Parse(Scope parentScope, KeywordToken selectToken)
{
var ret = new SelectStatement(parentScope, selectToken);
var scope = parentScope.Clone();
scope.BreakOwner = ret;
scope.ContinueOwner = ret;
var code = scope.Code;
if (code.ReadStringLiteral())
{
ret.AddToken(new StringLiteralToken(scope, code.Span, code.Text));
}
if (code.ReadExact('*'))
{
ret.AddToken(new OperatorToken(scope, code.Span, "*"));
}
if (!code.ReadExactWholeWord("from"))
{
return(ret);
}
ret.AddToken(new KeywordToken(scope, code.Span, "from"));
ExtractTableDefinition extractDef = null;
DkDict.Table table = null;
if (code.ReadWord())
{
if ((table = DkDict.Dict.GetTable(code.Text)) != null)
{
ret.AddToken(new TableToken(scope, code.Span, code.Text, table.Definition));
}
else if ((extractDef = scope.DefinitionProvider.GetAny <ExtractTableDefinition>(code.TokenStartPostion, code.Text).FirstOrDefault()) != null)
{
ret.AddToken(new IdentifierToken(scope, code.Span, code.Text, extractDef));
}
else
{
ret.AddToken(new UnknownToken(scope, code.Span, code.Text));
}
}
if (code.ReadExactWholeWord("of"))
{
ret.AddToken(new KeywordToken(scope, code.Span, "of"));
if (code.ReadWord())
{
if ((table = DkDict.Dict.GetTable(code.Text)) != null)
{
ret.AddToken(new TableToken(scope, code.Span, code.Text, table.Definition));
}
else
{
ret.AddToken(new UnknownToken(scope, code.Span, code.Text));
}
}
}
else if (code.ReadExact(','))
{
ret.AddToken(new DelimiterToken(scope, code.Span));
var expectingComma = false;
while (!code.EndOfFile)
{
if (code.PeekExact('{'))
{
break;
}
if (expectingComma)
{
if (code.ReadExact(','))
{
ret.AddToken(new DelimiterToken(scope, code.Span));
expectingComma = false;
}
else
{
break;
}
}
else if (code.ReadWord())
{
if ((table = DkDict.Dict.GetTable(code.Text)) != null)
{
ret.AddToken(new TableToken(scope, code.Span, code.Text, table.Definition));
}
else
{
ret.AddToken(new UnknownToken(scope, code.Span, code.Text));
}
expectingComma = true;
}
else
{
break;
}
}
}
// WHERE and ORDER BY
var gotWhere = false;
var gotOrderBy = false;
while (!code.EndOfFile)
{
if (code.PeekExact('{'))
{
break;
}
if (!gotWhere && code.ReadExactWholeWord("where"))
{
ret.AddToken(new KeywordToken(scope, code.Span, code.Text));
gotWhere = true;
var exp = ExpressionToken.TryParse(scope, _whereEndTokens);
if (exp != null)
{
ret.AddToken(exp);
}
else
{
break;
}
}
else if (!gotOrderBy && code.ReadExactWholeWord("order"))
{
ret.AddToken(new KeywordToken(scope, code.Span, code.Text));
gotOrderBy = true;
if (!code.ReadExactWholeWord("by"))
{
break;
}
ret.AddToken(new KeywordToken(scope, code.Span, code.Text));
while (!code.EndOfFile)
{
if (code.PeekExact('{'))
{
break;
}
if (code.ReadExact(','))
{
ret.AddToken(new DelimiterToken(scope, code.Span));
continue;
}
if (code.ReadExactWholeWord("asc") || code.ReadExactWholeWord("desc"))
{
ret.AddToken(new KeywordToken(scope, code.Span, code.Text));
continue;
}
if (TryParseColumn(scope, ret, true, extractDef))
{
continue;
}
break;
}
}
else
{
break;
}
}
// Body
if (code.ReadExact('{'))
{
var braces = new BracesToken(scope);
braces.AddOpen(code.Span);
ret.AddToken(braces);
while (!code.EndOfFile)
{
if (code.ReadExact('}'))
{
braces.AddClose(code.Span);
break;
}
if (code.ReadExactWholeWord("for"))
{
braces.AddToken(new KeywordToken(scope, code.Span, "for"));
if (!code.ReadExactWholeWord("each"))
{
continue;
}
braces.AddToken(new KeywordToken(scope, code.Span, "each"));
if (!code.ReadExact(':'))
{
continue;
}
braces.AddToken(new OperatorToken(scope, code.Span, ":"));
}
else if (code.ReadExactWholeWord("before") || code.ReadExactWholeWord("after"))
{
braces.AddToken(new KeywordToken(scope, code.Span, code.Text));
if (!code.ReadExactWholeWord("group"))
{
continue;
}
braces.AddToken(new KeywordToken(scope, code.Span, "group"));
if (code.ReadExactWholeWord("all"))
{
braces.AddToken(new KeywordToken(scope, code.Span, "all"));
if (!code.ReadExact(':'))
{
continue;
}
braces.AddToken(new OperatorToken(scope, code.Span, ":"));
}
else if (TryParseColumn(scope, braces, false, extractDef))
{
if (!code.ReadExact(':'))
{
continue;
}
braces.AddToken(new OperatorToken(scope, code.Span, ":"));
}
}
else if (code.ReadExactWholeWord("default"))
{
braces.AddToken(new KeywordToken(scope, code.Span, "default"));
if (!code.ReadExact(':'))
{
continue;
}
braces.AddToken(new OperatorToken(scope, code.Span, ":"));
}
else
{
var stmt = StatementToken.TryParse(scope);
if (stmt != null)
{
braces.AddToken(stmt);
}
}
}
}
return(ret);
}
public ExtractTableToken(Scope scope, Span span, string name, ExtractTableDefinition def)
: base(scope, span, name)
{
SourceDefinition = def;
}
public static ExtractStatement Parse(Scope scope, KeywordToken extractKeywordToken)
{
var code = scope.Code;
var tokens = new List <Token>();
tokens.Add(extractKeywordToken);
var permanent = false;
if (code.ReadExactWholeWord("permanent"))
{
var permToken = new KeywordToken(scope, code.Span, "permanent");
tokens.Add(permToken);
permanent = true;
}
ExtractTableDefinition exDef = null;
string name = null;
if (!code.ReadWord())
{
// Not correct syntax; exit here.
return(new ExtractStatement(scope, tokens)
{
_fields = new ExtractFieldDefinition[0]
});
}
else if ((exDef = scope.DefinitionProvider.GetGlobalFromFile <ExtractTableDefinition>(code.Text).FirstOrDefault()) == null)
{
// The extract definition would have been added by the preprocessor. If it's not recognized here, then it's incorrect syntax.
return(new ExtractStatement(scope, tokens)
{
_fields = new ExtractFieldDefinition[0]
});
}
else
{
name = code.Text;
tokens.Add(new ExtractTableToken(scope, code.Span, name, exDef));
}
var ret = new ExtractStatement(scope, tokens);
ret._name = name;
ret._permanent = permanent;
var scope2 = scope.CloneIndent();
scope2.Hint |= ScopeHint.SuppressControlStatements | ScopeHint.SuppressFunctionDefinition | ScopeHint.SuppressVarDecl;
var fieldTokens = new List <ExtractFieldToken>();
while (!code.EndOfFile)
{
if (code.ReadExact(';'))
{
ret.AddToken(new StatementEndToken(scope2, code.Span));
break;
}
ExtractFieldDefinition fieldDef;
if ((fieldDef = exDef.GetField(code.PeekWordR())) != null)
{
var fieldToken = new ExtractFieldToken(scope, code.MovePeekedSpan(), code.Text, fieldDef);
fieldTokens.Add(fieldToken);
ret.AddToken(fieldToken);
}
else
{
break;
}
if (!code.PeekExact("==") && code.PeekExact('='))
{
var equalsToken = new OperatorToken(scope, code.MovePeekedSpan(), code.Text);
ret.AddToken(equalsToken);
}
else
{
break;
}
var oldValue = code.StopAtLineEnd;
code.StopAtLineEnd = true;
try
{
while (true)
{
var exp = ExpressionToken.TryParse(scope, null, expectedDataType: fieldDef.DataType);
if (exp != null)
{
ret.AddToken(exp);
if (fieldDef.DataType == null)
{
fieldDef.SetDataType(exp.ValueDataType);
}
}
else
{
break;
}
}
}
finally
{
code.StopAtLineEnd = oldValue;
}
}
var fields = new List <ExtractFieldDefinition>();
var rownoDef = new ExtractFieldDefinition("rowno", exDef.FilePosition, exDef);
rownoDef.SetDataType(DataType.Unsigned9);
fields.Add(rownoDef);
fields.AddRange(from f in fieldTokens select f.SourceDefinition as ExtractFieldDefinition);
ret._fields = fields.ToArray();
return(ret);
}
