Exemplo n.º 1
0
        private void ParseTokens()
        {
            if (_tokens.Current.IsNonSignificant())
            {
                ConsumeWhitelines();
            }

            while (_tokens.Current.Type != TokenType.EndOfFile)
            {
                switch (_tokens.Current.Type)
                {
                case TokenType.Include:
                case TokenType.OptionalInclude:
                    _root.Add(ParseInclude(_root));
                    break;

                // may contain one array and one array only
                case TokenType.StartOfArray:
                    _root.Add(ParseArray(_root));
                    break;

                case TokenType.StartOfObject:
                    _root.Add(ParseObject(_root).GetObject());
                    break;

                case TokenType.LiteralValue:
                    if (_tokens.Current.IsNonSignificant())
                    {
                        ConsumeWhitelines();
                    }
                    if (_tokens.Current.Type != TokenType.LiteralValue)
                    {
                        break;
                    }

                    _root.Add(ParseObject(_root).GetObject());
                    break;

                case TokenType.Comment:
                case TokenType.EndOfLine:
                case TokenType.EndOfFile:
                case TokenType.EndOfObject:
                case TokenType.EndOfArray:
                    _tokens.Next();
                    break;

                default:
                    throw JsonPlusParserException.Create(_tokens.Current, null, string.Format(RS.IllegalTokenType, _tokens.Current.Type), null);
                }
            }
        }
Exemplo n.º 2
0
        /// <see cref="IJsonPlusNode.Clone(IJsonPlusNode)"/>
        public virtual IJsonPlusNode Clone(IJsonPlusNode newParent)
        {
            JsonPlusValue clone = new JsonPlusValue(newParent);

            foreach (IJsonPlusNode value in this)
            {
                clone.Add(value.Clone(clone));
            }
            return(clone);
        }
Exemplo n.º 3
0
        internal void EnsureMemberIsObject()
        {
            if (Type == JsonPlusType.Object)
            {
                return;
            }

            JsonPlusValue  v = new JsonPlusValue(this);
            JsonPlusObject o = new JsonPlusObject(v);

            v.Add(o);
            _internalValues.Add(v);
        }
Exemplo n.º 4
0
        internal JsonPlusValue OlderValueThan(IJsonPlusNode marker)
        {
            List <JsonPlusObject> objectList = new List <JsonPlusObject>();
            int index = 0;

            while (index < _internalValues.Count)
            {
                JsonPlusValue value = _internalValues[index];
                if (value.Any(v => ReferenceEquals(v, marker)))
                {
                    break;
                }

                switch (value.Type)
                {
                case JsonPlusType.Object:
                    objectList.Add(value.GetObject());
                    break;

                case JsonPlusType.Literal:
                case JsonPlusType.Array:
                    objectList.Clear();
                    break;
                }

                index++;
            }

            if (objectList.Count == 0)
            {
                return(index == 0
                    ? null
                    : _internalValues[index - 1]);
            }

            JsonPlusValue  result = new JsonPlusValue(null);
            JsonPlusObject o      = new JsonPlusObject(result);

            result.Add(o);

            foreach (JsonPlusObject obj in objectList)
            {
                o.Merge(obj);
            }

            return(result);
        }
