From d4ad1bd99a6a9a2689755f5cba5c3717843dd224 Mon Sep 17 00:00:00 2001 From: Justin Aquadro Date: Sun, 16 Feb 2014 02:56:27 -0500 Subject: [PATCH] Restructuring project to support separate command-line utility --- NBTExplorer.Installer/Product.wxs | 11 +- NBTExplorer.sln | 34 + NBTExplorer/Model/ListTagContainer.cs | 38 - NBTExplorer/Model/TagDoubleDataNode.cs | 16 - NBTExplorer/Model/TagFloatDataNode.cs | 16 - NBTExplorer/Model/TagIntDataNode.cs | 16 - NBTExplorer/Model/TagLongDataNode.cs | 16 - NBTExplorer/Model/TagShortDataNode.cs | 16 - NBTExplorer/NBTExplorer.csproj | 40 +- NBTExplorer/Program.cs | 2 +- NBTExplorer/Properties/AssemblyInfo.cs | 6 +- NBTExplorer/Windows/About.Designer.cs | 2 +- NBTExplorer/Windows/FormHandlers.cs | 1 + NBTExplorer/Windows/MainForm.cs | 1 + .../Windows/NbtClipboardControllerWin.cs | 1 + .../CompoundTagContainer.cs | 0 .../Model => NBTModel}/CubicRegionDataNode.cs | 1 + .../Model => NBTModel}/CubicRegionFile.cs | 0 {NBTExplorer/Model => NBTModel}/DataNode.cs | 0 .../Model => NBTModel}/DataNodeCollection.cs | 1 + .../Model => NBTModel}/DirectoryDataNode.cs | 0 .../Model => NBTModel}/FileTypeRegistry.cs | 0 .../Interop}/FormRegistry.cs | 2 +- .../Interop}/NbtClipboardController.cs | 2 +- .../Interop}/NbtClipboardData.cs | 2 +- NBTModel/ListTagContainer.cs | 66 + NBTModel/NBTModel.csproj | 83 ++ .../Model => NBTModel}/NbtFileDataNode.cs | 1 + .../Model => NBTModel}/NodeCapabilities.cs | 0 NBTModel/Properties/AssemblyInfo.cs | 36 + .../Model => NBTModel}/RegionChunkDataNode.cs | 0 .../Model => NBTModel}/RegionFileDataNode.cs | 1 + .../Model => NBTModel}/Search/SearchRule.cs | 0 .../TagByteArrayDataNode.cs | 0 .../Model => NBTModel}/TagByteDataNode.cs | 12 + .../Model => NBTModel}/TagCompoundDataNode.cs | 1 + .../TagContainerInterface.cs | 1 + .../Model => NBTModel}/TagDataNode.cs | 9 + NBTModel/TagDoubleDataNode.cs | 33 + NBTModel/TagFloatDataNode.cs | 33 + .../Model => NBTModel}/TagIntArrayDataNode.cs | 0 NBTModel/TagIntDataNode.cs | 33 + {NBTExplorer/Model => NBTModel}/TagKey.cs | 0 .../Model => NBTModel}/TagListDataNode.cs | 23 +- NBTModel/TagLongDataNode.cs | 33 + NBTModel/TagShortDataNode.cs | 33 + .../Model => NBTModel}/TagStringDataNode.cs | 13 + .../Utility}/SnapshotList.cs | 2 +- NBTUtil/App.config | 6 + NBTUtil/ConsoleOptions.cs | 76 ++ NBTUtil/ConsoleRunner.cs | 181 +++ NBTUtil/NBTUtil.csproj | 81 ++ NBTUtil/NDesk/Options.cs | 1123 +++++++++++++++++ NBTUtil/Ops/ConsoleOperation.cs | 18 + NBTUtil/Ops/EditOperation.cs | 35 + NBTUtil/Ops/PrintOperation.cs | 27 + NBTUtil/Ops/PrintTreeOperation.cs | 36 + NBTUtil/Ops/SetListOperation.cs | 37 + NBTUtil/Program.cs | 15 + NBTUtil/Properties/AssemblyInfo.cs | 36 + NBTUtil/TypePrinter.cs | 40 + 61 files changed, 2186 insertions(+), 162 deletions(-) delete mode 100644 NBTExplorer/Model/ListTagContainer.cs delete mode 100644 NBTExplorer/Model/TagDoubleDataNode.cs delete mode 100644 NBTExplorer/Model/TagFloatDataNode.cs delete mode 100644 NBTExplorer/Model/TagIntDataNode.cs delete mode 100644 NBTExplorer/Model/TagLongDataNode.cs delete mode 100644 NBTExplorer/Model/TagShortDataNode.cs rename {NBTExplorer/Model => NBTModel}/CompoundTagContainer.cs (100%) rename {NBTExplorer/Model => NBTModel}/CubicRegionDataNode.cs (99%) rename {NBTExplorer/Model => NBTModel}/CubicRegionFile.cs (100%) rename {NBTExplorer/Model => NBTModel}/DataNode.cs (100%) rename {NBTExplorer/Model => NBTModel}/DataNodeCollection.cs (99%) rename {NBTExplorer/Model => NBTModel}/DirectoryDataNode.cs (100%) rename {NBTExplorer/Model => NBTModel}/FileTypeRegistry.cs (100%) rename {NBTExplorer => NBTModel/Interop}/FormRegistry.cs (98%) rename {NBTExplorer => NBTModel/Interop}/NbtClipboardController.cs (97%) rename {NBTExplorer => NBTModel/Interop}/NbtClipboardData.cs (98%) create mode 100644 NBTModel/ListTagContainer.cs create mode 100644 NBTModel/NBTModel.csproj rename {NBTExplorer/Model => NBTModel}/NbtFileDataNode.cs (99%) rename {NBTExplorer/Model => NBTModel}/NodeCapabilities.cs (100%) create mode 100644 NBTModel/Properties/AssemblyInfo.cs rename {NBTExplorer/Model => NBTModel}/RegionChunkDataNode.cs (100%) rename {NBTExplorer/Model => NBTModel}/RegionFileDataNode.cs (99%) rename {NBTExplorer/Model => NBTModel}/Search/SearchRule.cs (100%) rename {NBTExplorer/Model => NBTModel}/TagByteArrayDataNode.cs (100%) rename {NBTExplorer/Model => NBTModel}/TagByteDataNode.cs (68%) rename {NBTExplorer/Model => NBTModel}/TagCompoundDataNode.cs (99%) rename {NBTExplorer/Model => NBTModel}/TagContainerInterface.cs (96%) rename {NBTExplorer/Model => NBTModel}/TagDataNode.cs (98%) create mode 100644 NBTModel/TagDoubleDataNode.cs create mode 100644 NBTModel/TagFloatDataNode.cs rename {NBTExplorer/Model => NBTModel}/TagIntArrayDataNode.cs (100%) create mode 100644 NBTModel/TagIntDataNode.cs rename {NBTExplorer/Model => NBTModel}/TagKey.cs (100%) rename {NBTExplorer/Model => NBTModel}/TagListDataNode.cs (84%) create mode 100644 NBTModel/TagLongDataNode.cs create mode 100644 NBTModel/TagShortDataNode.cs rename {NBTExplorer/Model => NBTModel}/TagStringDataNode.cs (62%) rename {NBTExplorer => NBTModel/Utility}/SnapshotList.cs (99%) create mode 100644 NBTUtil/App.config create mode 100644 NBTUtil/ConsoleOptions.cs create mode 100644 NBTUtil/ConsoleRunner.cs create mode 100644 NBTUtil/NBTUtil.csproj create mode 100644 NBTUtil/NDesk/Options.cs create mode 100644 NBTUtil/Ops/ConsoleOperation.cs create mode 100644 NBTUtil/Ops/EditOperation.cs create mode 100644 NBTUtil/Ops/PrintOperation.cs create mode 100644 NBTUtil/Ops/PrintTreeOperation.cs create mode 100644 NBTUtil/Ops/SetListOperation.cs create mode 100644 NBTUtil/Program.cs create mode 100644 NBTUtil/Properties/AssemblyInfo.cs create mode 100644 NBTUtil/TypePrinter.cs diff --git a/NBTExplorer.Installer/Product.wxs b/NBTExplorer.Installer/Product.wxs index 5bef182..00d8f95 100644 --- a/NBTExplorer.Installer/Product.wxs +++ b/NBTExplorer.Installer/Product.wxs @@ -3,7 +3,7 @@ @@ -81,6 +81,15 @@ + + + + + + + + + diff --git a/NBTExplorer.sln b/NBTExplorer.sln index 9aee4d1..fe14688 100644 --- a/NBTExplorer.sln +++ b/NBTExplorer.sln @@ -9,6 +9,10 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NBTExplorerMac", "NBTExplor EndProject Project("{930C7802-8A8C-48F9-8165-68863BCCD9DD}") = "NBTExplorer.Installer", "NBTExplorer.Installer\NBTExplorer.Installer.wixproj", "{A1566071-7CBB-4C54-AAE1-4B81B7715DB3}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NBTUtil", "NBTUtil\NBTUtil.csproj", "{BD90EED5-97B9-47D5-AFEA-C2C0D0E59FCF}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NBTModel", "NBTModel\NBTModel.csproj", "{20D7CBA3-5B6D-40B0-8D28-4C9A58E4FFBC}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution AppStore|Any CPU = AppStore|Any CPU @@ -71,6 +75,36 @@ Global {A1566071-7CBB-4C54-AAE1-4B81B7715DB3}.Release|Mixed Platforms.Build.0 = Release|x86 {A1566071-7CBB-4C54-AAE1-4B81B7715DB3}.Release|x86.ActiveCfg = Release|x86 {A1566071-7CBB-4C54-AAE1-4B81B7715DB3}.Release|x86.Build.0 = Release|x86 + {BD90EED5-97B9-47D5-AFEA-C2C0D0E59FCF}.AppStore|Any CPU.ActiveCfg = Release|Any CPU + {BD90EED5-97B9-47D5-AFEA-C2C0D0E59FCF}.AppStore|Any CPU.Build.0 = Release|Any CPU + {BD90EED5-97B9-47D5-AFEA-C2C0D0E59FCF}.AppStore|Mixed Platforms.ActiveCfg = Release|Any CPU + {BD90EED5-97B9-47D5-AFEA-C2C0D0E59FCF}.AppStore|Mixed Platforms.Build.0 = Release|Any CPU + {BD90EED5-97B9-47D5-AFEA-C2C0D0E59FCF}.AppStore|x86.ActiveCfg = Release|Any CPU + {BD90EED5-97B9-47D5-AFEA-C2C0D0E59FCF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {BD90EED5-97B9-47D5-AFEA-C2C0D0E59FCF}.Debug|Any CPU.Build.0 = Debug|Any CPU + {BD90EED5-97B9-47D5-AFEA-C2C0D0E59FCF}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {BD90EED5-97B9-47D5-AFEA-C2C0D0E59FCF}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {BD90EED5-97B9-47D5-AFEA-C2C0D0E59FCF}.Debug|x86.ActiveCfg = Debug|Any CPU + {BD90EED5-97B9-47D5-AFEA-C2C0D0E59FCF}.Release|Any CPU.ActiveCfg = Release|Any CPU + {BD90EED5-97B9-47D5-AFEA-C2C0D0E59FCF}.Release|Any CPU.Build.0 = Release|Any CPU + {BD90EED5-97B9-47D5-AFEA-C2C0D0E59FCF}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {BD90EED5-97B9-47D5-AFEA-C2C0D0E59FCF}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {BD90EED5-97B9-47D5-AFEA-C2C0D0E59FCF}.Release|x86.ActiveCfg = Release|Any CPU + {20D7CBA3-5B6D-40B0-8D28-4C9A58E4FFBC}.AppStore|Any CPU.ActiveCfg = Release|Any CPU + {20D7CBA3-5B6D-40B0-8D28-4C9A58E4FFBC}.AppStore|Any CPU.Build.0 = Release|Any CPU + {20D7CBA3-5B6D-40B0-8D28-4C9A58E4FFBC}.AppStore|Mixed Platforms.ActiveCfg = Release|Any CPU + {20D7CBA3-5B6D-40B0-8D28-4C9A58E4FFBC}.AppStore|Mixed Platforms.Build.0 = Release|Any CPU + {20D7CBA3-5B6D-40B0-8D28-4C9A58E4FFBC}.AppStore|x86.ActiveCfg = Release|Any CPU + {20D7CBA3-5B6D-40B0-8D28-4C9A58E4FFBC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {20D7CBA3-5B6D-40B0-8D28-4C9A58E4FFBC}.Debug|Any CPU.Build.0 = Debug|Any CPU + {20D7CBA3-5B6D-40B0-8D28-4C9A58E4FFBC}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {20D7CBA3-5B6D-40B0-8D28-4C9A58E4FFBC}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {20D7CBA3-5B6D-40B0-8D28-4C9A58E4FFBC}.Debug|x86.ActiveCfg = Debug|Any CPU + {20D7CBA3-5B6D-40B0-8D28-4C9A58E4FFBC}.Release|Any CPU.ActiveCfg = Release|Any CPU + {20D7CBA3-5B6D-40B0-8D28-4C9A58E4FFBC}.Release|Any CPU.Build.0 = Release|Any CPU + {20D7CBA3-5B6D-40B0-8D28-4C9A58E4FFBC}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {20D7CBA3-5B6D-40B0-8D28-4C9A58E4FFBC}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {20D7CBA3-5B6D-40B0-8D28-4C9A58E4FFBC}.Release|x86.ActiveCfg = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/NBTExplorer/Model/ListTagContainer.cs b/NBTExplorer/Model/ListTagContainer.cs deleted file mode 100644 index 1f4f3cd..0000000 --- a/NBTExplorer/Model/ListTagContainer.cs +++ /dev/null @@ -1,38 +0,0 @@ -using Substrate.Nbt; - -namespace NBTExplorer.Model -{ - public class ListTagContainer : IOrderedTagContainer - { - private TagNodeList _tag; - - public ListTagContainer (TagNodeList tag) - { - _tag = tag; - } - - public int TagCount - { - get { return _tag.Count; } - } - - public bool DeleteTag (TagNode tag) - { - return _tag.Remove(tag); - } - - public int GetTagIndex (TagNode tag) - { - return _tag.IndexOf(tag); - } - - public bool InsertTag (TagNode tag, int index) - { - if (index < 0 || index > _tag.Count) - return false; - - _tag.Insert(index, tag); - return true; - } - } -} diff --git a/NBTExplorer/Model/TagDoubleDataNode.cs b/NBTExplorer/Model/TagDoubleDataNode.cs deleted file mode 100644 index e1fd990..0000000 --- a/NBTExplorer/Model/TagDoubleDataNode.cs +++ /dev/null @@ -1,16 +0,0 @@ -using Substrate.Nbt; - -namespace NBTExplorer.Model -{ - public class TagDoubleDataNode : TagDataNode - { - public TagDoubleDataNode (TagNodeDouble tag) - : base(tag) - { } - - public override bool EditNode () - { - return EditScalarValue(Tag); - } - } -} diff --git a/NBTExplorer/Model/TagFloatDataNode.cs b/NBTExplorer/Model/TagFloatDataNode.cs deleted file mode 100644 index 30c8946..0000000 --- a/NBTExplorer/Model/TagFloatDataNode.cs +++ /dev/null @@ -1,16 +0,0 @@ -using Substrate.Nbt; - -namespace NBTExplorer.Model -{ - public class TagFloatDataNode : TagDataNode - { - public TagFloatDataNode (TagNodeFloat tag) - : base(tag) - { } - - public override bool EditNode () - { - return EditScalarValue(Tag); - } - } -} diff --git a/NBTExplorer/Model/TagIntDataNode.cs b/NBTExplorer/Model/TagIntDataNode.cs deleted file mode 100644 index 2cda6c3..0000000 --- a/NBTExplorer/Model/TagIntDataNode.cs +++ /dev/null @@ -1,16 +0,0 @@ -using Substrate.Nbt; - -namespace NBTExplorer.Model -{ - public class TagIntDataNode : TagDataNode - { - public TagIntDataNode (TagNodeInt tag) - : base(tag) - { } - - public override bool EditNode () - { - return EditScalarValue(Tag); - } - } -} diff --git a/NBTExplorer/Model/TagLongDataNode.cs b/NBTExplorer/Model/TagLongDataNode.cs deleted file mode 100644 index 3051802..0000000 --- a/NBTExplorer/Model/TagLongDataNode.cs +++ /dev/null @@ -1,16 +0,0 @@ -using Substrate.Nbt; - -namespace NBTExplorer.Model -{ - public class TagLongDataNode : TagDataNode - { - public TagLongDataNode (TagNodeLong tag) - : base(tag) - { } - - public override bool EditNode () - { - return EditScalarValue(Tag); - } - } -} diff --git a/NBTExplorer/Model/TagShortDataNode.cs b/NBTExplorer/Model/TagShortDataNode.cs deleted file mode 100644 index beff379..0000000 --- a/NBTExplorer/Model/TagShortDataNode.cs +++ /dev/null @@ -1,16 +0,0 @@ -using Substrate.Nbt; - -namespace NBTExplorer.Model -{ - public class TagShortDataNode : TagDataNode - { - public TagShortDataNode (TagNodeShort tag) - : base(tag) - { } - - public override bool EditNode () - { - return EditScalarValue(Tag); - } - } -} diff --git a/NBTExplorer/NBTExplorer.csproj b/NBTExplorer/NBTExplorer.csproj index 8a70f8b..c6f53e2 100644 --- a/NBTExplorer/NBTExplorer.csproj +++ b/NBTExplorer/NBTExplorer.csproj @@ -84,6 +84,9 @@ ;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules 4 + + + False @@ -98,12 +101,8 @@ - - - - Component @@ -174,32 +173,6 @@ EditHex.cs - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -208,7 +181,6 @@ Settings.settings - Component @@ -337,6 +309,12 @@ true + + + {20d7cba3-5b6d-40b0-8d28-4c9a58e4ffbc} + NBTModel + + + \ No newline at end of file diff --git a/NBTExplorer/Model/NbtFileDataNode.cs b/NBTModel/NbtFileDataNode.cs similarity index 99% rename from NBTExplorer/Model/NbtFileDataNode.cs rename to NBTModel/NbtFileDataNode.cs index e40f6d3..7df458c 100644 --- a/NBTExplorer/Model/NbtFileDataNode.cs +++ b/NBTModel/NbtFileDataNode.cs @@ -4,6 +4,7 @@ using Substrate.Nbt; using System.Collections.Generic; using System; +using NBTModel.Interop; namespace NBTExplorer.Model { diff --git a/NBTExplorer/Model/NodeCapabilities.cs b/NBTModel/NodeCapabilities.cs similarity index 100% rename from NBTExplorer/Model/NodeCapabilities.cs rename to NBTModel/NodeCapabilities.cs diff --git a/NBTModel/Properties/AssemblyInfo.cs b/NBTModel/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..9327da9 --- /dev/null +++ b/NBTModel/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("NBTModel")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("NBTModel")] +[assembly: AssemblyCopyright("Copyright © 2014")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("0dd78c98-e4af-4898-a0f5-4ea5675933c8")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/NBTExplorer/Model/RegionChunkDataNode.cs b/NBTModel/RegionChunkDataNode.cs similarity index 100% rename from NBTExplorer/Model/RegionChunkDataNode.cs rename to NBTModel/RegionChunkDataNode.cs diff --git a/NBTExplorer/Model/RegionFileDataNode.cs b/NBTModel/RegionFileDataNode.cs similarity index 99% rename from NBTExplorer/Model/RegionFileDataNode.cs rename to NBTModel/RegionFileDataNode.cs index 61ed548..719c790 100644 --- a/NBTExplorer/Model/RegionFileDataNode.cs +++ b/NBTModel/RegionFileDataNode.cs @@ -2,6 +2,7 @@ using System.Text.RegularExpressions; using Substrate.Core; using System.Collections.Generic; +using NBTModel.Interop; namespace NBTExplorer.Model { diff --git a/NBTExplorer/Model/Search/SearchRule.cs b/NBTModel/Search/SearchRule.cs similarity index 100% rename from NBTExplorer/Model/Search/SearchRule.cs rename to NBTModel/Search/SearchRule.cs diff --git a/NBTExplorer/Model/TagByteArrayDataNode.cs b/NBTModel/TagByteArrayDataNode.cs similarity index 100% rename from NBTExplorer/Model/TagByteArrayDataNode.cs rename to NBTModel/TagByteArrayDataNode.cs diff --git a/NBTExplorer/Model/TagByteDataNode.cs b/NBTModel/TagByteDataNode.cs similarity index 68% rename from NBTExplorer/Model/TagByteDataNode.cs rename to NBTModel/TagByteDataNode.cs index cfc803a..d2c6b45 100644 --- a/NBTExplorer/Model/TagByteDataNode.cs +++ b/NBTModel/TagByteDataNode.cs @@ -13,6 +13,18 @@ public TagByteDataNode (TagNodeByte tag) get { return base.Tag as TagNodeByte; } } + public override bool Parse (string value) + { + byte data; + if (!byte.TryParse(value, out data)) + return false; + + Tag.Data = data; + IsDataModified = true; + + return true; + } + public override bool EditNode () { return EditScalarValue(Tag); diff --git a/NBTExplorer/Model/TagCompoundDataNode.cs b/NBTModel/TagCompoundDataNode.cs similarity index 99% rename from NBTExplorer/Model/TagCompoundDataNode.cs rename to NBTModel/TagCompoundDataNode.cs index 0c1e40c..f5f045d 100644 --- a/NBTExplorer/Model/TagCompoundDataNode.cs +++ b/NBTModel/TagCompoundDataNode.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using NBTModel.Interop; using Substrate.Nbt; namespace NBTExplorer.Model diff --git a/NBTExplorer/Model/TagContainerInterface.cs b/NBTModel/TagContainerInterface.cs similarity index 96% rename from NBTExplorer/Model/TagContainerInterface.cs rename to NBTModel/TagContainerInterface.cs index 93c507d..1cc46a9 100644 --- a/NBTExplorer/Model/TagContainerInterface.cs +++ b/NBTModel/TagContainerInterface.cs @@ -36,5 +36,6 @@ public interface IOrderedTagContainer : ITagContainer { int GetTagIndex (TagNode tag); bool InsertTag (TagNode tag, int index); + bool AppendTag (TagNode tag); } } diff --git a/NBTExplorer/Model/TagDataNode.cs b/NBTModel/TagDataNode.cs similarity index 98% rename from NBTExplorer/Model/TagDataNode.cs rename to NBTModel/TagDataNode.cs index 2878e3f..0d79e3d 100644 --- a/NBTExplorer/Model/TagDataNode.cs +++ b/NBTModel/TagDataNode.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using NBTModel.Interop; using Substrate.Nbt; namespace NBTExplorer.Model @@ -44,6 +45,9 @@ public virtual bool DeleteTag (TagNode tag) return false; } + public virtual void Clear () + { } + #endregion protected override NodeCapabilities Capabilities @@ -155,6 +159,11 @@ protected set } } + public virtual bool Parse (string value) + { + return false; + } + protected override NodeCapabilities Capabilities { get diff --git a/NBTModel/TagDoubleDataNode.cs b/NBTModel/TagDoubleDataNode.cs new file mode 100644 index 0000000..3cd160b --- /dev/null +++ b/NBTModel/TagDoubleDataNode.cs @@ -0,0 +1,33 @@ +using Substrate.Nbt; + +namespace NBTExplorer.Model +{ + public class TagDoubleDataNode : TagDataNode + { + public TagDoubleDataNode (TagNodeDouble tag) + : base(tag) + { } + + protected new TagNodeDouble Tag + { + get { return base.Tag as TagNodeDouble; } + } + + public override bool Parse (string value) + { + double data; + if (!double.TryParse(value, out data)) + return false; + + Tag.Data = data; + IsDataModified = true; + + return true; + } + + public override bool EditNode () + { + return EditScalarValue(Tag); + } + } +} diff --git a/NBTModel/TagFloatDataNode.cs b/NBTModel/TagFloatDataNode.cs new file mode 100644 index 0000000..1351079 --- /dev/null +++ b/NBTModel/TagFloatDataNode.cs @@ -0,0 +1,33 @@ +using Substrate.Nbt; + +namespace NBTExplorer.Model +{ + public class TagFloatDataNode : TagDataNode + { + public TagFloatDataNode (TagNodeFloat tag) + : base(tag) + { } + + protected new TagNodeFloat Tag + { + get { return base.Tag as TagNodeFloat; } + } + + public override bool Parse (string value) + { + float data; + if (!float.TryParse(value, out data)) + return false; + + Tag.Data = data; + IsDataModified = true; + + return true; + } + + public override bool EditNode () + { + return EditScalarValue(Tag); + } + } +} diff --git a/NBTExplorer/Model/TagIntArrayDataNode.cs b/NBTModel/TagIntArrayDataNode.cs similarity index 100% rename from NBTExplorer/Model/TagIntArrayDataNode.cs rename to NBTModel/TagIntArrayDataNode.cs diff --git a/NBTModel/TagIntDataNode.cs b/NBTModel/TagIntDataNode.cs new file mode 100644 index 0000000..b0b1244 --- /dev/null +++ b/NBTModel/TagIntDataNode.cs @@ -0,0 +1,33 @@ +using Substrate.Nbt; + +namespace NBTExplorer.Model +{ + public class TagIntDataNode : TagDataNode + { + public TagIntDataNode (TagNodeInt tag) + : base(tag) + { } + + protected new TagNodeInt Tag + { + get { return base.Tag as TagNodeInt; } + } + + public override bool Parse (string value) + { + int data; + if (!int.TryParse(value, out data)) + return false; + + Tag.Data = data; + IsDataModified = true; + + return true; + } + + public override bool EditNode () + { + return EditScalarValue(Tag); + } + } +} diff --git a/NBTExplorer/Model/TagKey.cs b/NBTModel/TagKey.cs similarity index 100% rename from NBTExplorer/Model/TagKey.cs rename to NBTModel/TagKey.cs diff --git a/NBTExplorer/Model/TagListDataNode.cs b/NBTModel/TagListDataNode.cs similarity index 84% rename from NBTExplorer/Model/TagListDataNode.cs rename to NBTModel/TagListDataNode.cs index 63e2db2..0d6d4e4 100644 --- a/NBTExplorer/Model/TagListDataNode.cs +++ b/NBTModel/TagListDataNode.cs @@ -1,4 +1,5 @@ using System; +using NBTModel.Interop; using Substrate.Nbt; namespace NBTExplorer.Model @@ -10,10 +11,10 @@ public class TagListDataNode : TagDataNode.Container public TagListDataNode (TagNodeList tag) : base(tag) { - _container = new ListTagContainer(tag); + _container = new ListTagContainer(tag, res => IsDataModified = true); } - protected new TagNodeList Tag + public new TagNodeList Tag { get { return base.Tag as TagNodeList; } set { base.Tag = value; } @@ -99,8 +100,22 @@ public override bool DeleteTag (TagNode tag) return _container.DeleteTag(tag); } - private void AppendTag (TagNode tag) + public override void Clear () { + if (TagCount == 0) + return; + + Nodes.Clear(); + Tag.Clear(); + + IsDataModified = true; + } + + public bool AppendTag (TagNode tag) + { + if (tag == null || !CanCreateTag(tag.GetTagType())) + return false; + _container.InsertTag(tag, _container.TagCount); IsDataModified = true; @@ -109,6 +124,8 @@ private void AppendTag (TagNode tag) if (node != null) Nodes.Add(node); } + + return true; } } } diff --git a/NBTModel/TagLongDataNode.cs b/NBTModel/TagLongDataNode.cs new file mode 100644 index 0000000..a822409 --- /dev/null +++ b/NBTModel/TagLongDataNode.cs @@ -0,0 +1,33 @@ +using Substrate.Nbt; + +namespace NBTExplorer.Model +{ + public class TagLongDataNode : TagDataNode + { + public TagLongDataNode (TagNodeLong tag) + : base(tag) + { } + + protected new TagNodeLong Tag + { + get { return base.Tag as TagNodeLong; } + } + + public override bool Parse (string value) + { + long data; + if (!long.TryParse(value, out data)) + return false; + + Tag.Data = data; + IsDataModified = true; + + return true; + } + + public override bool EditNode () + { + return EditScalarValue(Tag); + } + } +} diff --git a/NBTModel/TagShortDataNode.cs b/NBTModel/TagShortDataNode.cs new file mode 100644 index 0000000..a162882 --- /dev/null +++ b/NBTModel/TagShortDataNode.cs @@ -0,0 +1,33 @@ +using Substrate.Nbt; + +namespace NBTExplorer.Model +{ + public class TagShortDataNode : TagDataNode + { + public TagShortDataNode (TagNodeShort tag) + : base(tag) + { } + + protected new TagNodeShort Tag + { + get { return base.Tag as TagNodeShort; } + } + + public override bool Parse (string value) + { + short data; + if (!short.TryParse(value, out data)) + return false; + + Tag.Data = data; + IsDataModified = true; + + return true; + } + + public override bool EditNode () + { + return EditScalarValue(Tag); + } + } +} diff --git a/NBTExplorer/Model/TagStringDataNode.cs b/NBTModel/TagStringDataNode.cs similarity index 62% rename from NBTExplorer/Model/TagStringDataNode.cs rename to NBTModel/TagStringDataNode.cs index 1624073..85f369b 100644 --- a/NBTExplorer/Model/TagStringDataNode.cs +++ b/NBTModel/TagStringDataNode.cs @@ -8,6 +8,19 @@ public TagStringDataNode (TagNodeString tag) : base(tag) { } + protected new TagNodeString Tag + { + get { return base.Tag as TagNodeString; } + } + + public override bool Parse (string value) + { + Tag.Data = value; + IsDataModified = true; + + return true; + } + public override bool EditNode () { return EditStringValue(Tag); diff --git a/NBTExplorer/SnapshotList.cs b/NBTModel/Utility/SnapshotList.cs similarity index 99% rename from NBTExplorer/SnapshotList.cs rename to NBTModel/Utility/SnapshotList.cs index 9736f06..4fc1c36 100644 --- a/NBTExplorer/SnapshotList.cs +++ b/NBTModel/Utility/SnapshotList.cs @@ -4,7 +4,7 @@ using System.Collections.ObjectModel; using System.Text; -namespace NBTExplorer +namespace NBTExplorer.Utility { public class SnapshotState : IDisposable { diff --git a/NBTUtil/App.config b/NBTUtil/App.config new file mode 100644 index 0000000..343984d --- /dev/null +++ b/NBTUtil/App.config @@ -0,0 +1,6 @@ + + + + + + diff --git a/NBTUtil/ConsoleOptions.cs b/NBTUtil/ConsoleOptions.cs new file mode 100644 index 0000000..8efdb9d --- /dev/null +++ b/NBTUtil/ConsoleOptions.cs @@ -0,0 +1,76 @@ +using System; +using System.Collections.Generic; +using System.Text; +using NDesk.Options; + +namespace NBTUtil +{ + public enum ConsoleCommand + { + None, + Print, + PrintTree, + SetValue, + SetList, + Help, + } + + class ConsoleOptions + { + private OptionSet _options; + private string _currentKey; + + //public string FilePath { get; private set; } + //public string TagPath { get; private set; } + public string Path { get; private set; } + + public ConsoleCommand Command { get; private set; } + public List Values { get; private set; } + public bool ShowTypes { get; private set; } + + public ConsoleOptions () + { + Command = ConsoleCommand.None; + Values = new List(); + + _options = new OptionSet() { + { "path=", "Path to NBT tag from current directory", v => Path = v }, + { "print", "Print the value(s) of a tag", v => Command = ConsoleCommand.Print }, + { "printtree", "Print the NBT tree rooted at a tag", v => Command = ConsoleCommand.PrintTree }, + { "types", "Show data types when printing tags", v => ShowTypes = true }, + { "setvalue=", "Set a single tag value", v => { + Command = ConsoleCommand.SetValue; + _currentKey = "setvalue"; + if (!string.IsNullOrEmpty(v)) + Values.Add(v); + }}, + { "setlist=", "Replace a list tag's contents with one or more values.", v => { + Command = ConsoleCommand.SetList; + _currentKey = "setlist"; + if (!string.IsNullOrEmpty(v)) + Values.Add(v); + }}, + { "help", "Print this help message", v => Command = ConsoleCommand.Help }, + { "<>", v => { + switch (_currentKey) { + case "setvalue": + case "setlist": + Values.Add(v); + break; + } + }}, + }; + } + + public void Parse (string[] args) + { + _options.Parse(args); + } + + public void PrintUsage () + { + Console.WriteLine("Program Options:"); + _options.WriteOptionDescriptions(Console.Out); + } + } +} diff --git a/NBTUtil/ConsoleRunner.cs b/NBTUtil/ConsoleRunner.cs new file mode 100644 index 0000000..183881a --- /dev/null +++ b/NBTUtil/ConsoleRunner.cs @@ -0,0 +1,181 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Runtime.InteropServices; +using System.Text; +using NBTExplorer.Model; +using NBTUtil.Ops; +using Substrate.Nbt; + +namespace NBTUtil +{ + class ConsoleRunner + { + private static readonly Dictionary _commandTable = new Dictionary() { + { ConsoleCommand.SetValue, new EditOperation() }, + { ConsoleCommand.SetList, new SetListOperation() }, + { ConsoleCommand.Print, new PrintOperation() }, + { ConsoleCommand.PrintTree, new PrintTreeOperation() }, + }; + + private ConsoleOptions _options; + + public ConsoleRunner () + { + _options = new ConsoleOptions(); + } + + public bool Run (string[] args) + { + _options.Parse(args); + + if (_options.Command == ConsoleCommand.Help) + return PrintHelp(); + + if (_options.Path == null) + return PrintUsage("Error: You must specify a path"); + if (!_commandTable.ContainsKey(_options.Command)) + return PrintUsage("Error: No command specified"); + + NbtPath path = new NbtPath(_options.Path); + DataNode targetNode = path.Open(); + + if (targetNode == null) + return PrintError("Error: Invalid path"); + + ConsoleOperation op = _commandTable[_options.Command]; + if (!op.OptionsValid(_options)) + return PrintError("Error: Invalid options specified for the given command"); + if (!op.CanProcess(targetNode)) + return PrintError("Error: The given command can't be applied to the given tag"); + if (!op.Process(targetNode, _options)) + return PrintError("Error: Problem encountered applying the given command"); + + path.RootNode.Save(); + + Console.WriteLine("The operation completed successfully"); + + return true; + } + + private DataNode OpenFile (string path) + { + DataNode node = null; + foreach (var item in FileTypeRegistry.RegisteredTypes) { + if (item.Value.NamePatternTest(path)) + node = item.Value.NodeCreate(path); + } + + return node; + } + + private DataNode ExpandDataNode (DataNode dataNode, string tagPath) + { + string[] pathParts = tagPath.Split('/'); + + DataNode curTag = dataNode; + curTag.Expand(); + + foreach (var part in pathParts) { + TagDataNode.Container container = curTag as TagDataNode.Container; + if (curTag == null) + throw new Exception("Invalid tag path"); + + DataNode childTag = null; + foreach (var child in curTag.Nodes) { + if (child.NodePathName == part) + childTag = child; + } + + if (childTag == null) + throw new Exception("Invalid tag path"); + + curTag.Expand(); + } + + return curTag; + } + + private bool PrintHelp () + { + Console.WriteLine("NBTUtil - Copyright 2014 Justin Aquadro"); + _options.PrintUsage(); + + return true; + } + + private bool PrintUsage (string error) + { + Console.WriteLine(error); + _options.PrintUsage(); + + return false; + } + + private bool PrintError (string error) + { + Console.WriteLine(error); + + return false; + } + } + + class NbtPath + { + private class PathPart + { + public string Name; + public DataNode Node; + } + + private List _pathParts = new List(); + + public NbtPath (string path) + { + Path = path; + + string[] parts = path.Split('/', '\\'); + foreach (var p in parts) { + _pathParts.Add(new PathPart() { + Name = p, + }); + } + } + + public string Path { get; private set; } + + public DataNode RootNode + { + get { return (_pathParts.Count == 0) ? null : _pathParts[0].Node; } + } + + public DataNode TargetNode + { + get { return (_pathParts.Count == 0) ? null : _pathParts[_pathParts.Count - 1].Node; } + } + + public DataNode Open () + { + DataNode dataNode = new DirectoryDataNode(Directory.GetCurrentDirectory()); + dataNode.Expand(); + + foreach (var part in _pathParts) { + DataNode match = null; + foreach (var child in dataNode.Nodes) { + if (child.NodePathName == part.Name) + match = child; + } + + if (match == null) + return null; + + part.Node = match; + + dataNode = match; + dataNode.Expand(); + } + + return dataNode; + } + } +} diff --git a/NBTUtil/NBTUtil.csproj b/NBTUtil/NBTUtil.csproj new file mode 100644 index 0000000..6c33f68 --- /dev/null +++ b/NBTUtil/NBTUtil.csproj @@ -0,0 +1,81 @@ + + + + + Debug + AnyCPU + {BD90EED5-97B9-47D5-AFEA-C2C0D0E59FCF} + Exe + Properties + NBTUtil + NBTUtil + v2.0 + 512 + + + + AnyCPU + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + AnyCPU + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + ..\References\Substrate.dll + + + + + + + + + + + + + + + + + + + + + + + + {20d7cba3-5b6d-40b0-8d28-4c9a58e4ffbc} + NBTModel + + + + + + + + + + + + + \ No newline at end of file diff --git a/NBTUtil/NDesk/Options.cs b/NBTUtil/NDesk/Options.cs new file mode 100644 index 0000000..317691e --- /dev/null +++ b/NBTUtil/NDesk/Options.cs @@ -0,0 +1,1123 @@ +// +// Options.cs +// +// Authors: +// Jonathan Pryor +// +// Copyright (C) 2008 Novell (http://www.novell.com) +// +// Permission is hereby granted, free of charge, to any person obtaining +// a copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to +// permit persons to whom the Software is furnished to do so, subject to +// the following conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +// + +// Compile With: +// gmcs -debug+ -r:System.Core Options.cs -o:NDesk.Options.dll +// gmcs -debug+ -d:LINQ -r:System.Core Options.cs -o:NDesk.Options.dll +// +// The LINQ version just changes the implementation of +// OptionSet.Parse(IEnumerable), and confers no semantic changes. + +// +// A Getopt::Long-inspired option parsing library for C#. +// +// NDesk.Options.OptionSet is built upon a key/value table, where the +// key is a option format string and the value is a delegate that is +// invoked when the format string is matched. +// +// Option format strings: +// Regex-like BNF Grammar: +// name: .+ +// type: [=:] +// sep: ( [^{}]+ | '{' .+ '}' )? +// aliases: ( name type sep ) ( '|' name type sep )* +// +// Each '|'-delimited name is an alias for the associated action. If the +// format string ends in a '=', it has a required value. If the format +// string ends in a ':', it has an optional value. If neither '=' or ':' +// is present, no value is supported. `=' or `:' need only be defined on one +// alias, but if they are provided on more than one they must be consistent. +// +// Each alias portion may also end with a "key/value separator", which is used +// to split option values if the option accepts > 1 value. If not specified, +// it defaults to '=' and ':'. If specified, it can be any character except +// '{' and '}' OR the *string* between '{' and '}'. If no separator should be +// used (i.e. the separate values should be distinct arguments), then "{}" +// should be used as the separator. +// +// Options are extracted either from the current option by looking for +// the option name followed by an '=' or ':', or is taken from the +// following option IFF: +// - The current option does not contain a '=' or a ':' +// - The current option requires a value (i.e. not a Option type of ':') +// +// The `name' used in the option format string does NOT include any leading +// option indicator, such as '-', '--', or '/'. All three of these are +// permitted/required on any named option. +// +// Option bundling is permitted so long as: +// - '-' is used to start the option group +// - all of the bundled options are a single character +// - at most one of the bundled options accepts a value, and the value +// provided starts from the next character to the end of the string. +// +// This allows specifying '-a -b -c' as '-abc', and specifying '-D name=value' +// as '-Dname=value'. +// +// Option processing is disabled by specifying "--". All options after "--" +// are returned by OptionSet.Parse() unchanged and unprocessed. +// +// Unprocessed options are returned from OptionSet.Parse(). +// +// Examples: +// int verbose = 0; +// OptionSet p = new OptionSet () +// .Add ("v", v => ++verbose) +// .Add ("name=|value=", v => Console.WriteLine (v)); +// p.Parse (new string[]{"-v", "--v", "/v", "-name=A", "/name", "B", "extra"}); +// +// The above would parse the argument string array, and would invoke the +// lambda expression three times, setting `verbose' to 3 when complete. +// It would also print out "A" and "B" to standard output. +// The returned array would contain the string "extra". +// +// C# 3.0 collection initializers are supported and encouraged: +// var p = new OptionSet () { +// { "h|?|help", v => ShowHelp () }, +// }; +// +// System.ComponentModel.TypeConverter is also supported, allowing the use of +// custom data types in the callback type; TypeConverter.ConvertFromString() +// is used to convert the value option to an instance of the specified +// type: +// +// var p = new OptionSet () { +// { "foo=", (Foo f) => Console.WriteLine (f.ToString ()) }, +// }; +// +// Random other tidbits: +// - Boolean options (those w/o '=' or ':' in the option format string) +// are explicitly enabled if they are followed with '+', and explicitly +// disabled if they are followed with '-': +// string a = null; +// var p = new OptionSet () { +// { "a", s => a = s }, +// }; +// p.Parse (new string[]{"-a"}); // sets v != null +// p.Parse (new string[]{"-a+"}); // sets v != null +// p.Parse (new string[]{"-a-"}); // sets v == null +// + +using System; +using System.Collections; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.ComponentModel; +using System.Globalization; +using System.IO; +using System.Runtime.Serialization; +using System.Security.Permissions; +using System.Text; +using System.Text.RegularExpressions; + +#if LINQ +using System.Linq; +#endif + +#if TEST +using NDesk.Options; +#endif + +namespace NDesk.Options +{ + + public class OptionValueCollection : IList, IList + { + List values = new List(); + OptionContext c; + + internal OptionValueCollection (OptionContext c) + { + this.c = c; + } + + #region ICollection + void ICollection.CopyTo (Array array, int index) { (values as ICollection).CopyTo(array, index); } + bool ICollection.IsSynchronized { get { return (values as ICollection).IsSynchronized; } } + object ICollection.SyncRoot { get { return (values as ICollection).SyncRoot; } } + #endregion + + #region ICollection + public void Add (string item) { values.Add(item); } + public void Clear () { values.Clear(); } + public bool Contains (string item) { return values.Contains(item); } + public void CopyTo (string[] array, int arrayIndex) { values.CopyTo(array, arrayIndex); } + public bool Remove (string item) { return values.Remove(item); } + public int Count { get { return values.Count; } } + public bool IsReadOnly { get { return false; } } + #endregion + + #region IEnumerable + IEnumerator IEnumerable.GetEnumerator () { return values.GetEnumerator(); } + #endregion + + #region IEnumerable + public IEnumerator GetEnumerator () { return values.GetEnumerator(); } + #endregion + + #region IList + int IList.Add (object value) { return (values as IList).Add(value); } + bool IList.Contains (object value) { return (values as IList).Contains(value); } + int IList.IndexOf (object value) { return (values as IList).IndexOf(value); } + void IList.Insert (int index, object value) { (values as IList).Insert(index, value); } + void IList.Remove (object value) { (values as IList).Remove(value); } + void IList.RemoveAt (int index) { (values as IList).RemoveAt(index); } + bool IList.IsFixedSize { get { return false; } } + object IList.this[int index] { get { return this[index]; } set { (values as IList)[index] = value; } } + #endregion + + #region IList + public int IndexOf (string item) { return values.IndexOf(item); } + public void Insert (int index, string item) { values.Insert(index, item); } + public void RemoveAt (int index) { values.RemoveAt(index); } + + private void AssertValid (int index) + { + if (c.Option == null) + throw new InvalidOperationException("OptionContext.Option is null."); + if (index >= c.Option.MaxValueCount) + throw new ArgumentOutOfRangeException("index"); + if (c.Option.OptionValueType == OptionValueType.Required && + index >= values.Count) + throw new OptionException(string.Format( + c.OptionSet.MessageLocalizer("Missing required value for option '{0}'."), c.OptionName), + c.OptionName); + } + + public string this[int index] + { + get + { + AssertValid(index); + return index >= values.Count ? null : values[index]; + } + set + { + values[index] = value; + } + } + #endregion + + public List ToList () + { + return new List(values); + } + + public string[] ToArray () + { + return values.ToArray(); + } + + public override string ToString () + { + return string.Join(", ", values.ToArray()); + } + } + + public class OptionContext + { + private Option option; + private string name; + private int index; + private OptionSet set; + private OptionValueCollection c; + + public OptionContext (OptionSet set) + { + this.set = set; + this.c = new OptionValueCollection(this); + } + + public Option Option + { + get { return option; } + set { option = value; } + } + + public string OptionName + { + get { return name; } + set { name = value; } + } + + public int OptionIndex + { + get { return index; } + set { index = value; } + } + + public OptionSet OptionSet + { + get { return set; } + } + + public OptionValueCollection OptionValues + { + get { return c; } + } + } + + public enum OptionValueType + { + None, + Optional, + Required, + } + + public abstract class Option + { + string prototype, description; + string[] names; + OptionValueType type; + int count; + string[] separators; + + protected Option (string prototype, string description) + : this(prototype, description, 1) + { + } + + protected Option (string prototype, string description, int maxValueCount) + { + if (prototype == null) + throw new ArgumentNullException("prototype"); + if (prototype.Length == 0) + throw new ArgumentException("Cannot be the empty string.", "prototype"); + if (maxValueCount < 0) + throw new ArgumentOutOfRangeException("maxValueCount"); + + this.prototype = prototype; + this.names = prototype.Split('|'); + this.description = description; + this.count = maxValueCount; + this.type = ParsePrototype(); + + if (this.count == 0 && type != OptionValueType.None) + throw new ArgumentException( + "Cannot provide maxValueCount of 0 for OptionValueType.Required or " + + "OptionValueType.Optional.", + "maxValueCount"); + if (this.type == OptionValueType.None && maxValueCount > 1) + throw new ArgumentException( + string.Format("Cannot provide maxValueCount of {0} for OptionValueType.None.", maxValueCount), + "maxValueCount"); + if (Array.IndexOf(names, "<>") >= 0 && + ((names.Length == 1 && this.type != OptionValueType.None) || + (names.Length > 1 && this.MaxValueCount > 1))) + throw new ArgumentException( + "The default option handler '<>' cannot require values.", + "prototype"); + + for (int i = 0; i < names.Length; i++) + names[i] = names[i].ToLower(); + } + + public string Prototype { get { return prototype; } } + public string Description { get { return description; } } + public OptionValueType OptionValueType { get { return type; } } + public int MaxValueCount { get { return count; } } + + public string[] GetNames () + { + return (string[])names.Clone(); + } + + public string[] GetValueSeparators () + { + if (separators == null) + return new string[0]; + return (string[])separators.Clone(); + } + + protected static T Parse (string value, OptionContext c) + { + TypeConverter conv = TypeDescriptor.GetConverter(typeof(T)); + T t = default(T); + try { + if (value != null) + t = (T)conv.ConvertFromString(value); + } + catch (Exception e) { + throw new OptionException( + string.Format( + c.OptionSet.MessageLocalizer("Could not convert string `{0}' to type {1} for option `{2}'."), + value, typeof(T).Name, c.OptionName), + c.OptionName, e); + } + return t; + } + + internal string[] Names { get { return names; } } + internal string[] ValueSeparators { get { return separators; } } + + static readonly char[] NameTerminator = new char[] { '=', ':' }; + + private OptionValueType ParsePrototype () + { + char type = '\0'; + List seps = new List(); + for (int i = 0; i < names.Length; ++i) { + string name = names[i]; + if (name.Length == 0) + throw new ArgumentException("Empty option names are not supported.", "prototype"); + + int end = name.IndexOfAny(NameTerminator); + if (end == -1) + continue; + names[i] = name.Substring(0, end); + if (type == '\0' || type == name[end]) + type = name[end]; + else + throw new ArgumentException( + string.Format("Conflicting option types: '{0}' vs. '{1}'.", type, name[end]), + "prototype"); + AddSeparators(name, end, seps); + } + + if (type == '\0') + return OptionValueType.None; + + if (count <= 1 && seps.Count != 0) + throw new ArgumentException( + string.Format("Cannot provide key/value separators for Options taking {0} value(s).", count), + "prototype"); + if (count > 1) { + if (seps.Count == 0) + this.separators = new string[] { ":", "=" }; + else if (seps.Count == 1 && seps[0].Length == 0) + this.separators = null; + else + this.separators = seps.ToArray(); + } + + return type == '=' ? OptionValueType.Required : OptionValueType.Optional; + } + + private static void AddSeparators (string name, int end, ICollection seps) + { + int start = -1; + for (int i = end + 1; i < name.Length; ++i) { + switch (name[i]) { + case '{': + if (start != -1) + throw new ArgumentException( + string.Format("Ill-formed name/value separator found in \"{0}\".", name), + "prototype"); + start = i + 1; + break; + case '}': + if (start == -1) + throw new ArgumentException( + string.Format("Ill-formed name/value separator found in \"{0}\".", name), + "prototype"); + seps.Add(name.Substring(start, i - start)); + start = -1; + break; + default: + if (start == -1) + seps.Add(name[i].ToString()); + break; + } + } + if (start != -1) + throw new ArgumentException( + string.Format("Ill-formed name/value separator found in \"{0}\".", name), + "prototype"); + } + + public void Invoke (OptionContext c) + { + OnParseComplete(c); + c.OptionName = null; + c.Option = null; + c.OptionValues.Clear(); + } + + protected abstract void OnParseComplete (OptionContext c); + + public override string ToString () + { + return Prototype; + } + } + + [Serializable] + public class OptionException : Exception + { + private string option; + + public OptionException () + { + } + + public OptionException (string message, string optionName) + : base(message) + { + this.option = optionName; + } + + public OptionException (string message, string optionName, Exception innerException) + : base(message, innerException) + { + this.option = optionName; + } + + protected OptionException (SerializationInfo info, StreamingContext context) + : base(info, context) + { + this.option = info.GetString("OptionName"); + } + + public string OptionName + { + get { return this.option; } + } + + [SecurityPermission(SecurityAction.LinkDemand, SerializationFormatter = true)] + public override void GetObjectData (SerializationInfo info, StreamingContext context) + { + base.GetObjectData(info, context); + info.AddValue("OptionName", option); + } + } + + public delegate void OptionAction (TKey key, TValue value); + + public class OptionSet : KeyedCollection + { + public OptionSet () + : this(delegate(string f) { return f; }) + { + } + + public OptionSet (Converter localizer) + { + this.localizer = localizer; + } + + Converter localizer; + + public Converter MessageLocalizer + { + get { return localizer; } + } + + protected override string GetKeyForItem (Option item) + { + if (item == null) + throw new ArgumentNullException("option"); + if (item.Names != null && item.Names.Length > 0) + return item.Names[0]; + // This should never happen, as it's invalid for Option to be + // constructed w/o any names. + throw new InvalidOperationException("Option has no names!"); + } + + [Obsolete("Use KeyedCollection.this[string]")] + protected Option GetOptionForName (string option) + { + if (option == null) + throw new ArgumentNullException("option"); + try { + return base[option]; + } + catch (KeyNotFoundException) { + return null; + } + } + + protected override void InsertItem (int index, Option item) + { + base.InsertItem(index, item); + AddImpl(item); + } + + protected override void RemoveItem (int index) + { + base.RemoveItem(index); + Option p = Items[index]; + // KeyedCollection.RemoveItem() handles the 0th item + for (int i = 1; i < p.Names.Length; ++i) { + Dictionary.Remove(p.Names[i]); + } + } + + protected override void SetItem (int index, Option item) + { + base.SetItem(index, item); + RemoveItem(index); + AddImpl(item); + } + + private void AddImpl (Option option) + { + if (option == null) + throw new ArgumentNullException("option"); + List added = new List(option.Names.Length); + try { + // KeyedCollection.InsertItem/SetItem handle the 0th name. + for (int i = 1; i < option.Names.Length; ++i) { + Dictionary.Add(option.Names[i], option); + added.Add(option.Names[i]); + } + } + catch (Exception) { + foreach (string name in added) + Dictionary.Remove(name); + throw; + } + } + + public new OptionSet Add (Option option) + { + base.Add(option); + return this; + } + + sealed class ActionOption : Option + { + Action action; + + public ActionOption (string prototype, string description, int count, Action action) + : base(prototype, description, count) + { + if (action == null) + throw new ArgumentNullException("action"); + this.action = action; + } + + protected override void OnParseComplete (OptionContext c) + { + action(c.OptionValues); + } + } + + public OptionSet Add (string prototype, Action action) + { + return Add(prototype, null, action); + } + + public OptionSet Add (string prototype, string description, Action action) + { + if (action == null) + throw new ArgumentNullException("action"); + Option p = new ActionOption(prototype, description, 1, + delegate(OptionValueCollection v) { action(v[0]); }); + base.Add(p); + return this; + } + + public OptionSet Add (string prototype, OptionAction action) + { + return Add(prototype, null, action); + } + + public OptionSet Add (string prototype, string description, OptionAction action) + { + if (action == null) + throw new ArgumentNullException("action"); + Option p = new ActionOption(prototype, description, 2, + delegate(OptionValueCollection v) { action(v[0], v[1]); }); + base.Add(p); + return this; + } + + sealed class ActionOption : Option + { + Action action; + + public ActionOption (string prototype, string description, Action action) + : base(prototype, description, 1) + { + if (action == null) + throw new ArgumentNullException("action"); + this.action = action; + } + + protected override void OnParseComplete (OptionContext c) + { + action(Parse(c.OptionValues[0], c)); + } + } + + sealed class ActionOption : Option + { + OptionAction action; + + public ActionOption (string prototype, string description, OptionAction action) + : base(prototype, description, 2) + { + if (action == null) + throw new ArgumentNullException("action"); + this.action = action; + } + + protected override void OnParseComplete (OptionContext c) + { + action( + Parse(c.OptionValues[0], c), + Parse(c.OptionValues[1], c)); + } + } + + public OptionSet Add (string prototype, Action action) + { + return Add(prototype, null, action); + } + + public OptionSet Add (string prototype, string description, Action action) + { + return Add(new ActionOption(prototype, description, action)); + } + + public OptionSet Add (string prototype, OptionAction action) + { + return Add(prototype, null, action); + } + + public OptionSet Add (string prototype, string description, OptionAction action) + { + return Add(new ActionOption(prototype, description, action)); + } + + protected virtual OptionContext CreateOptionContext () + { + return new OptionContext(this); + } + +#if LINQ + public List Parse (IEnumerable arguments) + { + bool process = true; + OptionContext c = CreateOptionContext (); + c.OptionIndex = -1; + var def = GetOptionForName ("<>"); + var unprocessed = + from argument in arguments + where ++c.OptionIndex >= 0 && (process || def != null) + ? process + ? argument == "--" + ? (process = false) + : !Parse (argument, c) + ? def != null + ? Unprocessed (null, def, c, argument) + : true + : false + : def != null + ? Unprocessed (null, def, c, argument) + : true + : true + select argument; + List r = unprocessed.ToList (); + if (c.Option != null) + c.Option.Invoke (c); + return r; + } +#else + public List Parse (IEnumerable arguments) + { + OptionContext c = CreateOptionContext(); + c.OptionIndex = -1; + bool process = true; + List unprocessed = new List(); + Option def = Contains("<>") ? this["<>"] : null; + foreach (string argument in arguments) { + ++c.OptionIndex; + if (argument == "--") { + process = false; + continue; + } + if (!process) { + Unprocessed(unprocessed, def, c, argument); + continue; + } + if (!Parse(argument, c)) + Unprocessed(unprocessed, def, c, argument); + } + if (c.Option != null) + c.Option.Invoke(c); + return unprocessed; + } +#endif + + private static bool Unprocessed (ICollection extra, Option def, OptionContext c, string argument) + { + if (def == null) { + extra.Add(argument); + return false; + } + c.OptionValues.Add(argument); + c.Option = def; + c.Option.Invoke(c); + return false; + } + + private readonly Regex ValueOption = new Regex( + @"^(?--|-|/)(?[^:=]+)((?[:=])(?.*))?$"); + + protected bool GetOptionParts (string argument, out string flag, out string name, out string sep, out string value) + { + if (argument == null) + throw new ArgumentNullException("argument"); + + flag = name = sep = value = null; + Match m = ValueOption.Match(argument); + if (!m.Success) { + return false; + } + flag = m.Groups["flag"].Value; + name = m.Groups["name"].Value; + if (m.Groups["sep"].Success && m.Groups["value"].Success) { + sep = m.Groups["sep"].Value; + value = m.Groups["value"].Value; + } + return true; + } + + protected virtual bool Parse (string argument, OptionContext c) + { + if (c.Option != null) { + ParseValue(argument, c); + return true; + } + + string f, n, s, v; + if (!GetOptionParts(argument, out f, out n, out s, out v)) + return false; + + Option p; + if (Contains(n)) { + p = this[n]; + c.OptionName = f + n; + c.Option = p; + switch (p.OptionValueType) { + case OptionValueType.None: + c.OptionValues.Add(n); + c.Option.Invoke(c); + break; + case OptionValueType.Optional: + case OptionValueType.Required: + ParseValue(v, c); + break; + } + return true; + } + // no match; is it a bool option? + if (ParseBool(argument, n, c)) + return true; + // is it a bundled option? + if (ParseBundledValue(f, string.Concat(n + s + v), c)) + return true; + + return false; + } + + private void ParseValue (string option, OptionContext c) + { + if (option != null) + foreach (string o in c.Option.ValueSeparators != null + ? option.Split(c.Option.ValueSeparators, StringSplitOptions.None) + : new string[] { option }) { + c.OptionValues.Add(o); + } + if (c.OptionValues.Count == c.Option.MaxValueCount || + c.Option.OptionValueType == OptionValueType.Optional) + c.Option.Invoke(c); + else if (c.OptionValues.Count > c.Option.MaxValueCount) { + throw new OptionException(localizer(string.Format( + "Error: Found {0} option values when expecting {1}.", + c.OptionValues.Count, c.Option.MaxValueCount)), + c.OptionName); + } + } + + private bool ParseBool (string option, string n, OptionContext c) + { + Option p; + string rn; + if (n.Length >= 1 && (n[n.Length - 1] == '+' || n[n.Length - 1] == '-') && + Contains((rn = n.Substring(0, n.Length - 1)))) { + p = this[rn]; + string v = n[n.Length - 1] == '+' ? option : null; + c.OptionName = option; + c.Option = p; + c.OptionValues.Add(v); + p.Invoke(c); + return true; + } + return false; + } + + private bool ParseBundledValue (string f, string n, OptionContext c) + { + if (f != "-") + return false; + for (int i = 0; i < n.Length; ++i) { + Option p; + string opt = f + n[i].ToString(); + string rn = n[i].ToString(); + if (!Contains(rn)) { + if (i == 0) + return false; + throw new OptionException(string.Format(localizer( + "Cannot bundle unregistered option '{0}'."), opt), opt); + } + p = this[rn]; + switch (p.OptionValueType) { + case OptionValueType.None: + Invoke(c, opt, n, p); + break; + case OptionValueType.Optional: + case OptionValueType.Required: { + string v = n.Substring(i + 1); + c.Option = p; + c.OptionName = opt; + ParseValue(v.Length != 0 ? v : null, c); + return true; + } + default: + throw new InvalidOperationException("Unknown OptionValueType: " + p.OptionValueType); + } + } + return true; + } + + private static void Invoke (OptionContext c, string name, string value, Option option) + { + c.OptionName = name; + c.Option = option; + c.OptionValues.Add(value); + option.Invoke(c); + } + + private const int OptionWidth = 29; + + public void WriteOptionDescriptions (TextWriter o) + { + foreach (Option p in this) { + int written = 0; + if (!WriteOptionPrototype(o, p, ref written)) + continue; + + if (written < OptionWidth) + o.Write(new string(' ', OptionWidth - written)); + else { + o.WriteLine(); + o.Write(new string(' ', OptionWidth)); + } + + List lines = GetLines(localizer(GetDescription(p.Description))); + o.WriteLine(lines[0]); + string prefix = new string(' ', OptionWidth + 2); + for (int i = 1; i < lines.Count; ++i) { + o.Write(prefix); + o.WriteLine(lines[i]); + } + } + } + + bool WriteOptionPrototype (TextWriter o, Option p, ref int written) + { + string[] names = p.Names; + + int i = GetNextOptionIndex(names, 0); + if (i == names.Length) + return false; + + if (names[i].Length == 1) { + Write(o, ref written, " -"); + Write(o, ref written, names[0]); + } + else { + Write(o, ref written, " --"); + Write(o, ref written, names[0]); + } + + for (i = GetNextOptionIndex(names, i + 1); + i < names.Length; i = GetNextOptionIndex(names, i + 1)) { + Write(o, ref written, ", "); + Write(o, ref written, names[i].Length == 1 ? "-" : "--"); + Write(o, ref written, names[i]); + } + + if (p.OptionValueType == OptionValueType.Optional || + p.OptionValueType == OptionValueType.Required) { + if (p.OptionValueType == OptionValueType.Optional) { + Write(o, ref written, localizer("[")); + } + Write(o, ref written, localizer("=" + GetArgumentName(0, p.MaxValueCount, p.Description))); + string sep = p.ValueSeparators != null && p.ValueSeparators.Length > 0 + ? p.ValueSeparators[0] + : " "; + for (int c = 1; c < p.MaxValueCount; ++c) { + Write(o, ref written, localizer(sep + GetArgumentName(c, p.MaxValueCount, p.Description))); + } + if (p.OptionValueType == OptionValueType.Optional) { + Write(o, ref written, localizer("]")); + } + } + return true; + } + + static int GetNextOptionIndex (string[] names, int i) + { + while (i < names.Length && names[i] == "<>") { + ++i; + } + return i; + } + + static void Write (TextWriter o, ref int n, string s) + { + n += s.Length; + o.Write(s); + } + + private static string GetArgumentName (int index, int maxIndex, string description) + { + if (description == null) + return maxIndex == 1 ? "VALUE" : "VALUE" + (index + 1); + string[] nameStart; + if (maxIndex == 1) + nameStart = new string[] { "{0:", "{" }; + else + nameStart = new string[] { "{" + index + ":" }; + for (int i = 0; i < nameStart.Length; ++i) { + int start, j = 0; + do { + start = description.IndexOf(nameStart[i], j); + } while (start >= 0 && j != 0 ? description[j++ - 1] == '{' : false); + if (start == -1) + continue; + int end = description.IndexOf("}", start); + if (end == -1) + continue; + return description.Substring(start + nameStart[i].Length, end - start - nameStart[i].Length); + } + return maxIndex == 1 ? "VALUE" : "VALUE" + (index + 1); + } + + private static string GetDescription (string description) + { + if (description == null) + return string.Empty; + StringBuilder sb = new StringBuilder(description.Length); + int start = -1; + for (int i = 0; i < description.Length; ++i) { + switch (description[i]) { + case '{': + if (i == start) { + sb.Append('{'); + start = -1; + } + else if (start < 0) + start = i + 1; + break; + case '}': + if (start < 0) { + if ((i + 1) == description.Length || description[i + 1] != '}') + throw new InvalidOperationException("Invalid option description: " + description); + ++i; + sb.Append("}"); + } + else { + sb.Append(description.Substring(start, i - start)); + start = -1; + } + break; + case ':': + if (start < 0) + goto default; + start = i + 1; + break; + default: + if (start < 0) + sb.Append(description[i]); + break; + } + } + return sb.ToString(); + } + + private static List GetLines (string description) + { + List lines = new List(); + if (string.IsNullOrEmpty(description)) { + lines.Add(string.Empty); + return lines; + } + int length = 80 - OptionWidth - 2; + int start = 0, end; + do { + end = GetLineEnd(start, length, description); + bool cont = false; + if (end < description.Length) { + char c = description[end]; + if (c == '-' || (char.IsWhiteSpace(c) && c != '\n')) + ++end; + else if (c != '\n') { + cont = true; + --end; + } + } + lines.Add(description.Substring(start, end - start)); + if (cont) { + lines[lines.Count - 1] += "-"; + } + start = end; + if (start < description.Length && description[start] == '\n') + ++start; + } while (end < description.Length); + return lines; + } + + private static int GetLineEnd (int start, int length, string description) + { + int end = Math.Min(start + length, description.Length); + int sep = -1; + for (int i = start; i < end; ++i) { + switch (description[i]) { + case ' ': + case '\t': + case '\v': + case '-': + case ',': + case '.': + case ';': + sep = i; + break; + case '\n': + return i; + } + } + if (sep == -1 || end == description.Length) + return end; + return sep; + } + } +} diff --git a/NBTUtil/Ops/ConsoleOperation.cs b/NBTUtil/Ops/ConsoleOperation.cs new file mode 100644 index 0000000..49589f1 --- /dev/null +++ b/NBTUtil/Ops/ConsoleOperation.cs @@ -0,0 +1,18 @@ +using System; +using System.Collections.Generic; +using System.Text; +using NBTExplorer.Model; + +namespace NBTUtil.Ops +{ + abstract class ConsoleOperation + { + public virtual bool OptionsValid (ConsoleOptions options) + { + return true; + } + + public abstract bool CanProcess (DataNode dataNode); + public abstract bool Process (DataNode dataNode, ConsoleOptions options); + } +} diff --git a/NBTUtil/Ops/EditOperation.cs b/NBTUtil/Ops/EditOperation.cs new file mode 100644 index 0000000..4db4a93 --- /dev/null +++ b/NBTUtil/Ops/EditOperation.cs @@ -0,0 +1,35 @@ +using System; +using System.Collections.Generic; +using System.Text; +using NBTExplorer.Model; + +namespace NBTUtil.Ops +{ + class EditOperation : ConsoleOperation + { + public override bool OptionsValid (ConsoleOptions options) + { + if (options.Values.Count == 0) + return false; + return true; + } + + public override bool CanProcess (DataNode dataNode) + { + if (!(dataNode is TagDataNode) || !dataNode.CanEditNode) + return false; + if (dataNode is TagByteArrayDataNode || dataNode is TagIntArrayDataNode) + return false; + + return true; + } + + public override bool Process (DataNode dataNode, ConsoleOptions options) + { + string value = options.Values[0]; + + TagDataNode tagDataNode = dataNode as TagDataNode; + return tagDataNode.Parse(value); + } + } +} diff --git a/NBTUtil/Ops/PrintOperation.cs b/NBTUtil/Ops/PrintOperation.cs new file mode 100644 index 0000000..f089459 --- /dev/null +++ b/NBTUtil/Ops/PrintOperation.cs @@ -0,0 +1,27 @@ +using System; +using System.Collections.Generic; +using System.Text; +using NBTExplorer.Model; + +namespace NBTUtil.Ops +{ + class PrintOperation : ConsoleOperation + { + public override bool CanProcess (DataNode dataNode) + { + return true; + } + + public override bool Process (DataNode dataNode, ConsoleOptions options) + { + Console.WriteLine(TypePrinter.Print(dataNode, options.ShowTypes)); + + if (dataNode.IsContainerType) { + foreach (var child in dataNode.Nodes) + Console.WriteLine(" | " + TypePrinter.Print(child, options.ShowTypes)); + } + + return true; + } + } +} diff --git a/NBTUtil/Ops/PrintTreeOperation.cs b/NBTUtil/Ops/PrintTreeOperation.cs new file mode 100644 index 0000000..897efca --- /dev/null +++ b/NBTUtil/Ops/PrintTreeOperation.cs @@ -0,0 +1,36 @@ +using System; +using System.Collections.Generic; +using System.Text; +using NBTExplorer.Model; + +namespace NBTUtil.Ops +{ + class PrintTreeOperation : ConsoleOperation + { + public override bool CanProcess (DataNode dataNode) + { + return true; + } + + public override bool Process (DataNode dataNode, ConsoleOptions options) + { + PrintSubTree(dataNode, options, "", true); + + return true; + } + + private void PrintSubTree (DataNode dataNode, ConsoleOptions options, string indent, bool last) + { + Console.WriteLine(indent + " + " + TypePrinter.Print(dataNode, options.ShowTypes)); + + indent += last ? " " : " |"; + int cnt = 0; + + dataNode.Expand(); + foreach (DataNode child in dataNode.Nodes) { + cnt++; + PrintSubTree(child, options, indent, cnt == dataNode.Nodes.Count); + } + } + } +} diff --git a/NBTUtil/Ops/SetListOperation.cs b/NBTUtil/Ops/SetListOperation.cs new file mode 100644 index 0000000..6e8ddac --- /dev/null +++ b/NBTUtil/Ops/SetListOperation.cs @@ -0,0 +1,37 @@ +using System; +using System.Collections.Generic; +using System.Text; +using NBTExplorer.Model; +using Substrate.Nbt; + +namespace NBTUtil.Ops +{ + class SetListOperation : ConsoleOperation + { + public override bool CanProcess (DataNode dataNode) + { + if (!(dataNode is TagListDataNode)) + return false; + + return true; + } + + public override bool Process (DataNode dataNode, ConsoleOptions options) + { + TagListDataNode listNode = dataNode as TagListDataNode; + + listNode.Clear(); + foreach (string value in options.Values) { + TagNode tag = TagDataNode.DefaultTag(listNode.Tag.ValueType); + TagDataNode tagData = TagDataNode.CreateFromTag(tag); + if (!tagData.Parse(value)) + return false; + + if (!listNode.AppendTag(tagData.Tag)) + return false; + } + + return true; + } + } +} diff --git a/NBTUtil/Program.cs b/NBTUtil/Program.cs new file mode 100644 index 0000000..efa70cb --- /dev/null +++ b/NBTUtil/Program.cs @@ -0,0 +1,15 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace NBTUtil +{ + class Program + { + static void Main (string[] args) + { + ConsoleRunner runner = new ConsoleRunner(); + runner.Run(args); + } + } +} diff --git a/NBTUtil/Properties/AssemblyInfo.cs b/NBTUtil/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..135fef8 --- /dev/null +++ b/NBTUtil/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("NBTUtil")] +[assembly: AssemblyDescription("A command-line utility to inspect and modify NBT data.")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("NBTUtil")] +[assembly: AssemblyCopyright("Copyright © Justin Aquadro 2014")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("14c36789-324a-4cbf-8cb4-1f2bd711a631")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/NBTUtil/TypePrinter.cs b/NBTUtil/TypePrinter.cs new file mode 100644 index 0000000..0f1f50d --- /dev/null +++ b/NBTUtil/TypePrinter.cs @@ -0,0 +1,40 @@ +using System; +using System.Collections.Generic; +using System.Text; +using NBTExplorer.Model; + +namespace NBTUtil +{ + static class TypePrinter + { + private static Dictionary _key = new Dictionary() { + { typeof(TagByteDataNode), "b" }, + { typeof(TagShortDataNode), "s" }, + { typeof(TagIntDataNode), "i" }, + { typeof(TagLongDataNode), "l" }, + { typeof(TagFloatDataNode), "f" }, + { typeof(TagDoubleDataNode), "d" }, + { typeof(TagStringDataNode), "T" }, + { typeof(TagByteArrayDataNode), "a" }, + { typeof(TagIntArrayDataNode), "A" }, + { typeof(TagListDataNode), "L" }, + { typeof(TagCompoundDataNode), "C" }, + { typeof(NbtFileDataNode), "N" }, + { typeof(RegionFileDataNode), "R" }, + { typeof(RegionChunkDataNode), "r" }, + { typeof(CubicRegionDataNode), "R" }, + { typeof(DirectoryDataNode), "/" }, + }; + + public static string Print (DataNode node, bool showType) + { + if (!_key.ContainsKey(node.GetType())) + return ""; + + if (showType) + return "<" + _key[node.GetType()] + "> " + node.NodeDisplay; + else + return node.NodeDisplay; + } + } +}