/// <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); } }