Merge branch 'v0.7-alpha' into danish-translation

Conflicts: src/api/api.cpp src/api/api.h src/backend/globals.cpp src/backend/globals.h src/backend/helpers.cpp src/backend/helpers.h src/gui/main.cpp src/installer.nsi
2026-07-27 14:16:01 -07:00 · 2014-08-26 16:14:55 +02:00
parent 9b5392183c a7fc173b9b
commit 6acdd0e562
97 changed files with 14074 additions and 65975 deletions
@@ -1,53 +1,86 @@
 # Settings passed on the command line:
 #
-# PROJECT_LIBS_DIR = the directory which all external libraries may be referenced from.
 # PROJECT_ARCH = the build architecture
-# PROJECT_LINK = whether to build a static or dynamic library.
+# LIBESPM_ROOT = the path to the root of the libespm source.

 ##############################
 # General Settings
 ##############################

 cmake_minimum_required (VERSION 2.8.9)
-project (boss)
+project (LOOT)

-set (BOSS_SRC   "${CMAKE_SOURCE_DIR}/src/backend/metadata.cpp"
+option(BUILD_SHARED_LIBS "Build a shared library" OFF)
+option(PROJECT_STATIC_RUNTIME "Build with static runtime libs (/MT)" ON)
+
+IF (NOT DEFINED PROJECT_ARCH)
+    set (PROJECT_ARCH "32")
+ENDIF ()
+
+IF (NOT DEFINED ALPHANUM_ROOT)
+    set (ALPHANUM_ROOT "../../alphanum")
+ENDIF ()
+
+IF (NOT DEFINED LIBESPM_ROOT)
+    set (LIBESPM_ROOT "../../libespm")
+ENDIF ()
+
+IF (NOT DEFINED LIBGIT2_ROOT)
+    set (LIBGIT2_ROOT "../../libgit2")
+ENDIF ()
+
+IF (NOT DEFINED LIBLOADORDER_ROOT)
+    set (LIBLOADORDER_ROOT "../../libloadorder")
+ENDIF ()
+
+IF (NOT DEFINED YAMLCPP_ROOT)
+    set (YAMLCPP_ROOT "../../yaml-cpp")
+ENDIF ()
+
+IF (NOT DEFINED CEF_ROOT)
+    set (CEF_ROOT "../../cef")
+ENDIF ()
+
+set (Boost_USE_STATIC_LIBS ON)
+set (Boost_USE_MULTITHREADED ON)
+set (Boost_USE_STATIC_RUNTIME PROJECT_STATIC_RUNTIME)
+
+set (LOOT_SRC   "${CMAKE_SOURCE_DIR}/src/backend/metadata.cpp"
                "${CMAKE_SOURCE_DIR}/src/backend/game.cpp"
                "${CMAKE_SOURCE_DIR}/src/backend/helpers.cpp"
-                "${CMAKE_SOURCE_DIR}/src/backend/network.cpp"
                "${CMAKE_SOURCE_DIR}/src/backend/globals.cpp"
-                "${CMAKE_SOURCE_DIR}/src/backend/graph.cpp"
-                "${PROJECT_LIBS_DIR}/pugixml/src/pugixml.cpp")
+                "${CMAKE_SOURCE_DIR}/src/backend/generators.cpp"
+                "${CMAKE_SOURCE_DIR}/src/backend/graph.cpp")

