Example #1
0
        internal void WriteArrayPart(TomlArray array)
        {
            this.writer.Write('[');

            for (int i = 0; i < array.Items.Length - 1; i++)
            {
                WriteArrayElement(array.Items[i]);
                this.writer.Write(", ");
            }

            if (array.Items.Length > 0)
            {
                WriteArrayElement(array.Items[array.Items.Length - 1]);
            }

            this.writer.Write(']');

            void WriteArrayElement(TomlValue value)
            {
                if (value is TomlArray arr)
                {
                    this.WriteArrayPart(arr);
                }
                else
                {
                    this.WriteValue(value);
                }
            }
        }
Example #2
0
        protected void WriteArray(TomlKey key, TomlArray array)
        {
            this.writer.Write(key.ToString());
            this.writer.Write(" = ");

            this.WriteArrayPart(array);
        }
Example #3
0
        private TomlArray ReadArray(StringReader reader)
        {
            //Consume the opening bracket
            if (!reader.ExpectAndConsume('['))
            {
                throw new ArgumentException("Internal Tomlet Bug: ReadArray called and first char is not a [");
            }

            //Move to the first value
            _lineNumber += reader.SkipAnyCommentNewlineWhitespaceEtc();

            var result = new TomlArray();

            while (reader.TryPeek(out _))
            {
                //Skip any empty lines
                _lineNumber += reader.SkipAnyCommentNewlineWhitespaceEtc();

                if (!reader.TryPeek(out var nextChar))
                {
                    throw new TomlEOFException(_lineNumber);
                }

                //Check for end of array here (helps with trailing commas, which are legal)
                if (nextChar.IsEndOfArrayChar())
                {
                    break;
                }

                //Read a value
                result.ArrayValues.Add(ReadValue(reader));

                //Skip any whitespace or newlines, NOT comments - that would be a syntax error
                _lineNumber += reader.SkipAnyNewlineOrWhitespace();

                if (!reader.TryPeek(out var postValueChar))
                {
                    throw new TomlEOFException(_lineNumber);
                }

                if (postValueChar.IsEndOfArrayChar())
                {
                    break; //end of array
                }
                if (!postValueChar.IsComma())
                {
                    throw new TomlArraySyntaxException(_lineNumber, (char)postValueChar);
                }

                reader.ExpectAndConsume(','); //We've already verified we have one.
            }

            if (!reader.ExpectAndConsume(']'))
            {
                throw new UnterminatedTomlArrayException(_lineNumber);
            }

            return(result);
        }
 public void Visit(TomlArray a)
 {
     for (int i = 0; i < a.Length; i++)
     {
         PushContext(i.ToString());
         a[i].Visit(this);
         PopContext();
     }
 }
Example #5
0
        internal static string WriteTomlFragment(TomlArray array)
        {
            return(WriteIntoStream(WriteArray));

            void WriteArray(FormattingStreamWriter stream)
            {
                var writer = new TomlTableWriter(stream, array.Root.Settings);

                writer.WriteArrayPart(array);
            }
        }
        void ITomlObjectVisitor.Visit(TomlArray a)
        {
            var clrArray = new object[a.Length];
            var extractItem = new ExtractItemValue();
            for (int i = 0; i < a.Items.Length; i++)
            {
                a[i].Visit(extractItem);
                clrArray[i] = extractItem.Item;
            }

            this.table[this.currentKey] = clrArray;
        }
 private static void ProcessArray(Dictionary <string, string> dict, TomlArray array, string fullKey)
 {
     for (int i = 0; i < array.Items.Length; i++)
     {
         if (array.Items[i] is TomlArray a)
         {
             ProcessArray(dict, a, $"{fullKey}:{i}");
         }
         else
         {
             dict[$"{fullKey}:{i}"] = array.Items[i].ToString();
         }
     }
 }
        private static void ProcessArray(Dictionary <string, string> dict, TomlArray array, string fullKey)
        {
            for (int i = 0; i < array.Items.Length; i++)
            {
                if (array.Items[i] is TomlArray a)
                {
                    throw new InvalidOperationException(
                              $"AspNet provider cannot handle jagged arrays, only simple arrays are supported." +
                              $"The arrays key is '{fullKey}'.");
                }

                dict[$"{fullKey}:{i}"] = array.Items[i].ToString();
            }
        }
