Exemple #1
0
        public static JsonScannerToken New(eTokenType type)
        {
            JsonScannerToken ret = new JsonScannerToken();

            ret.Type = type;
            return(ret);
        }
Exemple #2
0
        private JsonScannerToken InputGetToken()
        {
            JsonScannerToken ret = m_Scanner.GetToken();

            LastToken = ret;
            return(ret);
        }
Exemple #3
0
 private bool InternalParseObjectProperties()
 {
     while (true)
     {
         JsonScannerToken token = InputGetToken();
         if (token.Type == eTokenType.FechaChaves)
         {
             return(true);
         }
         if (token.Type == eTokenType.String)
         {
             token = InputGetToken();
             if (token.Type != eTokenType.DoisPontos)
             {
                 return(ReturnError("Esperado ':'"));
             }
             if (!ParseValue(false))
             {
                 return(false);
             }
             token = InputGetToken();
             if (token.Type == eTokenType.FechaChaves)
             {
                 return(true);
             }
             if (token.Type == eTokenType.Virgula)
             {
                 continue;
             }
             return(ReturnError("Esperado '}' ou ','"));
         }
         return(ReturnError("Esperado string ou '}'"));
     }
 }
Exemple #4
0
 private void Reset()
 {
     this.ThrowError          = true;
     this.m_Scanner           = null;
     this.m_ParseErrorMessage = null;
     this.m_ParseErrorToken   = null;
 }
Exemple #5
0
        private bool InternalParseObject()
        {
            JsonScannerToken token = InputGetToken();

            if (token.Type != eTokenType.AbreChaves)
            {
                return(ReturnError("Esperado '{'"));
            }
            return(InternalParseObjectProperties());
        }
Exemple #6
0
        protected JsonScannerToken ReturnToken(eTokenType tipo, object conteudo)
        {
            CurrentToken.Type = tipo;
            if (conteudo != null)
            {
                CurrentTokenAppend(conteudo);
            }
            JsonScannerToken ret = CurrentToken;

            NewCurrentToken();
            return(ret);
        }
Exemple #7
0
        private bool InternalParseIdent(JsonScannerToken token)
        {
            string cont = token.Conteudo.ToString();

            switch (cont)
            {
            case "true":
            case "false":
            case "null":
                return(true);
            }
            return(ReturnError("Esperado true, false ou null"));
        }
Exemple #8
0
 public bool ParseObject(bool eof)
 {
     if (!InternalParseObject())
     {
         return(ReturnError("Valor JSON esperado"));
     }
     if (eof)
     {
         JsonScannerToken token = InputGetToken();
         if (token.Type != eTokenType.Eof)
         {
             return(ReturnError("EOF esperado"));
         }
     }
     return(true);
 }
Exemple #9
0
 public JsonScannerToken GetToken()
 {
     if (m_Input != null)
     {
         JsonScannerToken ret = InternalGetToken();
         if (ret.Type == eTokenType.Eof || ret.Type == eTokenType.Erro)
         {
             m_Input.Dispose();
             m_Input = null;
         }
         m_tokens.Add(ret);
         return(ret);
     }
     if (m_tokensIndex < m_tokens.Count)
     {
         return(m_tokens[m_tokensIndex++]);
     }
     return(JsonScannerToken.New(eTokenType.Eof));
 }
Exemple #10
0
        public bool ParseValue(bool eof)
        {
            while (true)
            {
                JsonScannerToken token = InputGetToken();

                if (token.Type == eTokenType.Numeric)
                {
                    break;
                }
                if (token.Type == eTokenType.String)
                {
                    break;
                }

                if (token.Type == eTokenType.AbreChaves)
                {
                    return(InternalParseObjectProperties());
                }
                if (token.Type == eTokenType.AbreColchetes)
                {
                    return(InternalParseVector());
                }

                if (token.Type == eTokenType.Ident)
                {
                    return(InternalParseIdent(token));
                }

                return(ReturnError("Esperado: número, string, '{' ou '['"));
            }

            if (eof)
            {
                JsonScannerToken token = InputGetToken();
                if (token.Type != eTokenType.Eof)
                {
                    return(ReturnError("EOF esperado"));
                }
            }

            return(true);
        }
Exemple #11
0
        public bool ReturnError(string mensagem, JsonScannerToken token)
        {
            if (token == null)
            {
                token = LastToken;
            }

            mensagem += String.Format(" (linha {0}, coluna {1})", token.NumeroLinha, token.NumeroColuna);
            if (ThrowError)
            {
                throw new Exception(mensagem);
            }
            if (String.IsNullOrWhiteSpace(this.m_ParseErrorMessage))
            {
                this.m_ParseErrorMessage = mensagem;
                this.m_ParseErrorToken   = token;
            }
            return(false);
        }
Exemple #12
0
 private bool InternalParseVector()
 {
     while (true)
     {
         if (!ParseValue(false))
         {
             return(ReturnError("Esperado valor JSON"));
         }
         JsonScannerToken token = InputGetToken();
         if (token.Type == eTokenType.FechaColchetes)
         {
             return(true);
         }
         if (token.Type == eTokenType.Virgula)
         {
             continue;
         }
         return(ReturnError("Esperado: ']' ou ','"));
     }
 }
Exemple #13
0
        public bool ParseVector(bool eof)
        {
            JsonScannerToken token = InputGetToken();

            if (token.Type != eTokenType.AbreColchetes)
            {
                return(ReturnError("Esperado '['"));
            }
            if (!InternalParseVector())
            {
                return(false);
            }
            if (eof)
            {
                token = InputGetToken();
                if (token.Type != eTokenType.Eof)
                {
                    return(ReturnError("EOF esperado"));
                }
            }
            return(true);
        }
Exemple #14
0
 protected void NewCurrentToken()
 {
     CurrentToken              = new JsonScannerToken();
     CurrentToken.NumeroLinha  = this.NumeroLinha;
     CurrentToken.NumeroColuna = this.NumeroColuna;
 }