-set (BOSS_GUI_SRC ${BOSS_SRC}
-                  "${CMAKE_SOURCE_DIR}/src/gui/ids.cpp"
-                  "${CMAKE_SOURCE_DIR}/src/gui/main.cpp"
-                  "${CMAKE_SOURCE_DIR}/src/gui/settings.cpp"
-                  "${CMAKE_SOURCE_DIR}/src/gui/editor.cpp"
-                  "${CMAKE_SOURCE_DIR}/src/gui/viewer.cpp"
-                  "${CMAKE_SOURCE_DIR}/src/gui/misc.cpp"
+set (LOOT_GUI_SRC ${LOOT_SRC}
+                  # Code the API doesn't need.
+                  "${CMAKE_SOURCE_DIR}/src/backend/git.cpp"
+                  # Actual GUI code.
+                  "${CMAKE_SOURCE_DIR}/src/gui/main_win.cpp"
+                  "${CMAKE_SOURCE_DIR}/src/gui/handler.cpp"
+                  "${CMAKE_SOURCE_DIR}/src/gui/app.cpp"
                  "${CMAKE_SOURCE_DIR}/src/resource.rc")

-set (BOSS_API_SRC ${BOSS_SRC}
+set (LOOT_API_SRC ${LOOT_SRC}
                  "${CMAKE_SOURCE_DIR}/src/api/api.cpp")

+find_package(Boost REQUIRED COMPONENTS log log_setup locale thread chrono date_time filesystem system regex iostreams)
+
 # Include source and library directories.
 include_directories ("${CMAKE_SOURCE_DIR}/src"
-                     "${PROJECT_LIBS_DIR}/alphanum"
-                     "${PROJECT_LIBS_DIR}/boost"
-                     "${PROJECT_LIBS_DIR}/yaml-cpp/include"
-                     "${PROJECT_LIBS_DIR}/libloadorder/src"
-                     "${PROJECT_LIBS_DIR}/libespm"
-                     "${PROJECT_LIBS_DIR}/zlib"
-                     "${PROJECT_LIBS_DIR}/pugixml/src"
-                     "${PROJECT_LIBS_DIR}/libgit2/include"
-                     "${PROJECT_LIBS_DIR}/wxWidgets/include")
+                     ${ALPHANUM_ROOT}
+                     "${YAMLCPP_ROOT}/include"
+                     "${LIBLOADORDER_ROOT}/src"
+                     "${LIBGIT2_ROOT}/include"
+                     ${CEF_ROOT}
+                     ${LIBESPM_ROOT}
+                     ${Boost_INCLUDE_DIRS})

-link_directories ("${PROJECT_LIBS_DIR}/libloadorder/build"
-                  "${PROJECT_LIBS_DIR}/zlib/build"
-                  "${PROJECT_LIBS_DIR}/libgit2/build"
-                  "${PROJECT_LIBS_DIR}/yaml-cpp/build"
-                  "${PROJECT_LIBS_DIR}/boost/stage-${PROJECT_ARCH}/lib")
+link_directories ("${LIBLOADORDER_ROOT}/build"
+                  "${LIBGIT2_ROOT}/build"
+                  "${YAMLCPP_ROOT}/build"
+                  "${CEF_ROOT}/Release"
+                  "${CEF_ROOT}/out/Release/lib")


 ##############################
@@ -57,24 +90,21 @@ link_directories ("${PROJECT_LIBS_DIR}/libloadorder/build"
 # Settings when compiling for Windows. Since it's a Windows-only app this is always true, but useful to check for copy/paste into other projects.
 IF (CMAKE_SYSTEM_NAME MATCHES "Windows")
    add_definitions (-DUNICODE -D_UNICODE -D__WXMSW__ -DNDEBUG -DLIBLO_STATIC -DWIN32 -D_WINDOWS)
-    IF (${PROJECT_LINK} MATCHES "STATIC")
-        add_definitions (-DBOSS_STATIC)
+    IF (BUILD_SHARED_LIBS)
+        add_definitions (-DLOOT_EXPORT)
    ELSE ()
-        add_definitions (-DBOSS_EXPORT)
+        add_definitions (-DLOOT_STATIC)
    ENDIF ()
 ENDIF ()

 # MinGW settings.
 IF (MINGW)
-    include_directories("${PROJECT_LIBS_DIR}/wxWidgets/lib/wx/include/${COMPILER_PREFIX}-msw-unicode-static-3.0")
-    link_directories("${PROJECT_LIBS_DIR}/openssl"
-                     "${PROJECT_LIBS_DIR}/wxWidgets/lib")
    set (CMAKE_C_FLAGS  "-m${PROJECT_ARCH} -O3")
    set (CMAKE_CXX_FLAGS "-m${PROJECT_ARCH} -O3")
    set (CMAKE_EXE_LINKER_FLAGS "-static-libstdc++ -static-libgcc -Wl,--subsystem,windows")
    set (CMAKE_SHARED_LINKER_FLAGS "-static-libstdc++ -static-libgcc -Wl,--subsystem,windows")
    set (CMAKE_MODULE_LINKER_FLAGS "-static-libstdc++ -static-libgcc -Wl,--subsystem,windows")
-    set (BOSS_LIBS ${BOSS_LIBS}
+    set (LOOT_LIBS ${LOOT_LIBS}
                   yaml-cpp
                   boost_log_setup
                   boost_log
@@ -86,52 +116,44 @@ IF (MINGW)
                   boost_system
                   boost_regex
                   version
-                   git2
-                   zlibstatic
                   loadorder${PROJECT_ARCH}
                   ssl
                   crypto
                   ws2_32)
-    set (BOSS_GUI_LIBS ${BOSS_LIBS}
-                       wx_mswu_webview-3.0-${COMPILER_PREFIX}
-                       wx_mswu_core-3.0-${COMPILER_PREFIX}
-                       wx_baseu-3.0-${COMPILER_PREFIX}
-                       wx_mswu_adv-3.0-${COMPILER_PREFIX}
-                       wxpng-3.0-${COMPILER_PREFIX}
-                       wxzlib-3.0-${COMPILER_PREFIX}
+    set (LOOT_GUI_LIBS ${LOOT_LIBS}
+                       git2
+                       cef_sandbox
+                       libcef
+                       libcef_dll_wrapper
+                       rpcrt4
+                       shlwapi
                       comctl32)
 ELSEIF (MSVC)
-    IF (MSVC_VERSION EQUAL 1800) 
-        set (CMAKE_GENERATOR_TOOLSET "v120_xp" CACHE STRING "Platform Toolset" FORCE)
+
+    # Force static C++ runtime linkage.
+    IF (PROJECT_STATIC_RUNTIME)
+        FOREACH(flag
+            CMAKE_C_FLAGS_RELEASE CMAKE_C_FLAGS_RELWITHDEBINFO
+            CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_DEBUG_INIT
+            CMAKE_CXX_FLAGS_RELEASE  CMAKE_CXX_FLAGS_RELWITHDEBINFO
+            CMAKE_CXX_FLAGS_DEBUG  CMAKE_CXX_FLAGS_DEBUG_INIT)
+            STRING(REPLACE "/MD"  "/MT" "${flag}" "${${flag}}")
+            SET("${flag}" "${${flag}} /EHsc")
+        ENDFOREACH()
    ENDIF ()
-    include_directories("${PROJECT_LIBS_DIR}/wxWidgets/lib/vc_lib/mswu")
-    link_directories("${PROJECT_LIBS_DIR}/wxWidgets/lib/vc_lib")
-	set (CMAKE_CXX_FLAGS "/EHsc")
-    set (CMAKE_EXE_LINKER_FLAGS "/SUBSYSTEM:WINDOWS")
-    set (BOOST_SUFFIX "-vc120-mt-1_55")
-    set (BOSS_LIBS ${BOSS_LIBS}
-                   libyaml-cppmd
-                   libboost_log_setup${BOOST_SUFFIX}
-                   libboost_log${BOOST_SUFFIX}
-                   libboost_locale${BOOST_SUFFIX}
-                   libboost_thread${BOOST_SUFFIX}
-                   libboost_chrono${BOOST_SUFFIX}
-                   libboost_date_time${BOOST_SUFFIX}
-                   libboost_filesystem${BOOST_SUFFIX}
-                   libboost_system${BOOST_SUFFIX}
-                   libboost_regex${BOOST_SUFFIX}
+
+    set (CMAKE_EXE_LINKER_FLAGS "/SUBSYSTEM:WINDOWS /LARGEADDRESSAWARE")
+    set (LOOT_LIBS libyaml-cppmt
                   version
-                   git2
-                   zlibstatic
                   loadorder${PROJECT_ARCH}
                   ws2_32)
-    set (BOSS_GUI_LIBS ${BOSS_LIBS}
-                       wxmsw30u_webview
-                       wxmsw30u_adv
-                       wxmsw30u_core
-                       wxbase30u
-                       wxpng
-                       wxzlib
+    set (LOOT_GUI_LIBS ${LOOT_LIBS}
+                       git2
+                       cef_sandbox
+                       libcef
+                       libcef_dll_wrapper
+                       rpcrt4
+                       shlwapi
                       comctl32)
 ENDIF ()

@@ -141,14 +163,25 @@ ENDIF ()
 ##############################

 # Build API.
-add_library           (boss${PROJECT_ARCH} ${PROJECT_LINK} ${BOSS_API_SRC})
-target_link_libraries (boss${PROJECT_ARCH} ${BOSS_LIBS})
+add_library           (loot${PROJECT_ARCH} ${LOOT_API_SRC})
+target_link_libraries (loot${PROJECT_ARCH} ${Boost_LIBRARIES} ${LOOT_LIBS})

 # Build application.
-add_executable        (BOSS ${BOSS_GUI_SRC})
-target_link_libraries (BOSS ${BOSS_GUI_LIBS})
+add_executable        (LOOT ${LOOT_GUI_SRC})
+target_link_libraries (LOOT ${Boost_LIBRARIES} ${LOOT_GUI_LIBS})

-# Build converter.
-add_executable        (masterlist-converter ${BOSS_SRC} "${CMAKE_SOURCE_DIR}/src/converter.cpp")
-target_link_libraries (masterlist-converter ${BOSS_LIBS})
+# Copy CEF DLLs.
+FOREACH(cef_dll d3dcompiler_43.dll d3dcompiler_46.dll libEGL.dll libGLESv2.dll libcef.dll)
+    add_custom_command(TARGET LOOT POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different
+            "${CMAKE_SOURCE_DIR}/${CEF_ROOT}/$<CONFIGURATION>/${cef_dll}"
+            $<TARGET_FILE_DIR:LOOT>)
+ENDFOREACH()

+# Copy CEF resources.
+FOREACH(cef_resource cef.pak cef_100_percent.pak cef_200_percent.pak devtools_resources.pak icudtl.dat)
+    add_custom_command(TARGET LOOT POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different
+            "${CMAKE_SOURCE_DIR}/${CEF_ROOT}/Resources/${cef_resource}"
+            $<TARGET_FILE_DIR:LOOT>)
+ENDFOREACH()
@@ -1,87 +1,43 @@
-# BOSSv3
+# LOOT

 ## Introduction

-BOSS is a plugin load order optimiser for TES IV: Oblivion, TES V: Skyrim, Fallout 3 and Fallout: New Vegas. It is designed to assist mod users in avoiding detrimental conflicts, by automatically calculating a load order that satisfies all plugin dependencies and maximises each plugin's impact on the user's game.
+LOOT is a plugin load order optimiser for TES IV: Oblivion, TES V: Skyrim, Fallout 3 and Fallout: New Vegas. It is designed to assist mod users in avoiding detrimental conflicts, by automatically calculating a load order that satisfies all plugin dependencies and maximises each plugin's impact on the user's game.

-BOSS also provides some load order error checking, including checks for requirements, incompatibilities and cyclic dependencies. In addition, it provides a large number of plugin-specific usage notes, bug wawrnings and Bash Tag suggestions.
+LOOT also provides some load order error checking, including checks for requirements, incompatibilities and cyclic dependencies. In addition, it provides a large number of plugin-specific usage notes, bug warnings and Bash Tag suggestions.

-Although BOSS is able to calculate the correct load order positions for the vast majority of mods without any user input, some plugins are designed to load at certain positions in a load order, and BOSS may be unable to determine this from the plugins themselves. As such, BOSS provides a mechanism for supplying additional plugin metadata so that it may sort them correctly.
+Although LOOT is able to calculate the correct load order positions for the vast majority of mods without any user input, some plugins are designed to load at certain positions in a load order, and LOOT may be unable to determine this from the plugins themselves. As such, LOOT provides a mechanism for supplying additional plugin metadata so that it may sort them correctly.

-BOSS is intended to make using mods easier, and mod users should still possess a working knowledge of mod load ordering. See the "Introduction To Load Orders" section of the BOSS readme for an overview.
+LOOT is intended to make using mods easier, and mod users should still possess a working knowledge of mod load ordering. See the "Introduction To Load Orders" section of the LOOT readme for an overview.


-## Downloading BOSS
+## Building LOOT

-At the moment, BOSSv3 is in beta testing, and so is not recommended for use unless for testing purposes. The load orders it produces should not be used in-game unless found to be valid by manual checking beforehand. Any releases can be found by clicking on the releases button above the coloured bar on the repository homepage.
-
-
-## About This Repository
-
-This repository holds the source code and documentation for BOSS v3. The masterlists for v3 are stored in separate repostories on [GitHub](https://github.com/boss-developers). The source code, documentation and masterlists for previous versions of BOSS are stored on [Google Code](http://code.google.com/p/better-oblivion-sorting-software/).
-
-
-## Building BOSS
-
-BOSS uses [CMake](http://cmake.org) v2.8.9 or later for cross-platform building support, as though it is a Windows application, development has taken place on Windows and Linux.
-
-BOSS requires the following libraries (version numbers used in latest development revision given):
+LOOT uses [CMake](http://cmake.org) to generate build files, and requires the following libraries (version numbers used in latest development revision given):

 * [Alphanum](http://www.davekoelle.com/files/alphanum.hpp)
-* [Boost](http://www.boost.org) v1.55.0.
+* [Boost](http://www.boost.org) v1.56.0
+* [Chromium Embedded Framework](https://code.google.com/p/chromiumembedded/) branch 2062
 * [Libespm](http://github.com/WrinklyNinja/libespm)
-* [Libgit2](https://github.com/libgit2) v0.20.0.
+* [Libgit2](http://libgit2.github.com/) v0.21.1
 * [Libloadorder](http://github.com/WrinklyNinja/libloadorder)
-* [OpenSSL](https://www.openssl.org) - only if HTTPS support in libgit2 is required using compilers other than MSVC.
-* [PugiXML](http://code.google.com/p/pugixml/) v1.2.
-* [wxWidgets](http://www.wxwidgets.org) v3.0.0.
-* [yaml-cpp](http://github.com/WrinklyNinja/yaml-cpp).
-* [zlib](http://zlib.net) v1.2.8.
+* [yaml-cpp](http://github.com/WrinklyNinja/yaml-cpp)

-BOSS expects all libraries' folders to be present alongside the BOSS repository folder that contains this readme, or otherwise installed such that the compiler and linker used can find them without suppling additional paths. All paths below are relative to the folder(s) containing the libraries and BOSS.
+Alphanum and Libespm do not require any additional setup. The rest of the libraries must be built separately. Instructions for building them and LOOT itself using MSVC or MinGW are given in [docs/BUILD.MSVC.md](docs/BUILD.MSVC.md) and [docs/BUILD.MinGW.md](docs/BUILD.MinGW.md) respectively.

-Alphanum, Libespm and PugiXML do not require any additional setup. The rest of the libraries must be built separately. Instructions for building them and BOSS itself using MSVC or MinGW are given in `docs/BUILD.MSVC.md` and `docs/BUILD.MinGW.md` respectively.
-
-
-## Using The Masterlist Converter
-
-The masterlist converter is a command line utility that takes two optional command line arguments:
-
-```
-masterlist-converter.exe [v2 masterlist input file] [v3 masterlist output file]
-```
-
-If only one argument is given, or if no arguments are given, the converter assumes it was called as
-
-```
-masterlist-converter.exe masterlist.txt masterlist.yaml
-```
-
-On encountering an error, it will print an error message to the console, and will not output a v3 masterlist.
-
-The converter does not perform a lossless conversion. The following do not get transferred into the new masterlist:
-
-* Silent comments. (Search regex: `^(/\*|//)`)
-* Plugin conditions. (Search regex: `^IF(NOT)?.+MOD:`)
-* Requirement messages containing plugin filenames. (Search regex: `REQ:.+(\.esp|\.esm)`)
-* Dirty message content. The ITM, UDR and Navmesh counts, along with CRCs and the dirty utility referenced are transferred, but any additional content, such as links to additional instructions, are lost. (Search regex: `DIRTY:`.)
-
-In addition, while other data is retained, it needs some manual adjustment, eg. translated messages need are converted as separate messages and should be placed into message content objects.
+Although LOOT uses a cross-platform build system and cross-platform libraries, it does rely on some Windows API functionality. Anyone wishing to port LOOT to other platforms will need to ensure equivalent functionality is implemented for their target platform. The Windows API code is wrapped in `#ifdef _WIN32` blocks so that it can be easily identified.

 ## Packaging Releases

-Installer and zip archive releases for the main BOSS application can be handled by running the scripts `installer.nsi` and `archive.py` in the `src` folder respectively. The installer script requires [NSIS 3](http://nsis.sourceforge.net/Main_Page) to be installed, while the archive script requires [Python](http://www.python.org/) to be installed.
+Installer and zip archive releases for the main LOOT application can be handled by running the scripts `installer.nsi` and `archive.py` in the `src` folder respectively. The installer script requires [Unicode NSIS](http://www.scratchpaper.com/), while the archive script requires [Python](http://www.python.org/).

-The installer and Python script both require the built BOSS.exe to be at `build\BOSS.exe`, and the installer also requires the MSVC 2013 Redistributable (x86) to be at `build\vcredist_x86.exe`.
+## Adding Translations

-## Adding Translations To BOSS
+If a translation for a new language is provided, here's what needs changing to make LOOT use that translation.

-If a translation for a new language is provided, here's what needs changing in the code to make BOSS use that translation.
-
-* Add constants for the language in `api.h` and `globals.h`.
-* In `helpers.cpp`, update `Language::Language(const std::string& nameOrISOCode)` and `Language::Construct(const unsigned int code).
-* In `helpers.h`, update `Language::Names()`.
-* In `main.cpp`, update `BossGUI::OnInit` to set the correct `wxLANGUAGE_`.
-* In `archive.py`, add the language folder to the inline list on line 68.
-* In `installer.nsi`, add entries for the language folder to the install and uninstall sections. If there's an installer translation, also add its string definitions beside all the other language string definitions, and insert its macro beside all the other language macros.
+* In [helpers.h](src/backend/helpers.h), add a constant for the language to the `Language` class, and update `Language::Names()`.
+* In [helpers.cpp](src/backend/helpers.cpp), update `Language::Language(const std::string& nameOrCode)` and `Language::Construct(const unsigned int code)`.
+* Add constants for the language in [api.h](src/api/api.h) and [api.cpp](src/api/api.cpp).
+* In [archive.py](src/archive.py), add the language folder to the inline list on line 68.
+* In [installer.nsi](src/installer.nsi), add entries for the language folder to the install and uninstall sections. If there's an installer translation, also add its string definitions beside all the other language string definitions, and insert its macro beside all the other language macros.
 * The readmes should be updated with a link to the translation in the repository in the main readme, and the language's code in the metadata syntax readme.
@@ -1,50 +1,67 @@
 # Build Instructions using Microsoft Visual C++

-These instructions were used to build BOSS using Microsoft Visual Studio Express 2013 for Desktop, though they should also apply to other versions of MSVC. BOSS's CMake configuration builds an executable that can be run on Windows XP, but this support has only been implemented for MSVC 2013 - other versions may require editing of BOSS's `CMakeLists.txt` file.
+These instructions were used to build LOOT using Microsoft Visual Studio 2012 and Microsoft Visual Studio Express 2013 for Desktop, though they should also apply to other versions of MSVC.

 #### Boost

 ```
 bootstrap.bat
-b2 toolset=msvc-12.0 threadapi=win32 link=static variant=release address-model=32 --with-log --with-date_time --with-thread --with-filesystem --with-locale --with-regex --with-system  --with-iostreams --stagedir=stage-32
+b2 toolset=msvc threadapi=win32 link=static runtime-link=static variant=release address-model=32 --with-log --with-date_time --with-thread --with-filesystem --with-program_options --with-locale --with-regex --with-system  --with-iostreams
 ```

-#### wxWidgets
+`link`, `runtime-link` and `address-model` can all be modified if shared linking or 64 bit builds are desired. LOOT uses statically-linked Boost libraries by default: to change this, edit [CMakeLists.txt](../CMakeLists.txt).

-Just build the solution provided by wxWidgets.
+#### Chromium Embedded Framework

-#### zlib
-
-1. Add `/safeseh` to both lines in `contrib\masmx86\bld_ml32.bat`. 
-2. Build the solution in `contrib\vstudio`.
-3. Copy `build\zconf.h` to `.\zconf.h`.
+Most of the required binaries are pre-built, but the libcef_dll_wrapper dynamic library must be built. Just open its project file and build it with the `Release` configuration.

 #### yaml-cpp

-1. Set CMake up so that it builds the binaries in the `build` subdirectory of the yaml-cpp folder.
-2. Define `BOOST_ROOT` to point to where the Boost folder is. 
-3. Configure CMake, then generate a build system for Visual Studio 12.
-4. Open the generated solution file, and build it.
+1. Configure CMake and generate a build system for Visual Studio by running:
+  ```
+  mkdir build
+  cd build
+  cmake.exe .. -G "Visual Studio 12" -DBOOST_ROOT={BOOST_ROOT} -DMSVC_SHARED_RT=OFF
+  ```
+  Adapt the commands as necessary for your particular setup.
+2. Open the generated solution file, and build it with `Release` configuration.

 #### Libloadorder

 Follow the instructions in libloadorder's README.md to build it as a static library.

+Example CMake keys: `-DCMAKE_RUNTIME_OUTPUT_DIRECTORY=build -DCMAKE_ARCHIVE_OUTPUT_DIRECTORY=build`
+
 #### Libgit2

-1. Set CMake up so that it builds the binaries in the `build` subdirectory of the libgit2 folder.
-2. Configure CMake.
-3. Undefine `BUILD_SHARED_LIBS`.
-4. Generate a build system for Visual Studio 12.
-5. Open the generated solution file, and build it.
+1. Configure CMake and generate a build system for Visual Studio by running:
+  ```
+  mkdir build
+  cd build
+  cmake.exe .. -G "Visual Studio 12" -DBUILD_SHARED_LIBS=OFF -DSTATIC_CRT=ON
+  ```
+  Adapt the commands as necessary for your particular setup.
+2. Open the generated solution file, and build it with `Release` configuration.

-You may need to make sure that the configuration properties for the Visual Studio project are set to use the multithreaded DLL runtime library (C/C++->Code Generation).
+#### LOOT

-#### BOSS
+LOOT uses the following CMake variables to set build parameters:

-1. Set CMake up so that it builds the binaries in the `build` subdirectory of the BOSS folder.
-2. Define `PROJECT_ARCH=32` or `PROJECT_ARCH=64` to build 32 or 64 bit executables respectively.
-3. Define `PROJECT_LINK=STATIC` to build a static API, or `PROJECT_LINK=SHARED` to build a DLL API.
-4. Define `PROEJCT_LIBS_DIR` to point to the folder holding all the required libraries' folders.
-5. Configure CMake, then generate a build system for Visual Studio 12.
-6. Open the generated solution file, and build it.
+Parameter | Values | Default |Description
+----------|--------|---------|-----------
+`BUILD_SHARED_LIBS` | `ON`, `OFF` | `OFF` | Whether or not to build a shared libloot.
+`PROJECT_STATIC_RUNTIME` | `ON`, `OFF` | `ON` | Whether to link the C++ runtime statically or not. This also affects the Boost libraries used.
+`PROJECT_ARCH` | `32`, `64` | `32` | Whether to build 32 or 64 bit LOOT binaries.
+`ALPHANUM_ROOT` | path | `../../alphanum` | Path to the folder containing `alphanum.hpp`.
+`CEF_ROOT` | path | `../../cef` | Path to the root of the Chromium Embedded Framework folder.
+`LIBESPM_ROOT` | path | `../../libespm` | Path to the root of the libespm repository folder.
+`LIBGIT2_ROOT` | path | `../../libgit2` | Path to the root of the libgit2 repository folder.
+`LIBLOADORDER_ROOT` | path | `../../libloadorder` | Path to the root of the libloadorder repository folder.
+`YAMLCPP_ROOT` | path | `../../yaml-cpp` | Path to the root of the yaml-cpp folder.
+
+The default paths given in the table above are relative to LOOT's `CMakeLists.txt`.
+
+1. Set CMake up so that it builds the binaries in the `build` subdirectory of the LOOT folder.
+2. Define any necessary parameters.
+3. Configure CMake, then generate a build system for Visual Studio 12.
+4. Open the generated solution file, and build it.
@@ -1,35 +1,23 @@
 # Build Instructions using MinGW

-These instructions were used to build BOSS using mingw-w64 on Ubuntu and Debian linux, though they should also apply to other similar environments.
+These instructions were used to build LOOT using mingw-w64 on Ubuntu and Debian linux, though they should also apply to other similar environments.

 #### Boost

 ```
 ./bootstrap.sh
 echo "using gcc : 4.6.3 : i686-w64-mingw32-g++ : <rc>i686-w64-mingw32-windres <archiver>i686-w64-mingw32-ar <ranlib>i686-w64-mingw32-ranlib ;" > tools/build/v2/user-config.jam
-./b2 toolset=gcc-4.6.3 target-os=windows threadapi=win32 link=static runtime-link=static variant=release address-model=32 cxxflags=-fPIC --with-log --with-date_time --with-thread --with-filesystem --with-locale --with-regex --with-system --with-iostreams --stagedir=stage-32
+./b2 toolset=gcc-4.6.3 target-os=windows threadapi=win32 link=static runtime-link=static variant=release address-model=32 cxxflags=-fPIC --with-log --with-date_time --with-thread --with-filesystem --with-program_options --with-locale --with-regex --with-system --with-iostreams
 ```

-#### wxWidgets
+#### Chromium Embedded Framework

-```
-./configure --host=i686-w64-mingw32 --disable-shared --enable-stl
-make
-```
-
-#### zlib
-
-```
-mkdir build && cd build
-cmake .. -DCMAKE_C_FLAGS=-m32 -DPROJECT_ARCH=32 -DCMAKE_TOOLCHAIN_FILE=../BOSSv3/mingw-toolchain.cmake
-make
-cp zconf.h ../zconf.h
-```
+Most of the required binaries are pre-built, but the libcef_dll_wrapper dynamic library must be built.

 #### yaml-cpp

 ```
-cmake . -DCMAKE_C_FLAGS=-m32 -DPROJECT_ARCH=32 -DCMAKE_TOOLCHAIN_FILE=../BOSSv3/mingw-toolchain.cmake -DBOOST_ROOT=../boost
+cmake . -DCMAKE_C_FLAGS=-m32 -DPROJECT_ARCH=32 -DCMAKE_TOOLCHAIN_FILE=../LOOT/mingw-toolchain.cmake -DBOOST_ROOT=../boost
 make
 ```

@@ -37,23 +25,15 @@ make

 Follow the instructions in libloadorder's README.md to build it as a static library.

-#### OpenSSL
-
-```
-./Configure --cross-compile-prefix=i686-w64-mingw32- mingw
-make
-```
-
 #### Libgit2

 ```
 mkdir build && cd build
-cmake .. -DBUILD_SHARED_LIBS=OFF -DOPENSSL_ROOT_DIR=../openssl -DCMAKE_C_FLAGS=-m32 -DPROJECT_ARCH=32 -DCMAKE_TOOLCHAIN_FILE=../BOSSv3/mingw-toolchain.cmake
+cmake .. -DBUILD_SHARED_LIBS=OFF -DOPENSSL_ROOT_DIR=../openssl -DCMAKE_C_FLAGS=-m32 -DPROJECT_ARCH=32 -DCMAKE_TOOLCHAIN_FILE=../LOOT/mingw-toolchain.cmake
 make
 ```
-If building with SSL support using OpenSSL, also pass ``.

-#### BOSS
+#### LOOT

 ```
 mkdir build && cd build
@@ -1,6 +1,6 @@
 <!DOCTYPE html>
 <meta charset="utf-8">
-<title>BOSS Metadata Syntax</title>
+<title>LOOT Metadata Syntax</title>
 <style>
    body {
        font:10pt/1.5 Helvetica,sans-serif;
@@ -45,30 +45,30 @@ h3{
    .warning {background:#fbb; border-color:#d00;}
    var {color:#8B4513;}
 </style>
-<!--  BOSS
+<!--  LOOT

-    A plugin load order optimiser for games that use the esp/esm plugin system.
+    A load order optimisation tool for Oblivion, Skyrim, Fallout 3 and Fallout: New Vegas.

    Copyright (C) 2012–2014    WrinklyNinja

-    This file is part of BOSS.
+    This file is part of LOOT.

-    BOSS is free software: you can redistribute
+    LOOT is free software: you can redistribute
    it and/or modify it under the terms of the GNU General Public License
    as published by the Free Software Foundation, either version 3 of
    the License, or (at your option) any later version.

-    BOSS is distributed in the hope that it will
+    LOOT is distributed in the hope that it will
    be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
-    along with BOSS.  If not, see
+    along with LOOT.  If not, see
    <http://www.gnu.org/licenses/>.
 -->

-<h1>BOSS Metadata Syntax</h1>
+<h1>LOOT Metadata Syntax</h1>

 <h2>Contents</h2>
 <ol>
@@ -83,7 +83,6 @@ h3{
        <li><a href="#structs-dirty">Dirty Info Data Structure</a>
        <li><a href="#structs-plugin">Plugin Data Structure</a>
    </ol>
-    <li><a href="#links">URL Hyperlinking</a>
    <li><a href="#cond">Condition Strings</a>
    <ol>
        <li><a href="#cond-function">Functions</a>
@@ -92,10 +91,11 @@ h3{
    </ol>
    <li><a href="#lang">Language Codes</a>
    <li><a href="#license">License</a>
+    <li><a href="#support">Feature Support</a>
 </ol>

 <h2 id="intro">Introduction</h2>
-<p>As of BOSS v3, the metadata syntax is what BOSS's masterlists and userlists are written in. If you know YAML, good news: the syntax is essentially just YAML 1.2. If you don't know YAML, then its <a href="https://en.wikipedia.org/wiki/YAML">Wikipedia page</a> is a good introduction. All you really need to know is:
+<p>The metadata syntax is what LOOT's masterlists and userlists are written in. If you know YAML, good news: the syntax is essentially just YAML 1.2. If you don't know YAML, then its <a href="https://en.wikipedia.org/wiki/YAML">Wikipedia page</a> is a good introduction. All you really need to know is:
 <ul>
    <li>How lists and associative arrays (key-value maps) are written.
    <li>That whitespace is important, and that only normal spaces (ie. no non-breaking spaces or tabs) count as such.
@@ -103,34 +103,34 @@ h3{
    <li>That YAML files must be written in a Unicode encoding.
    <li>That each key in a key-value map must only appear once per map object.
 </ul>
-<p>Some important points that are more specific to how BOSS uses YAML:
+<p>Some important points that are more specific to how LOOT uses YAML:
 <ul>
-    <li>BOSS's support for YAML syntax is incomplete. A list of known limitations can be found <a href="https://github.com/WrinklyNinja/yaml-cpp/issues?labels=bug&amp;state=open">here</a>. The only major missing piece is support for merge keys (<code>&lt;&lt;:</code>).
+    <li>LOOT's support for YAML syntax is incomplete. A list of known limitations can be found <a href="https://github.com/WrinklyNinja/yaml-cpp/issues?labels=bug&amp;state=open">here</a>. The only major missing piece is support for merge keys (<code>&lt;&lt;:</code>).
    <li>Strings are case-sensitive, apart from file paths, regular expressions and checksums.
 </ul>
-<p>Some properties of file paths as used by BOSS:
+<p>Some properties of file paths as used by LOOT:
 <ul>
    <li>They are evaluated as paths relative to the game's Data folder.
    <li>They cannot reference a path outside of the game's folder structure, ie. they cannot contain the substring <code>../../</code>.
-    <li>Regular expression file paths must be written in the <a href="http://www.boost.org/doc/libs/1_54_0/libs/regex/doc/html/boost_regex/syntax/perl_syntax.html">Perl</a> syntax.
-    <li>Only the filename of a regex file path may contain non-literal regex syntax, ie. if the filename part of the regex file path is removed, the remainder must be an exact folder path (though with the regex syntax special characters escaped). For example, given the regex file path <code>Meshes\\Resources(1|2)\\(upperclass)?table.nif</code>, BOSS will look for a file named <code>table.nif</code> or <code>upperclasstable.nif</code> in the <code>Meshes\Resources(1|2)</code> folder, rather than looking in the <code>Meshes\Resources1</code> and <code>Meshes\Resources2</code> folders.
+    <li>Regular expression file paths must be written in the <a href="http://www.cplusplus.com/reference/regex/ECMAScript/">EMCAScript</a> syntax.
+    <li>Only the filename of a regex file path may contain non-literal regex syntax, ie. if the filename part of the regex file path is removed, the remainder must be an exact folder path (though with the regex syntax special characters escaped). For example, given the regex file path <code>Meshes\\Resources(1|2)\\(upperclass)?table.nif</code>, LOOT will look for a file named <code>table.nif</code> or <code>upperclasstable.nif</code> in the <code>Meshes\Resources(1|2)</code> folder, rather than looking in the <code>Meshes\Resources1</code> and <code>Meshes\Resources2</code> folders.
 </ul>
-<p>Please test any changes you make before uploading them. One way of doing this is to run BOSS, another is to copy/paste what you've changed into <a href="http://nodeca.github.io/js-yaml/">here</a>, though it won't catch condition syntax errors and doesn't use the same parser as BOSS so may give different results.
+<p>Please test any changes you make before uploading them. One way of doing this is to run LOOT, another is to copy/paste what you've changed into <a href="http://nodeca.github.io/js-yaml/">here</a>, though it won't catch condition syntax errors and doesn't use the same parser as LOOT so may give different results.

 <h2 id="filestruct">Metadata File Contents</h2>
-<p>The root of a metadata file is a key-value map. BOSS will recognise the following keys, none of which are required:
+<p>The root of a metadata file is a key-value map. LOOT will recognise the following keys, none of which are required:
 <table>
    <thead><tr><th>Key Name<th>Value Type<th>Notes
    <tbody>
        <tr><td><code>globals</code><td>message list<td>A list of message data structures for messages that are displayed independently of any plugin.
        <tr><td><code>plugins</code><td>plugin list<td>A list of plugin data structures, holding all the plugin metadata within the file.
 </table>
-<p>Other keys may also be present, but are not processed by BOSS. The message and plugin data structures are detailed in the next section.
+<p>Other keys may also be present, but are not processed by LOOT. The message and plugin data structures are detailed in the next section.
 <p>An example metadata file:
 <code class="box">globals:
  - type: say
-    content: 'You are using the latest version of BOSS.'
-    condition: 'version("BOSS", "3.0.0.0", ==)'
+    content: 'You are using the latest version of LOOT.'
+    condition: 'version("LOOT", "0.5.0.0", ==)'
 plugins:
  - name: 'Armamentarium.esm'
    tag:
@@ -148,10 +148,10 @@ plugins:


 <h2 id="structs">Data Structures</h2>
-<p>BOSS expects metadata to be laid out using a certain set of data structures, described in this section.
+<p>LOOT expects metadata to be laid out using a certain set of data structures, described in this section.

 <h3 id="structs-tag">Tag Data Structure</h3>
-<p>BOSS metadata files can contain suggestions for the addition or removal of Bash Tags, and this is the structure used for them. It has two forms: the first is a simple string, and the second is a key-value map. All values in the map are strings.
+<p>LOOT metadata files can contain suggestions for the addition or removal of Bash Tags, and this is the structure used for them. It has two forms: the first is a simple string, and the second is a key-value map. All values in the map are strings.
 <p>The simple form:
 <code class="box"><var>tag</var></code>
 <p>where <code><var>tag</var></code> is the Bash Tag, preceded by a minus sign if it is suggested for removal.
@@ -179,7 +179,7 @@ condition: 'file("Mart''s Monster Mod for OOO.esm") or file("FCOM_Convergence.es
    <thead><tr><th>Key Name<th>Required<th>Notes
    <tbody>
        <tr><td><code>name</code><td>&#x2713;<td>An exact (ie. not regex) file path or name.
-        <tr><td><code>display</code><td>&#x2717;<td>A substitute string to be displayed instead of the file path in any generated messages, eg. the name of the mod the file belongs to. Double-quoted URLs will be hyperlinked in the BOSS report. See <a href="#links">URL Hyperlinking</a> for details.
+        <tr><td><code>display</code><td>&#x2717;<td>A substitute string to be displayed instead of the file path in any generated messages, eg. the name of the mod the file belongs to.
        <tr><td><code>condition</code><td>&#x2717;<td>A condition string that is evaluated to determine whether this file data should be used: if it evaluates to true, the data is used, otherwise it is ignored. See <a href="#cond">Condition Strings</a> for details.
 </table>

@@ -199,6 +199,7 @@ display: 'OBSE v18+'
        <tr><td><code>type</code><td>string<td>&#x2713;<td>The type string can be one of three keywords, see the table below for their semantics.
        <tr><td><code>content</code><td>string <i>or</i> localised content list<td>&#x2713;<td>Either simply a string, or a list of localised content data structures. If the latter, one of the structures must be for English.
        <tr><td><code>condition</code><td>string<td>&#x2717;<td>A condition string that is evaluated to determine whether the message should be displayed: if it evaluates to true, the message is displayed, otherwise it is not. See <a href="#cond">Condition Strings</a> for details.
+        <tr><td><code>subs</code><td>list of strings<td>&#x2717;<td>A list of strings to be substituted into the message content string. The content string must use numbered specifiers (<code>%1%</code>, <code>%2%</code>, etc.), where the numbers correspond to the position of the substitution string in this list to use, to denote where these strings are to be substituted.
 </table>

 <p>There are three message types:
@@ -213,27 +214,25 @@ display: 'OBSE v18+'
 <table>
    <thead><tr><th>Key Name<th>Required<th>Notes
    <tbody>
-        <tr><td><code>str</code><td>&#x2713;<td>The actual message content string. Double-quoted URLs will be hyperlinked in the BOSS report. See <a href="#links">URL Hyperlinking</a> for details.
-        <tr><td><code>lang</code><td>&#x2713;<td>The language that <code>str</code> is written in, given as a POSIX language code. The languages BOSS supports are given in <a href="#lang">Language Codes</a>.
+        <tr><td><code>str</code><td>&#x2713;<td>The actual message content string.
+        <tr><td><code>lang</code><td>&#x2713;<td>The language that <code>str</code> is written in, given as a POSIX language code. The languages LOOT supports are given in <a href="#lang">Language Codes</a>.
 </table>
+<p>LOOT supports formatting of messages using <a href="https://help.github.com/articles/github-flavored-markdown">GitHub Flavored Markdown</a>. Support is provided by the <a href="https://github.com/chjj/marked">Marked</a> library (v0.3.2). Strings that get substituted into messages, such as file display names and dirty info utility strings, also support the same formatting options.

-<p>BOSS handles messages and languages as follows:
+<p>LOOT handles messages and languages as follows:
 <ol>
    <li>If a message's <code>content</code> value is a string, the message will use the string as its content if displayed.
-    <li>If a message's <code>content</code> value is a list of localised content structures, then the first structure with a language that matches BOSS's current language will be used as the message's content if displayed. If there are no matches, then the first structure in English will be used.
+    <li>If a message's <code>content</code> value is a list of localised content structures, then the first structure with a language that matches LOOT's current language will be used as the message's content if displayed. If there are no matches, then the first structure in English will be used.
 </ol>

-
 <p>Examples (translations by Google):
 <code class="box">type: say
 condition: 'file("foo.esp")'
 content:
-  - lang: eng
+  - lang: en
    str: 'An example link: &lt;http://www.example.com&gt;'
-  - lang: rus
+  - lang: ru
    str: 'Это пример ссылки: &lt;http://www.example.com&gt;'
-  - lang: ger
-    str: 'Ein Beispiel-Link: &lt;http://www.example.com&gt;'
 </code>
 would be displayed as
 <blockquote>
@@ -247,10 +246,21 @@ would be displayed as
 <blockquote>
 отмечать: An alternative <a href="http://www.example.com">example link</a>, with no translations.
 </blockquote>
+In English,
+<code class="box">type: say
+content: 'A newer version of %1% [is available](%2%).
+subs:
+  - 'this plugin'
+  - 'http://www.example.com'
+</code>
+would be displayed as
+<blockquote>
+Note: A newer version of this plugin <a href="http://www.example.com">is available</a>.
+</blockquote>


 <h3 id="structs-location">Location Data Structure</h3>
-<p>This data structure is used to hold information on where a plugin is hosted online. It is not currently used by BOSS, but it was suggested that since the BOSS team receives a considerable number of plugin URLs, they should be recorded in a standard format, as there is no existing store of such information and it could prove useful in the future.
+<p>This data structure is used to hold information on where a plugin is hosted online. It is not currently used by LOOT, but it was suggested that since the LOOT team receives a considerable number of plugin URLs, they should be recorded in a standard format, as there is no existing store of such information and it could prove useful in the future.
 <p>The data structure has two forms: the first is a simple string, and the second is a key-value map. The first form should be used for a URL without any associated version data, such as when it is not clear which version is found there, or when it is the only known hosting location for the plugin and as such hosts all available versions. The second form should be used when version data can be associated with the URL, such as when the URL only hosts a subset of the available versions of the plugin.
 <p>The simple form:
 <code class="box"><var>URL</var></code>
@@ -275,8 +285,8 @@ ver:
 <table>
    <thead><tr><th>Key Name<th>Data Type<th>Required<th>Notes
    <tbody>
-        <tr><td><code>crc</code><td>hexadecimal integer<td>&#x2713;<td>The CRC checksum of the dirty plugin, before cleaning. BOSS displays the CRCs of installed plugins in its report. The 8-character CRC should be preceded by <code>0x</code> so that it is correctly interpreted.
-        <tr><td><code>util</code><td>string<td>&#x2713;<td>The utility that should be used to clean the plugin. This field supports <a href="#links">URL Hyperlinking</a>, and it is recommended that a URL to the game's cleaning guide is supplied.
+        <tr><td><code>crc</code><td>hexadecimal integer<td>&#x2713;<td>The CRC checksum of the dirty plugin, before cleaning. LOOT displays the CRCs of installed plugins in its report. The 8-character CRC should be preceded by <code>0x</code> so that it is correctly interpreted.
+        <tr><td><code>util</code><td>string<td>&#x2713;<td>The utility that should be used to clean the plugin.
        <tr><td><code>itm</code><td>integer<td>&#x2717;<td>The number of identical-to-master records reported for the dirty plugin. If the number is unknown, this field should not be supplied. If the number is known and zero, this field should be supplied.
        <tr><td><code>udr</code><td>integer<td>&#x2717;<td>The number of undeleted records reported for the dirty plugin. If the number is unknown, this field should not be supplied. If the number is known and zero, this field should be supplied.
        <tr><td><code>nav</code><td>integer<td>&#x2717;<td>The number of deleted navmeshes reported for the dirty plugin. If the number is unknown, this field should not be supplied. If the number is known and zero, this field should be supplied.
@@ -297,19 +307,25 @@ nav: 0
    <tbody>
        <tr><td><code>name</code><td>string<td>&#x2713;<td>Can be an exact plugin filename or a regular expression plugin filename. If the period that precedes the file extension has been escaped (eg. <code>\.esp</code>, <code>\.esm</code>), the string is treated as a regular expression, otherwise it is treated as an exact filename.
        <tr><td><code>enabled</code><td>boolean<td>&#x2717;<td>Enables or disables use of the plugin object. Used for user rules, but no reason to use it in the masterlist. If unspecified, defaults to <code>true</code>.
-        <tr><td><code>priority</code><td>integer<td>&#x2717;<td>Modifies plugin position relative to others that change one or more of the same records, but which are otherwise unrelated (ie. neither plugin lists the other as a master, requirement, or in its <code>after</code> list). An exception is made for plugins that contain only a header record: these plugins have their priorities compared against all unrelated plugins. A plugin with a higher priority value will load after a plugin with a lower priority value. Value can be anything in the range <code>-2000000000</code> to <code>2000000000</code>, and if unspecified defaults to <code>0</code>.
+        <tr><td><code>priority</code><td>integer<td>&#x2717;<td>Modifies plugin position relative to others that change one or more of the same records, but which are otherwise unrelated (ie. neither plugin lists the other as a master, requirement, or in its <code>after</code> list). Plugins that don't change any of the same records are not compared, unless:
+            <ul>
+                <li>One of the plugins is a "dummy" plugin, containing only a header record.
+                <li>One of the plugins has a priority greater than or equal to 1,000,000. In this case, only the modulo (ie. remainder when divided) with 1,000,000 is used when comparing plugin priority values &ndash; the rest is only used to signify that the plugin should be compared against all others.
+            </ul>
+            <p>For example, <code>priority: 153000352</code> and <code>priority: 352</code> have equal values when compared, but a plugin with the first priority will be compared against all others, while a (non-dummy) plugin with the second priority will be compared against only those it conflicts with.
+            <p>A plugin with a higher priority value will load after a plugin with a lower priority value. Value can be anything in the range <code>-2000000000</code> to <code>2000000000</code>, and if unspecified defaults to <code>0</code>.
        <tr><td><code>after</code><td>file list<td>&#x2717;<td>An unordered list of plugins that this plugin must load after, but which are not dependencies. Used for resolving specific compatibility issues and by user rules for specifying custom plugin positions.
-        <tr><td><code>req</code><td>file list<td>&#x2717;<td>An unordered list of files that this plugin requires to be present. This plugin will load after any plugins listed. If any of these files are missing, an error message will be displayed. Intended for use specifying implicit dependencies, as BOSS will detect a plugin's explicit masters itself.
+        <tr><td><code>req</code><td>file list<td>&#x2717;<td>An unordered list of files that this plugin requires to be present. This plugin will load after any plugins listed. If any of these files are missing, an error message will be displayed. Intended for use specifying implicit dependencies, as LOOT will detect a plugin's explicit masters itself.
        <tr><td><code>inc</code><td>file list<td>&#x2717;<td>An unordered list of files that this plugin is incompatible with. If any of these files are present, an error message will be displayed.
        <tr><td><code>msg</code><td>message list<td>&#x2717;<td>The messages attached to this plugin. The messages will be displayed in the order that they are listed.
        <tr><td><code>tag</code><td>tag list<td>&#x2717;<td>An unordered list of Bash Tags suggested for this plugin. If a Bash Tag is suggested for both addition and removal, the latter will override the former when the list is evaluated.
-        <tr><td><code>url</code><td>location list<td>&#x2717;<td>An unordered list of locations for this plugin. If the same version can be found at multiple locations, only one location should be recorded. This metadata is not currently used by BOSS.
+        <tr><td><code>url</code><td>location list<td>&#x2717;<td>An unordered list of locations for this plugin. If the same version can be found at multiple locations, only one location should be recorded. This metadata is not currently used by LOOT.
        <tr><td><code>dirty</code><td>dirty info list<td>&#x2717;<td>An unordered list of dirty info structures for this plugin.
 </table>
 <p>Example:
 <code class="box">name: 'Oscuro''s_Oblivion_Overhaul.esm'
 req:
-  - 'Oblivion.esm'  # Don't do this, Oblivion.esm is a master of Oscuro's_Oblivion_Overhaul.esm, so BOSS already knows it's required.
+  - 'Oblivion.esm'  # Don't do this, Oblivion.esm is a master of Oscuro's_Oblivion_Overhaul.esm, so LOOT already knows it's required.
  - name: 'example.esp'
    display: '[Example Mod](http://www.example.com)'
    condition: 'version("Oscuro''s_Oblivion_Overhaul.esm", "15.0", ==)'
@@ -327,27 +343,11 @@ msg:
    content: 'Do not clean. "Dirty" edits are intentional and required for the mod to function.'
 </code>

-
-<h2 id="links">URL Hyperlinking</h2>
-<p>File <code>display</code> strings and message <code>content</code> strings (including the strings in localised content structures) that contain recognised URLs have them displayed as hyperlinks in the BOSS report. 
-<p>URLs must begin with <code>file:</code>, <code>http:</code> or <code>https:</code>, and be written according to the following subset of <a href="http://daringfireball.net/projects/markdown/syntax">Markdown</a> syntax. Note that BOSS does not recognise additional Markdown syntaxes to those given below.
-<p>For labelled URLs, the syntax is <code>[<var>label</var>](<var>url</var>)</code>. A single optional space may be included between the closing square bracket and the opening parenthesis, ie. <code>[<var>label</var>] (<var>url</var>)</code>.
-<p>For unlabelled URLs, the syntax is <code>&lt;<var>url</var>&gt;</code>. The URL shall be used as its own label.
-<p>Note that the URLs given as part of a location data structure should not be labelled or enclosed in less-than or greater-than signs, as they consist of raw URL data, rather than text to be displayed in a message.
-<p>Examples:
-<code class="box">'This [string](https://en.wikipedia.org/wiki/String_(computer_science)) contains a labelled hyperlink.'</code>
-would be displayed as
-<blockquote>This <a href="https://en.wikipedia.org/wiki/String_(computer_science)">string</a> contains a labelled hyperlink.</blockquote>
-<p>While
-<code class="box">'This string (see: &lt;https://en.wikipedia.org/wiki/String_(computer_science)&gt;) contains an unlabelled hyperlink.'</code>
-both get displayed as
-<blockquote>This string (see: <a href="https://en.wikipedia.org/wiki/String_(computer_science)">https://en.wikipedia.org/wiki/String_(computer_science)</a>) contains an unlabelled hyperlink.</blockquote>
-
 <h2 id="cond">Condition Strings</h2>
-<p>Condition strings can be used to ensure that data is only acted on by BOSS under certain circumstances. They are very similar to boolean conditional expressions in programming languages such as Python, though more limited. Their <a href="https://en.wikipedia.org/wiki/Extended_Backus%E2%80%93Naur_Form">EBNF</a> grammar is:
+<p>Condition strings can be used to ensure that data is only acted on by LOOT under certain circumstances. They are very similar to boolean conditional expressions in programming languages such as Python, though more limited. Their <a href="https://en.wikipedia.org/wiki/Extended_Backus%E2%80%93Naur_Form">EBNF</a> grammar is:
 <code class="box">[ negator ], function, { junctor, [ negator ], function } ;</code>
 <p>The <code>[ negator ], function</code> grammar is referred to as a condition, and two conditions joined by an operator, ie. <code>condition, operator, condition</code> is referred to as a compound condition.
-<p>Unlike previous versions of BOSS, BOSS v3 caches the results of condition evaluations, so performance is not really an issue. A regular expression check will still take longer than a file check though, so use the former only when appropriate to do so.
+<p>LOOT caches the results of condition evaluations, so performance is not really an issue. A regular expression check will still take longer than a file check though, so use the former only when appropriate to do so.

 <h3 id="cond-function">Functions</h3>
 <p>There are several conditions that can be tested for using the functions detailed in the table below.
@@ -365,10 +365,10 @@ both get displayed as
 <table>
 <thead><tr><th>Variable Type<th>Description
 <tbody>
-  <tr><td><code>filepath</code><td>A Windows file path, or <code>BOSS</code>, which references the BOSS executable being run.
+  <tr><td><code>filepath</code><td>A Windows file path, or <code>LOOT</code>, which references the LOOT executable being run.
  <tr><td><code>regex</code><td>A regular expression string to match file paths to.
-  <tr><td><code>checksum</code><td>A string of hexadecimal digits representing an unsigned integer that is the data checksum of a file. BOSS displays the checksums of plugins in its user interface after running.
-  <tr><td><code>version</code><td>A string of characters representing the version of a plugin or executable. BOSS displays the versions of plugins in its user interface after running.
+  <tr><td><code>checksum</code><td>A string of hexadecimal digits representing an unsigned integer that is the data checksum of a file. LOOT displays the checksums of plugins in its user interface after running.
+  <tr><td><code>version</code><td>A string of characters representing the version of a plugin or executable. LOOT displays the versions of plugins in its user interface after running.
  <tr><td><code>comparator</code><td>A comparison operator, ie. one of <code>==</code>, <code>!=</code>, <code>&lt;</code>, <code>&gt;</code>, <code>&lt;=</code> or <code>&gt;=</code>, meaning "is equal to", "is not equal to", "is less than", "is greater than", "is less than or equal to" and "is greater than or equal to" respectively.
 </table>

@@ -431,20 +431,35 @@ both get displayed as
 <p>You can also explicitly enclose any condition in brackets to override the evaluation order, eg. <code><var>C</var> and ( <var>C</var> or <var>C</var> )</code> is evaluated as <code><var>C</var> and ( <var>C</var> or <var>C</var> )</code>, in contrast to the unbracketed string above.

 <h2 id="lang">Language Codes</h2>
-<p>BOSS supports the following languages and language codes:
+<p>LOOT supports the following languages and language codes:
 <table>
    <thead><tr><th>Language<th>POSIX Code
    <tbody>
        <tr><td>Chinese<td>zh_CN
        <tr><td>English<td>en
+        <tr><td>Finnish<td>fi
        <tr><td>French<td>fr
        <tr><td>Polish<td>pl
        <tr><td>Brazilian Portuguese<td>pt_BR
        <tr><td>Russian<td>ru
        <tr><td>Spanish<td>es
+        <tr><td>German<td>de
 </table>

 <h2 id="license">License</h2>
-<p>This document is part of the BOSS documentation.<br>
+<p>This document is part of the LOOT documentation.<br>
 Copyright (C) 2012&mdash;2014 WrinklyNinja<br>
-See the file <q>BOSS ReadMe.html</q> for copying conditions.
+See the file <q>LOOT ReadMe.html</q> for copying conditions.
+
+<h2 id="support">Feature Support</h2>
+<p>Different versions of LOOT may have varying levels of support for the syntax detailed in this document. Such variation in support is detailed in the table below. Unless otherwise noted, all syntax changes are backwards-compatible (ie. you can use the features without breaking the masterlist for users on older versions).
+
+<table>
+    <thead>
+        <tr><th><th colspan="2">LOOT Version
+        <tr><th>Feature<th>&lt;= 0.6 <th>0.7
+    <tbody>
+        <tr><td>GitHub Flavored Markdown message formatting<td>Only URL hyperlinking is supported, for <code>file:</code>, <code>http:</code> and <code>https:</code> URLs, using the <code>[label](url)</code> and <code>&lt;url&gt;</code> syntaxes.<td>LOOT uses the <a href="https://github.com/chjj/marked">Marked</a> library (v0.3.2) to provide support for most of GitHub Flavored Markdown, minus the GitHub-specific features (like @mentions, issue/repo linking and emoji).
+        <tr><td>Message string substitution (ie. <code>sub:</code>)<td>Not supported.<td>Support planned, but not yet implemented in the latest alpha release.
+        <tr><td>YAML merge keys (ie. <code>&lt;&lt;:</code>)<td>Not supported.<td>Support planned, but not yet implemented in the latest alpha release.
+</table>
@@ -1,20 +1,18 @@
 /**
    @mainpage
    @author WrinklyNinja
-    @version 3.0.0
-    @copyright The BOSS API is distributed under the GNU General Public License v3.0. For the full text of the license, see the "GNU GPL v3.txt" file included in the source archive.
+    @version 0..0
+    @copyright The LOOT API is distributed under the GNU General Public License v3.0. For the full text of the license, see the "GNU GPL v3.txt" file included in the source archive.

    @section intro_sec Introduction

-    BOSS is a utility that helps users avoid serious conflicts between their mods by setting their plugins in an optimal load order. It also provides tens of thousands of plugin-specific messages, including usage notes, requirements, incompatibilities, bug warnings and installation mistake notifications, and thousands of Bash Tag suggestions.
+    LOOT is a utility that helps users avoid serious conflicts between their mods by setting their plugins in an optimal load order. It also provides tens of thousands of plugin-specific messages, including usage notes, requirements, incompatibilities, bug warnings and installation mistake notifications, and thousands of Bash Tag suggestions.

-    This metadata that BOSS supplies is stored in its masterlist, which is maintained by the BOSS team using information provided by mod authors and users. Users can also add to and modify the metadata used by BOSS through the use of userlist files. The BOSS API provides a way for third-party developers to access this metadata for use in their own programs.
+    This metadata that LOOT supplies is stored in its masterlist, which is maintained by the LOOT team using information provided by mod authors and users. Users can also add to and modify the metadata used by LOOT through the use of userlist files. The LOOT API provides a way for third-party developers to access this metadata for use in their own programs.

    All further API documentation is contained within the documentation for api.h.

    @section credit_sec Credits

-    Thanks go to Lojack and myk002 for significant contributions during planning and beta testing, and to kaburke for beta testing of v2 of the API.
-
-    The BOSS API is written by WrinklyNinja in C/C++ and makes use of the <a href="http://code.google.com/p/yaml-cpp/">yaml-cpp</a> and <a href="http://github.com/WrinklyNinja/libloadorder/">libloadorder</a> libraries and some of the <a href="http://www.boost.org/">Boost</a> libraries. Copyright license information for all these may be found in the "licenses/Licenses.txt" file.
+    The LOOT API is written by WrinklyNinja in C/C++ and makes use of the <a href="http://code.google.com/p/yaml-cpp/">yaml-cpp</a> and <a href="http://github.com/WrinklyNinja/libloadorder/">libloadorder</a> libraries and some of the <a href="http://www.boost.org/">Boost</a> libraries. Copyright license information for all these may be found in the "licenses/Licenses.txt" file.
 */
@@ -1,178 +0,0 @@
-
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
@@ -0,0 +1,29 @@
+// Copyright (c) 2008-2013 Marshall A. Greenblatt. Portions Copyright (c)
+// 2006-2009 Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the name Chromium Embedded
+// Framework nor the names of its contributors may be used to endorse
+// or promote products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
@@ -1,16 +1,16 @@
 # Licenses

-BOSS uses a number of libraries, and their licenses are listed in this file.
+LOOT uses a number of libraries, and their licenses are listed in this file.

 * Alphanum - zlib license; the text is not included as allowed by the license.
 * Boost - Boost Software License v1.0; see "Boost Software License v1.0.txt" for the text.
+* Chromium Embedded Framework - BSD license; see "BSD License (Chromium Embedded Framework).txt for the text.
+* Font Awesome - SIL OFL 1.1, MIT license; the author has stated attribution is not necessary.
 * Libespm - GNU GPL v3; see "GNU GPL v3.txt" for the text.
 * Libgit2 - GNU GPL v2; see "GNU GPL v2 (libgit2).txt" for the text.
 * Libloadorder - GNU GPL v3; see "GNU GPL v3.txt" for the text.
-* Polyfill.js - This code has been placed in the public domain.
-* PugiXML - MIT License; see "MIT License (PugiXML).txt" for the text.
-* wxWidgets - wxWindows License; the text is not included as allowed by the license.
+* Marked - MIT License; see "MIT License (Marked).txt" for the text.
+* RequireJS - MIT License; see "MIT License (RequireJS).txt" for the text.
 * yaml-cpp - MIT License; see "MIT License (yaml-cpp).txt" for the text.
-* zlib - zlib license; the text is not included as allowed by the license.

-Source code for all libraries and binaries can be found on the websites linked to in the main BOSS readme.
+Source code for all libraries and binaries can be found on the websites linked to in the main LOOT readme.
@@ -0,0 +1,19 @@
+Copyright (c) 2011-2014, Christopher Jeffrey (https://github.com/chjj/)
+
+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.
--- a/Show More
+++ b/Show More