Example #9
0
        void ITomlObjectVisitor.Visit(TomlArray a)
        {
            sb.Append("{").Append("\"type\":\"array\", \"value\":[");

            for (int i = 0; i < a.Length - 1; i++)
            {
                a[i].Visit(this);
                this.sb.Append(",");
            }

            if (a.Length > 0) { a[a.Length - 1].Visit(this); }

            this.sb.Append("]}");
        }
Example #10
0
    public static TomlArray BuildCopyPathTable(List <CopyPathMap> list)
    {
        var result = new TomlArray()
        {
            IsTableArray = true
        };

        foreach (var entry in list)
        {
            result.Add(DictToTomlTable(new()
            {
                { "source", entry.From },
                { "target", entry.To }
            }));
Example #11
0
        void ITomlObjectVisitor.Visit(TomlArray a)
        {
            sb.Append("{").Append("\"type\":\"array\", \"value\":[");

            for (int i = 0; i < a.Length - 1; i++)
            {
                a[i].Visit(this);
                this.sb.Append(",");
            }

            if (a.Length > 0)
            {
                a[a.Length - 1].Visit(this);
            }

            this.sb.Append("]}");
        }
Example #12
0
        protected void WriteArray(TomlKey key, TomlArray array)
        {
            this.writer.Write(key.ToString());
            this.writer.Write(" = [");

            for (int i = 0; i < array.Items.Length - 1; i++)
            {
                this.WriteValue(array[i]);
                this.writer.Write(", ");
            }

            if (array.Items.Length > 0)
            {
                this.WriteValue(array.Items[array.Items.Length - 1]);
            }

            this.writer.Write(']');
        }
Example #13
0
        protected void WriteArray(string key, TomlArray array)
        {
            this.writer.Write(key);
            this.writer.Write(" = [");

            for (int i = 0; i < array.Items.Length - 1; i++)
            {
                this.WriteValue(array[i]);
                this.writer.Write(", ");
            }

            if (array.Items.Length > 0)
            {
                this.WriteValue(array.Items[array.Items.Length - 1]);
            }

            this.writer.Write(']');
        }
Example #14
0
        public static LocalConfig Load(string path)
        {
            LocalConfig returnval = new LocalConfig();

            if (File.Exists(path))
            {
                string filestr = File.ReadAllText(path);
                if (!string.IsNullOrEmpty(filestr))
                {
                    var doc = Toml.Parse(filestr);
                    if (doc != null)
                    {
                        var       table   = doc.ToModel();
                        TomlTable MainTbl = (TomlTable)table["AssemblyGenerator"];
                        if (MainTbl != null)
                        {
                            returnval.UnityVersion      = (string)MainTbl["UnityVersion"];
                            returnval.GameAssemblyHash  = (string)MainTbl["GameAssemblyHash"];
                            returnval.DumperVersion     = (string)MainTbl["DumperVersion"];
                            returnval.UnhollowerVersion = (string)MainTbl["UnhollowerVersion"];
                            TomlArray oldfilesarr = (TomlArray)MainTbl["OldFiles"];
                            if (oldfilesarr.Count > 0)
                            {
                                for (int i = 0; i < oldfilesarr.Count; i++)
                                {
                                    string file = (string)oldfilesarr[i];
                                    if (!string.IsNullOrEmpty(file))
                                    {
                                        returnval.OldFiles.Add(file);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            return(returnval);
        }
Example #15
0
        private void ReadTableArrayStatement(StringReader reader, TomlDocument document)
        {
            //Consume the (second) opening bracket
            if (!reader.ExpectAndConsume('['))
            {
                throw new ArgumentException("Internal Tomlet Bug: ReadTableArrayStatement called and first char is not a [");
            }

            //Array
            var arrayName = reader.ReadWhile(c => !c.IsEndOfArrayChar() && !c.IsNewline());

            if (!reader.ExpectAndConsume(']') || !reader.ExpectAndConsume(']'))
            {
                throw new UnterminatedTomlTableArrayException(_lineNumber);
            }

            TomlTable parentTable;

            if (_lastTableArrayName != null && arrayName.StartsWith(_lastTableArrayName + "."))
            {
                //nested array of tables directly relative to parent - we can cheat

                //Save parent table
                parentTable = _currentTable !;

                //Work out relative key
                var relativeKey = arrayName.Replace(_lastTableArrayName + ".", "");

                //Make new array and table
                var newArray = new TomlArray();
                _currentTable = new TomlTable();
                newArray.ArrayValues.Add(_currentTable);

                //Insert into parent table
                parentTable !.ParserPutValue(relativeKey, newArray, _lineNumber);

                //Save variables
                _lastTableArrayName = arrayName;
                return;
            }

            if (TomlKeyUtils.IsSimpleKey(arrayName))
            {
                //Not present - create and populate with one table.
                _currentTable = new TomlTable();

                TomlArray tableArray;

                //Simple key so looking up via document.ContainsKey is fine.
                if (!document.ContainsKey(arrayName))
                {
                    //make a new one if it doesn't exist
                    tableArray = new TomlArray {
                        IsTableArray = true
                    }
                }
                ;
                else if (document.Entries.TryGetValue(arrayName, out var hopefullyArray) && hopefullyArray is TomlArray arr)
                {
                    //already exists, use it
                    tableArray = arr;
                }
                else
                {
                    throw new TomlTableArrayAlreadyExistsAsNonArrayException(_lineNumber, arrayName);
                }

                if (!tableArray.IsTableArray)
                {
                    throw new TomlNonTableArrayUsedAsTableArrayException(_lineNumber, arrayName);
                }

                tableArray.ArrayValues.Add(_currentTable);

                if (!document.ContainsKey(arrayName))
                {
                    //Insert into the document
                    document.ParserPutValue(arrayName, tableArray, _lineNumber);
                }

                //Save variables
                _lastTableArrayName = arrayName;
                return;
            }

            //Need to add to a complex-keyed table array, so may be behind one or more table arrays.

            parentTable = document;
            var components = TomlKeyUtils.GetKeyComponents(arrayName).ToList();

            //Don't check last component
            for (var index = 0; index < components.Count - 1; index++)
            {
                var pathComponent = components[index];

                if (!parentTable.ContainsKey(pathComponent))
                {
                    throw new MissingIntermediateInTomlTableArraySpecException(_lineNumber, pathComponent);
                }

                var value = parentTable.GetValue(pathComponent);

                if (value is TomlArray intermediateArray)
                {
                    if (intermediateArray.Last() is TomlTable table)
                    {
                        parentTable = table;
                    }
                    else
                    {
                        throw new TomlTableArrayIntermediateNonTableException(_lineNumber, arrayName);
                    }
                }
                else if (value is TomlTable table)
                {
                    parentTable = table;
                }
                else
                {
                    throw new TomlKeyRedefinitionException(_lineNumber, pathComponent);
                }
            }

            var lastComponent = components.Last();

            if (parentTable.ContainsKey(lastComponent))
            {
                if (!(parentTable.GetValue(lastComponent) is TomlArray array))
                {
                    throw new TomlTableArrayAlreadyExistsAsNonArrayException(_lineNumber, lastComponent);
                }

                if (!array.IsTableArray)
                {
                    throw new TomlNonTableArrayUsedAsTableArrayException(_lineNumber, arrayName);
                }

                _currentTable = new TomlTable();
                array.ArrayValues.Add(_currentTable);

                _lastTableArrayName = arrayName;
            }
            else
            {
                var array = new TomlArray {
                    IsTableArray = true
                };
                _currentTable = new TomlTable();
                array.ArrayValues.Add(_currentTable);

                parentTable.PutValue(lastComponent, array);

                _lastTableArrayName = arrayName;
            }
        }
Example #16
0
 private void WriteTomlArrayWithComments(TomlKey key, TomlArray array)
 {
     this.WritePrependComments(array);
     this.WriteArray(key, array);
     this.WriteAppendComments(array);
 }
Example #17
0
        private static TomlArray ParseTomlArray(ITomlRoot root, TokenBuffer tokens)
        {
            TomlArray a;
            var       prep = CommentProduction.TryParseComments(tokens, CommentLocation.Prepend).ToList();

            tokens.ExpectAndConsume(TokenType.LBrac);
            using (tokens.UseIgnoreNewlinesContext())
            {
                prep.AddRange(CommentProduction.TryParseComments(tokens, CommentLocation.Prepend));
                if (tokens.TryExpect(TokenType.RBrac))
                {
                    // Empty array handled inside this if, else part can assume the array has values
                    // Comments in an empty array are moved before the array at the moment.
                    // There currently does not exist a comment  location that will allow to write this comments correctly
                    // => Parse the real items correctly and do not create a parse error, but the comment will get lost
                    // on the next write.
                    tokens.Consume();
                    a = new TomlArray(root);
                    a.Comments.AddRange(prep);
                    return(a);
                }
                else
                {
                    List <TomlValue> values = new List <TomlValue>();

                    // Parse first !required! array value
                    var v = ParseArrayValue();
                    v.Comments.AddRange(prep);
                    values.Add(v);

                    while (!tokens.TryExpect(TokenType.RBrac))
                    {
                        if (!tokens.TryExpectAndConsume(TokenType.Comma))
                        {
                            throw Parser.CreateParseError(tokens.Peek(), "Array not closed.");
                        }

                        // This comment is misplaced as we simply append it to the last value, but it does not belong to it
                        // Comments processing needs some tweaking/redesign in the future.
                        v.Comments.AddRange(CommentProduction.TryParseComments(tokens, CommentLocation.Append));

                        if (!tokens.TryExpect(TokenType.RBrac))
                        {
                            var et = tokens.Peek();
                            v = ParseArrayValue();

                            if (v.GetType() != values[0].GetType())
                            {
                                throw Parser.CreateParseError(et, $"Expected array value of type '{values[0].ReadableTypeName}' but value of type '{v.ReadableTypeName}' was found.");
                            }

                            values.Add(v);
                        }
                    }

                    a = new TomlArray(root, values.ToArray());
                }

                a.Last().Comments.AddRange(CommentProduction.TryParseComments(tokens, CommentLocation.Append));
                tokens.ExpectAndConsume(TokenType.RBrac);
                a.Comments.AddRange(CommentProduction.TryParseComments(tokens, CommentLocation.Append));

                TomlValue ParseArrayValue()
                {
                    var prepComments       = CommentProduction.TryParseComments(tokens, CommentLocation.Prepend);
                    var valueParseErrorPos = tokens.Peek();
                    var value = ParseTomlValue(root, tokens);

                    if (value == null)
                    {
                        throw Parser.CreateParseError(valueParseErrorPos, $"Array value is missing.");
                    }

                    value.Comments.AddRange(prepComments);
                    value.Comments.AddRange(CommentProduction.TryParseComments(tokens, CommentLocation.Append));

                    return(value);
                }
            }

            return(a);
        }
        static Config()
        {
            FilePath = Path.Combine(Core.BasePath, "Config.cfg");
            if (!File.Exists(FilePath))
            {
                Save();
                return;
            }
            string filestr = File.ReadAllText(FilePath);

            if (string.IsNullOrEmpty(filestr))
            {
                return;
            }
            DocumentSyntax docsyn = Toml.Parse(filestr);

            if (docsyn == null)
            {
                return;
            }
            TomlTable model = docsyn.ToModel();

            if (model.Count <= 0)
            {
                return;
            }
            TomlTable tbl = (TomlTable)model["AssemblyGenerator"];

            if (tbl == null)
            {
                return;
            }
            if (tbl.ContainsKey("UnityVersion"))
            {
                UnityVersion = (string)tbl["UnityVersion"];
            }
            if (tbl.ContainsKey("Cpp2IL"))
            {
                Cpp2ILVersion = (string)tbl["Cpp2IL"];
            }
            if (tbl.ContainsKey("Il2CppAssemblyUnhollower"))
            {
                Il2CppAssemblyUnhollowerVersion = (string)tbl["Il2CppAssemblyUnhollower"];
            }
            if (tbl.ContainsKey("GameAssemblyHash"))
            {
                GameAssemblyHash = (string)tbl["GameAssemblyHash"];
            }
            if (!tbl.ContainsKey("OldFiles"))
            {
                return;
            }
            TomlArray oldfilesarr = (TomlArray)tbl["OldFiles"];

            if (oldfilesarr.Count <= 0)
            {
                return;
            }
            for (int i = 0; i < oldfilesarr.Count; i++)
            {
                string file = (string)oldfilesarr[i];
                if (!string.IsNullOrEmpty(file))
                {
                    OldFiles.Add(file);
                }
            }
        }
            public void Visit(TomlArray a)
            {
                var clrArray = new object[a.Length];
                var extractItem = new ExtractItemValue();
                for (int i = 0; i < a.Items.Length; i++)
                {
                    a[i].Visit(extractItem);
                    clrArray[i] = extractItem.Item;
                }

                this.Item = clrArray;
            }
Example #20
0
 private void WriteTomlArrayWithComments(string key, TomlArray array)
 {
     this.WritePrependComments(array);
     this.WriteArray(key, array);
     this.WriteAppendComments(array);
 }
Example #21
0
        private static TomlArray ParseTomlArray(ITomlRoot root, TokenBuffer tokens)
        {
            TomlArray a;

            tokens.ExpectAndConsume(TokenType.LBrac);
            tokens.ConsumeAllNewlines();

            if (tokens.TryExpect(TokenType.RBrac))
            {
                // Empty array handled inside this if, else part can assume the array has values
                tokens.Consume();
                return new TomlArray(root);
            }
            else
            {
                List<TomlValue> values = new List<TomlValue>();
                var errPos = tokens.Peek();
                var v = ParseTomlValue(root, tokens);

                if (v == null)
                {
                    throw Parser.CreateParseError(errPos, $"Array value is missing.");
                }

                values.Add(v);

                while (!tokens.TryExpect(TokenType.RBrac))
                {
                    if (!tokens.TryExpectAndConsume(TokenType.Comma))
                    {
                        throw Parser.CreateParseError(tokens.Peek(), "Array not closed.");
                    }

                    tokens.ConsumeAllNewlines();
                    values.Last().Comments.AddRange(CommentProduction.TryParseComments(tokens, CommentLocation.Append));

                    if (!tokens.TryExpect(TokenType.RBrac))
                    {
                        var et = tokens.Peek();
                        v = ParseTomlValue(root, tokens);

                        if (v == null)
                        {
                            throw Parser.CreateParseError(et, $"Array value is missing.");
                        }

                        if (v.GetType() != values[0].GetType())
                        {
                            throw Parser.CreateParseError(et, $"Expected value of type '{values[0].ReadableTypeName}' but value of type '{v.ReadableTypeName}' was found.");
                        }

                        values.Add(v);
                        tokens.ConsumeAllNewlines();
                    }
                }

                a = new TomlArray(root, values.ToArray());
            }

            a.Last().Comments.AddRange(CommentProduction.TryParseComments(tokens, CommentLocation.Append));
            tokens.ExpectAndConsume(TokenType.RBrac);

            return a;
        }
Example #22
0
        private static TomlObject ToTomlValue(ITomlRoot root, ValueNode node)
        {
            switch (node.Value.SyntaxNode())
            {
            case TerminalNode tn: return(CreateValueFromTerminal(tn.Terminal));

            case ArrayNode an: return(CreateArrayOrTableArray(an));

            case InlineTableNode it: return(CreateInlineTable(it));

            default: throw new Exception($"Cannot create TomlValue from node with type '{node.GetType()}'.");
            }

            TomlValue CreateValueFromTerminal(Token terminal)
            {
                switch (terminal.Type)
                {
                case TokenType.Integer: return(new TomlInt(root, Convert.ToInt64(Cleanup(terminal.Value, 0)), TomlInt.IntTypes.Decimal));

                case TokenType.HexInteger: return(new TomlInt(root, Convert.ToInt64(Cleanup(terminal.Value, 2), 16), TomlInt.IntTypes.Hex));

                case TokenType.BinaryInteger: return(new TomlInt(root, Convert.ToInt64(Cleanup(terminal.Value, 2), 2), TomlInt.IntTypes.Binary));

                case TokenType.OctalInteger: return(new TomlInt(root, Convert.ToInt64(Cleanup(terminal.Value, 2), 8), TomlInt.IntTypes.Octal));

                case TokenType.Bool: return(new TomlBool(root, Convert.ToBoolean(terminal.Value)));

                case TokenType.String: return(new TomlString(root, terminal.Value.Unescape(terminal)));

                case TokenType.LiteralString: return(new TomlString(root, terminal.Value, TomlString.TypeOfString.Literal));

                case TokenType.MultilineLiteralString: return(new TomlString(root, terminal.Value, TomlString.TypeOfString.MultilineLiteral));

                case TokenType.MultilineString: return(new TomlString(root, terminal.Value, TomlString.TypeOfString.Multiline));

                case TokenType.Float: return(TomlFloat.FromTerminal(root, terminal));

                case TokenType.OffsetDateTime: return(TomlOffsetDateTime.Parse(root, terminal.Value));

                case TokenType.LocalTime: return(TomlLocalTime.Parse(root, terminal.Value));

                case TokenType.Duration: return(TomlDuration.Parse(root, terminal.Value));

                case TokenType.LocalDate: return(TomlLocalDate.Parse(root, terminal.Value));

                case TokenType.LocalDateTime: return(TomlLocalDateTime.Parse(root, terminal.Value));

                default: throw new NotSupportedException();
                }

                string Cleanup(string s, int sub)
                => s.Substring(sub).Replace("_", string.Empty);
            }

            TomlObject CreateArrayOrTableArray(ArrayNode array)
            {
                var values = CreateValues(array.GetValues()).ToList();
                var tables = values.OfType <TomlTable>().ToList();

                if (tables.Count > 0 && tables.Count == values.Count)
                {
                    var ta = new TomlTableArray(root, tables);
                    ta.AddComments(array);
                    return(ta);
                }
                else if (tables.Count == 0)
                {
                    var arr = new TomlArray(root, values.Cast <TomlValue>().ToArray());
                    arr.AddComments(array);
                    return(arr);
                }
                else
                {
                    throw new InvalidOperationException("Array is a mixture of a value array and a TOML table array.");
                }

                IEnumerable <TomlObject> CreateValues(IEnumerable <ValueNode> nodes)
                {
                    var linked       = nodes.Select(n => Tuple.Create(n, ToTomlValue(root, n))).ToList();
                    var expectedType = linked.DistinctBy(n => n.Item2.GetType()).FirstOrDefault();
                    var wrongType    = linked.DistinctBy(n => n.Item2.GetType()).Skip(1).FirstOrDefault();

                    if (wrongType != null)
                    {
                        string msg = $"Expected array value of type '{expectedType.Item2.ReadableTypeName}' " +
                                     $"but value of type '{wrongType.Item2.ReadableTypeName}' was found.'";

                        throw ParseException.MessageForNode(wrongType.Item1, msg);
                    }

                    return(linked.Select(l => l.Item2));
                }
            }

            TomlTable CreateInlineTable(InlineTableNode it)
            {
                TomlTable table = new TomlTable(root, TomlTable.TableTypes.Inline);

                table.AddComments(it);

                System.Collections.Generic.IEnumerable <KeyValueExpressionNode> expressions = it.GetExpressions();

                foreach (KeyValueExpressionNode e in expressions)
                {
                    table.AddRow(e.Key.SyntaxNode().ExpressionKey(), ToTomlValue(root, e.Value.SyntaxNode()));
                }

                return(table);
            }
        }