Exemplo n.º 5
0
        private void ResolveAllSubstitution(bool resolveEnv)
        {
            foreach (JsonPlusSubstitution sub in _substitutions)
            {
                // Retrieve value
                JsonPlusValue res;
                try
                {
                    res = ResolveSubstitution(sub);
                }
                catch (JsonPlusException e)
                {
                    throw JsonPlusParserException.Create(sub, sub.Path, string.Format(RS.SubstitutionError, e.Message), e);
                }

                if (res != null)
                {
                    sub.ResolvedValue = res;
                    continue;
                }

                if (resolveEnv)
                {
                    // Try to pull value from environment
                    string envValue = null;
                    try
                    {
                        envValue = Environment.GetEnvironmentVariable(sub.Path.Value);
                    }
                    catch (Exception)
                    {
                        // ignored
                    }

                    if (envValue != null)
                    {
                        // undefined value resolved to an environment variable
                        res = new JsonPlusValue(sub.Parent);
                        if (envValue.NeedQuotes())
                        {
                            res.Add(new QuotedStringValue(sub.Parent, envValue));
                        }
                        else
                        {
                            res.Add(new UnquotedStringValue(sub.Parent, envValue));
                        }

                        sub.ResolvedValue = res;
                        continue;
                    }
                }

                // ${ throws exception if it is not resolved
                if (sub.Required)
                {
                    throw JsonPlusParserException.Create(sub, sub.Path, string.Format(RS.UnresolvedSubstitution, sub.Path));
                }

                sub.ResolvedValue = new EmptyValue(sub.Parent);
            }
        }
Exemplo n.º 6
0
        /// <summary>
        /// Retrieves the next value token from the tokenizer and appends it
        /// to the supplied element <paramref name="owner"/>.
        /// </summary>
        /// <param name="owner">The element to append the next token.</param>
        /// <exception cref="Exception">End of file reached while trying to read a value</exception>
        private JsonPlusValue ParseValue(IJsonPlusNode owner)
        {
            JsonPlusValue value   = new JsonPlusValue(owner);
            bool          parsing = true;

            while (parsing)
            {
                switch (_tokens.Current.Type)
                {
                case TokenType.Include:
                case TokenType.OptionalInclude:
                    value.Add(ParseInclude(value));
                    break;

                case TokenType.LiteralValue:
                    // Consume leading whitespaces.
                    if (_tokens.Current.IsNonSignificant())
                    {
                        ConsumeWhitespace();
                    }
                    if (_tokens.Current.Type != TokenType.LiteralValue)
                    {
                        break;
                    }

                    while (_tokens.Current.Type == TokenType.LiteralValue)
                    {
                        value.Add(JsonPlusLiteralValue.Create(value, _tokens.Current));
                        _tokens.Next();
                    }
                    break;

                case TokenType.StartOfObject:
                    value.Add(ParseObject(value));
                    break;

                case TokenType.StartOfArray:
                    value.Add(ParseArray(value));
                    break;

                case TokenType.OptionalSubstitution:
                case TokenType.Substitution:
                    JsonPlusPath         pointerPath = JsonPlusPath.Parse(_tokens.Current.Value);
                    JsonPlusSubstitution sub         = new JsonPlusSubstitution(value, pointerPath, _tokens.Current,
                                                                                _tokens.Current.Type == TokenType.Substitution);
                    _substitutions.Add(sub);
                    value.Add(sub);
                    _tokens.Next();
                    break;

                case TokenType.EndOfObject:
                case TokenType.EndOfArray:
                    parsing = false;
                    break;

                // comments automatically stop value parsing.
                case TokenType.Comment:
                    ConsumeWhitelines();
                    parsing = false;
                    break;

                case TokenType.EndOfLine:
                    parsing = false;
                    break;

                case TokenType.EndOfFile:
                case TokenType.ArraySeparator:
                    parsing = false;
                    break;

                case TokenType.SelfAssignment:
                    JsonPlusSubstitution subAssign = new JsonPlusSubstitution(value, new JsonPlusPath(Path), _tokens.Current, false);
                    _substitutions.Add(subAssign);
                    value.Add(subAssign);

                    value.Add(ParseSelfAssignArray(value));
                    parsing = false;
                    break;

                case TokenType.Assignment:
                    ConsumeWhitelines();
                    break;

                default:
                    throw JsonPlusParserException.Create(_tokens.Current, Path, string.Format(RS.ErrAtUnexpectedToken, _tokens.Current.Type));
                }
            }

            // trim trailing whitespace if result is a literal
            if (value.Type == JsonPlusType.Literal)
            {
                if (value[value.Count - 1] is WhitespaceValue)
                {
                    value.RemoveAt(value.Count - 1);
                }
            }
            return(value);
        }