public static Token Parse(Scope scope, InsertStartToken insertToken)
{
var code = scope.Code;
var ret = new InsertToken(scope);
var scopeIndent = scope.CloneIndent();
ret.AddToken(ret._startToken = insertToken);
var done = false;
while (!done && !code.EndOfFile)
{
var token = StatementToken.TryParse(scopeIndent, t =>
{
if (t is InsertEndToken)
{
ret._endToken = t as InsertEndToken;
done = true;
}
});
if (token != null)
{
ret.AddToken(token);
}
}
return(ret);
}
public void Parse(CodeSource source, string fileName, IEnumerable <string> parentFiles, bool visible)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
_source = source;
_code = new CodeParser(_source.Text);
_fileName = fileName;
_parentFiles = parentFiles.ToArray();
FunctionFileScanning.FFUtil.FileNameIsClass(_fileName, out _className);
var scope = new Scope(this, 0, ScopeHint.None, visible, _model.DefinitionProvider);
scope.ClassName = _className;
Scope = scope;
while (_code.SkipWhiteSpace())
{
var stmt = StatementToken.TryParse(scope);
if (stmt != null)
{
AddToken(stmt);
}
}
Span = new Span(0, _code.Length);
}
/// <summary>
/// Parses a set of braces from the file.
/// </summary>
/// <param name="scope">The current scope.</param>
/// <param name="ownerDef">(optional) A definition of an object (e.g. function) that owns these braces.</param>
/// <param name="funcOutliningStart">(optional) To specify a custom outlining region start position. Function use this to get the outlining to appear at the end of the previous line.</param>
/// <returns>The braces token.</returns>
public static BracesToken Parse(Scope scope, Definition ownerDef, int funcOutliningStart = -1)
{
if (ownerDef != null)
{
scope = scope.CloneIndent();
scope.ReturnDataType = ownerDef.DataType;
}
var code = scope.Code;
if (!code.ReadExact('{'))
{
throw new InvalidOperationException("BracesToken.Parse expected next char to be '{'.");
}
var openBraceSpan = code.Span;
var indentScope = scope.CloneIndentNonRoot();
indentScope.Hint |= ScopeHint.SuppressFunctionDefinition;
var ret = new BracesToken(scope);
ret._funcOutliningStart = funcOutliningStart;
ret._openToken = new BraceToken(scope, openBraceSpan, ret, true);
ret.AddToken(ret._openToken);
while (!code.EndOfFile)
{
if (code.ReadExact('}'))
{
ret._closeToken = new BraceToken(scope, code.Span, ret, false);
ret.AddToken(ret._closeToken);
return(ret);
}
var stmt = StatementToken.TryParse(scope);
if (stmt != null)
{
ret.AddToken(stmt);
}
}
return(ret);
}
public static ReplaceToken Parse(Scope scope, ReplaceStartToken startToken)
{
#if DEBUG
if (startToken == null)
{
throw new ArgumentNullException("replaceToken");
}
#endif
var scopeIndent = scope.CloneIndent();
var ret = new ReplaceToken(scope, startToken);
var done = false;
while (!done && !scope.Code.EndOfFile)
{
var stmt = StatementToken.TryParse(scopeIndent, t =>
{
if (t is ReplaceEndToken)
{
ret._endToken = t as ReplaceEndToken;
ret._endToken.ReplaceToken = ret;
done = true;
}
else if (ret._withToken == null)
{
if (t is ReplaceWithToken)
{
ret._withToken = t as ReplaceWithToken;
ret._withToken.ReplaceToken = ret;
}
else
{
ret._oldTokens.Add(t);
}
}
else
{
ret._newTokens.Add(t);
}
});
}
return(ret);
}
public static SwitchStatement Parse(Scope scope, KeywordToken switchToken)
{
var ret = new SwitchStatement(scope, switchToken);
scope = scope.Clone();
scope.BreakOwner = ret;
var code = scope.Code;
var expressionScope = scope.Clone();
expressionScope.Hint |= ScopeHint.SuppressDataType | ScopeHint.SuppressFunctionDefinition | ScopeHint.SuppressVarDecl;
ret._expressionToken = ExpressionToken.TryParse(expressionScope, null);
if (ret._expressionToken != null)
{
ret.AddToken(ret._expressionToken);
}
if (code.ReadExact('{'))
{
var bodyScope = scope.Clone();
bodyScope.Hint |= ScopeHint.SuppressFunctionDefinition;
ret._bodyToken = new BracesToken(bodyScope, code.Span);
ret.AddToken(ret._bodyToken);
var switchDataType = ret.ExpressionDataType;
while (true)
{
if (code.ReadExact('}'))
{
ret._bodyToken.AddClose(code.Span);
return(ret);
}
if (code.ReadExactWholeWord("case"))
{
ret.AddToken(new KeywordToken(scope, code.Span, "case"));
var caseExp = ExpressionToken.TryParse(scope, _caseEndTokens, expectedDataType: switchDataType);
if (caseExp != null)
{
ret.AddToken(caseExp);
}
if (code.ReadExact(':'))
{
ret.AddToken(new OperatorToken(scope, code.Span, ":"));
}
continue;
}
if (code.ReadExactWholeWord("default"))
{
ret.AddToken(new KeywordToken(scope, code.Span, "default"));
if (code.ReadExact(':'))
{
ret.AddToken(new OperatorToken(scope, code.Span, ":"));
}
continue;
}
var stmt = StatementToken.TryParse(bodyScope);
if (stmt != null)
{
ret._bodyToken.AddToken(stmt);
}
else
{
break;
}
}
}
return(ret);
}
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);
}
