/// <summary>
/// Parse a module identifier
/// </summary>
/// <param name="identifier">Identifier to parse</param>
public ModuleId ParseModuleId()
{
ModuleId moduleId = new ModuleId();
//parse module identifier
while (TokenStream.HasNext())
{
if (NextToken("identifier", "module identifier.identifier", TokenType.IDENTIFIER))
{
moduleId.AddIdentifier(CurrentToken.GetValue().ToString());
}
else
{
//Raise exception
throw new UnexpectedToken("Unexpected token found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine());
}
if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == ".")
{ //Period, so another identifier will appear after this one
NextToken(".", "module identifier.identifier", '.');
}
else
{
break; //No more module identifier stuff will appear
}
}
return(moduleId);
}
string parseFnText()
{
string text = CurrentToken.GetText();
MoveNext();
return(text);
}
public async Task <TokenDetails> GetCurrentValidTokenAndRenewIfNecessaryAsync()
{
if (AuthMethod == AuthMethod.Basic)
{
throw new AblyException("AuthMethod is set to Auth so there is no current valid token.");
}
if (CurrentToken.IsValidToken(ServerTimeOffset() ?? Now()))
{
return(CurrentToken);
}
if (TokenRenewable)
{
var token = await AuthorizeAsync();
var now = ServerTimeOffset() ?? Now();
if (token.IsValidToken(now))
{
CurrentToken = token;
return(token);
}
if (token != null && token.IsExpired(now))
{
throw new AblyException("Token has expired: " + CurrentToken, 40142, HttpStatusCode.Unauthorized);
}
}
return(null);
}
private void ReturnIdOrTokenOrLabel(LexerState lexerState, Symbol symbol)
{
if (_tokens.Contains(CurrentToken.ToString()))
{
CurrentToken.TokenIndex = _tokens.IndexOf(CurrentToken.ToString()) + 1;
Log(LogEventLevel.Information, "Found token {0}", false, CurrentToken);
ReturnToken(CurrentToken, symbol);
}
else if (symbol.Class?.Class == Class.Colon || Parsed.Last().Substring == "goto")
{
//Label
ReturnLabel(new StateMachine.Transition(lexerState, LexerState.LabelDefinition, symbol));
}
else
{
Log(LogEventLevel.Information, "Not found token - treat as ID: {0}", false, CurrentToken);
var identifier =
Identifiers.FirstOrDefault(x => x.Name == CurrentToken.ToString())?.Clone() as IdentifierToken;
if (identifier == null)
{
identifier = new IdentifierToken(CurrentToken.ToString())
{
TokenIndex = IdIndex
};
Identifiers.Add(identifier);
}
identifier.Line = Line;
ReturnToken(identifier, symbol);
}
}
TKTPropertyModel parseProperty(CodePostion parentPostion)
{
TKTPropertyModel ast = new TKTPropertyModel();
ast.Postion = CurrentToken.Postion;
if (CurrentKind != TokenKind.Ident)
{
//error("不是正确的名称");
}
else
{
ast.PropertyType = CurrentToken.GetText();
}
MoveNext();
match(TokenKind.Colon);
if (CurrentKind != TokenKind.Ident)
{
//error("不是正确的变量名称");
}
else
{
ast.PropertyName = CurrentToken.GetText();
}
MoveNext();
if (CurrentKind == TokenKind.Assign)
{
MoveNext();
skipToSemi();
//Exp exp = parseExp();
//ast.ValueExp = exp;
}
match(TokenKind.Semi);
return(ast);
}
TKTArgModel parseFnArg()
{
TKTArgModel argt = new TKTArgModel();
if (CurrentKind == TokenKind.Ident)
{
argt.ArgType = CurrentToken.GetText();
MoveNext();
if (CurrentKind == TokenKind.Colon)
{
MoveNext();
if (CurrentKind == TokenKind.Ident)
{
argt.ArgName = CurrentToken.GetText();
MoveNext();
return(argt);
}
else
{
//error("参数名称不正确");
}
}
else
{
//error("应该是':'");
}
}
else
{
//error("参数类型不正确");
MoveNext();
}
return(null);
}
public async Task <TokenDetails> GetCurrentValidTokenAndRenewIfNecessaryAsync()
{
if (AuthMethod == AuthMethod.Basic)
{
throw new AblyException("AuthMethod is set to Auth so there is no current valid token.");
}
if (CurrentToken.IsValidToken())
{
return(CurrentToken);
}
if (TokenRenewable)
{
var token = await AuthoriseAsync();
if (token.IsValidToken())
{
CurrentToken = token;
return(token);
}
}
return(null);
}
/// <summary>
/// Parser for EachStatement
/// </summary>
/// <returns>Parsed EachStatement</returns>
public EachStatement ParseEachStatement()
{
EachStatement eachStatement = new EachStatement();
//Skip each token
NextToken("each", "each (identifier : expression) Statement", "each");
//Skip ( token
NextToken("(", "each (identifier : expression) Statement", '(');
//Parse identifier
CurrentToken = TokenStream.NextToken();
eachStatement.SetIdentifier(CurrentToken.GetValue().ToString());
//Skip : token
NextToken(":", "each (identifier : expression) Statement", ':');
//Parse expression
eachStatement.SetExpression(expressionParser.ParseExpression());
//Skip ) token
NextToken(")", "each (identifier : expression) Statement", ')');
//Parse statement
eachStatement.SetStatement(ParseStatement());
return(eachStatement);
}
Exp parseTerm()
{
if (CurrentToken.Kind == TokenKind.LBS)
{
return(parseBracket());
}
else if (CurrentToken.Kind == TokenKind.RBS)
{
error("多余的右括号");
MoveNext();
return(null);
}
else if (CurrentToken.IsLiteral())
{
return(parseLiteral());
}
else if (CurrentToken.Kind == TokenKind.Ident && NextToken.Kind == TokenKind.Colon)
{
return(pareNV());
}
else if (CurrentToken.Kind == TokenKind.Ident)
{
return(parseIdent());
}
else
{
return(null);
}
}
internal ElevateToken Elevate(String message)
{
if (CurrentToken == null || CurrentToken.IsExpired())
{
Logger.Debug("We don't have an elevation token or it has expired, requesting from server.");
ElevateTokenRq erq = new ElevateTokenRq();
try
{
String password = UIManager.RequestElevation(message);
// Make sure password isn't empty and conforms to the current password.
if (!String.IsNullOrWhiteSpace(password) &&
Util.getSingleton().hashPassword(password).Equals(Reg.PasswordHash))
{
ElevateTokenRs ers = ConnectionManager.Connection.Request <ElevateTokenRq, ElevateTokenRs>(erq);
CurrentToken = new ElevateToken(ers.tokenId, ers.token, password, ers.expires);
}
else
{
Logger.Error("Entered password for elevation is invalid.");
CurrentToken = null;
throw new ElevationException();
}
}
finally
{
UIManager.CompleteElevation();
}
}
else
{
Logger.Debug("Reusing elevate token " + CurrentToken.TokenId);
}
return(CurrentToken);
}
bool expIsInExp()
{
if (isNewLine())
{
return(false);
}
return(CurrentKind == TokenKind.Ident || CurrentKind == TokenKind.LBS || CurrentToken.IsLiteral());
}
/// <summary>
/// Parser for Formal
/// </summary>
/// <returns>Parsed Formal</returns>
public Formal ParseFormal()
{
Formal formal = new Formal();
CurrentToken = TokenStream.NextToken();
formal.SetIdentifier(CurrentToken.GetValue().ToString());
return(formal);
}
/// <summary>
/// Parse an TextExpression
/// </summary>
/// <returns>Parsed TextExpression</returns>
public TextExpression ParseTextExpression()
{
TextExpression textExpression = new TextExpression();
CurrentToken = TokenStream.NextToken();
textExpression.SetText(CurrentToken.GetValue().ToString());
return(textExpression);
}
/// <summary>
/// Parse an NumericExpression
/// </summary>
/// <returns>Parsed Numeric Expression</returns>
public NumExpression ParseNumExpression()
{
NumExpression numExpression = new NumExpression();
CurrentToken = TokenStream.NextToken();
numExpression.SetNum(ObjectToInt(CurrentToken.GetValue()));
return(numExpression);
}
/// <summary>
/// Parse an SymbolExpression
/// </summary>
/// <returns>Parsed SymbolExpression</returns>
public SymExpression ParseSymExpression()
{
SymExpression symExpression = new SymExpression();
CurrentToken = TokenStream.NextToken();
symExpression.SetSym(CurrentToken.GetValue().ToString());
return(symExpression);
}
/// <summary>
/// Parse an VariableExpression
/// </summary>
/// <returns>Parsed VariableExpression</returns>
public VarExpression ParseVarExpression()
{
VarExpression varExpression = new VarExpression();
CurrentToken = TokenStream.NextToken();
varExpression.SetVariableIdentifier(CurrentToken.GetValue().ToString());
return(varExpression);
}
string parseFnText()
{
string text = CurrentToken.GetText();
//FnText textterm = new FnText ();
//textterm.TextToken = CurrentToken;
MoveNext();
return(text);
}
protected void ExpectToken(string token)
{
if (CurrentToken.ToLower() != token.ToLower())
{
throw new ExpectedTokenNotFoundException(token, CurrentToken, Tokenizer.Position);
}
ReadNextToken();
}
/// <summary>
/// Parser for NameAttribute
/// </summary>
/// <returns>Parsed NameAttribute</returns>
public NameAttribute ParseNameAttribute()
{
NameAttribute nameAttribute = new NameAttribute();
//Get name token
CurrentToken = TokenStream.NextToken();
nameAttribute.SetName(CurrentToken.GetValue().ToString());
return(nameAttribute);
}
/// <summary>
/// Parser for WidthAttribute
/// </summary>
/// <returns>Parsed HeightAttribute</returns>
public WidthAttribute ParseWidthAttribute()
{
WidthAttribute widthAttribute = new WidthAttribute();
//Get height
CurrentToken = TokenStream.NextToken();
widthAttribute.SetWidth(ObjectToInt(CurrentToken.GetValue()));
return(widthAttribute);
}
/// <summary>
/// Parser for TypeAttribute
/// </summary>
/// <returns>Parsed TypeAttribute</returns>
public TypeAttribute ParseTypeAttribute()
{
TypeAttribute typeAttribute = new TypeAttribute();
//Get type token
CurrentToken = TokenStream.NextToken();
typeAttribute.SetType(CurrentToken.GetValue().ToString());
return(typeAttribute);
}
public void FlushCurrentToken(TokenType type)
{
var value = CurrentToken.Flush();
if (string.IsNullOrEmpty(value))
{
return;
}
_tokens.Add(new Token(value, type));
}
/// <summary>
/// Parser for ClassAttribute
/// </summary>
/// <returns>Parsed ClassAttribute</returns>
public ClassAttribute ParseClassAttribute()
{
ClassAttribute classAttribute = new ClassAttribute();
//Get class token
CurrentToken = TokenStream.NextToken();
classAttribute.SetClass(CurrentToken.GetValue().ToString());
return(classAttribute);
}
/// <summary>
/// Parser for IdAttribute
/// </summary>
/// <returns>Parsed IdAttribute</returns>
public IdAttribute ParseIdAttribute()
{
IdAttribute idAttribute = new IdAttribute();
//Get id token
CurrentToken = TokenStream.NextToken();
idAttribute.SetId(CurrentToken.GetValue().ToString());
return(idAttribute);
}
TKTProcModel parseFnName()
{
TKTProcModel fname = new TKTProcModel();
fname.Postion = CurrentToken.Postion;
var curline = CurrentToken.Line;
while (CurrentToken.Kind != TokenKind.EOF && curline == CurrentToken.Line)
{
if (CurrentKind == TokenKind.LBS)
{
var arg = parseFnMuArg();
if (arg != null)
{
fname.Elements.Add(arg);
}
}
else if (CurrentKind == TokenKind.Ident)
{
var textt = parseFnText();
if (textt != null)
{
fname.Elements.Add(textt);
}
}
else if (CurrentKind == TokenKind.AssignTo)
{
if (fname.Elements == null || fname.Elements.Count == 0)
{
//error("过程没有名称");
MoveNext();
}
else
{
MoveNext();
if (CurrentKind == TokenKind.Ident)
{
fname.RetType = CurrentToken.GetText();
MoveNext();
}
else
{
//error("错误的过程结果");
MoveNext();
}
}
}
else
{
//error("错误的过程名称");
MoveNext();
}
}
return(fname);
}
/// <summary>
/// Throws an error if the current token does not match the given expression.
/// </summary>
/// <param name="expression">The expression to check.</param>
public void Expect(string expression)
{
var match = CurrentToken.Equals(expression, StringComparison.OrdinalIgnoreCase);
if (!match)
{
throw new ParserException($"'{expression}' expected but found '{CurrentToken}'", CurrentLineNumber);
}
Move();
}
public async Task EnsureAuthenticatedAsync()
{
if (CurrentToken != null && !CurrentToken.IsExpired())
{
return;
}
CurrentToken = await Credentials.DoAuthAsync().ConfigureAwait(false);
Api.TokenType = CurrentToken.TokenType;
Api.AccessToken = CurrentToken.AccessToken;
}
/// <summary>
/// Get NextToken and verify if it exists (EmbeddedTokenStream)
/// </summary>
/// <param name="name">Name of expected token</param>
/// <param name="syntax">Syntax of expected token</param>
/// <returns>True if new token found, otherwise false</returns>
private new bool NextToken(String name, String syntax)
{
if (EmbeddingTokenStream.HasNext())
{
CurrentToken = EmbeddingTokenStream.NextToken();
return(true);
}
else
{
throw new UnexpectedToken("Unexpected token found:", CurrentToken.GetValue().ToString(), CurrentToken.GetLine());
}
}
/// <summary>
/// Parser for TextChars
/// </summary>
/// <returns>Parsed TextChars as String</returns>
public String ParseTextChars()
{
StringBuilder stringBuilder = new StringBuilder();
while (EmbeddingTokenStream.HasNext() && EmbeddingTokenStream.Peek(1).GetType() == TokenType.TEXT)
{ //Parse all text tokens until different type found
CurrentToken = EmbeddingTokenStream.NextToken();
stringBuilder.Append(CurrentToken.GetValue().ToString());
}
return(stringBuilder.ToString());
}
protected bool checkToken(TokenKind tokKind)
{
if (CurrentToken.Kind != tokKind)
{
error(CurrentToken, CurrentToken.ToCode() + "不正确,应该是" + Token.GetTextByKind(tokKind));
return(false);
}
else
{
return(true);
}
}
