Build asar as a static library too.

With these changes, building asar now also builds a static library version of it.
The name of the library will be asar-static.lib/libasar-static.a .
This behavior is enabled by default (as everything else) and can be disabled.
To do this, add -DASAR_GEN_LIB=OFF to the cmake configuration command.

Author: Atari2

README.md

@@ -13,6 +13,13 @@ If you'd rather not build from source, check out the [Releases](https://github.c
 ## Asar DLL
 Asar can also be built as a DLL. This makes it easier and faster to use in other programs (such as a sprite insertion tool). You can find documentation on the DLL API in the respective bindings (asardll.h, asar.cs, asar.py).
 
+## Asar as a static library
+Asar can also be build as a static library. All "out-facing" functions are in interface-lib.h. This is useful for embedding Asar in other programs which don't want to use DLLs. The easiest way to add asar as a static library to your project, assuming you are using CMake (at least 3.11), is to use [FetchContent](https://cmake.org/cmake/help/latest/module/FetchContent.html) to fetch the source code, then add the following to your CMakeLists.txt:
+```CMake
+target_include_directories(YourTarget PUBLIC ${asar_SOURCE_DIR}/src)
+```
+to be able to include the header files. It is also recommended to add `set(ASAR_TESTING_DISABLED TRUE)` to your CMakeLists.txt to disable building tests.
+
 ## Folder layout
 * `docs` contains the source of the manual and changelog.
   (You can view an online version of the manual [here](https://rpghacker.github.io/asar/manual/) and an online version of the changelog [here](https://rpghacker.github.io/asar/changelog/)).

src/asar/CMakeLists.txt

@@ -5,16 +5,34 @@ cmake_minimum_required(VERSION 3.9.0)
 
 option(ASAR_GEN_EXE "Build Asar standalone application" ON)
 option(ASAR_GEN_DLL "Build Asar shared library" ON)
+option(ASAR_GEN_LIB "Build Asar static library" ON)
 option(ASAR_COVERAGE "Build Asar with coverage tracking support" OFF)
+if (MSVC)
+	message(STATUS "In MSVC you can override MSVC_LIB_TYPE, valid values are D for dynamic and T for static")
+endif()
 
 set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize=address")
 set (CMAKE_LINKER_FLAGS_DEBUG "${CMAKE_LINKER_FLAGS_DEBUG} -fsanitize=address")
 
 
-# This maro sets a number of properties required by both,
+# This macro sets a number of properties required by both,
 # stand-alone application and library interface
 
-macro(set_asar_shared_properties target)
+macro(set_asar_shared_properties target msvc_lib_type_param enable_sanitizer)
+	if (MSVC)
+		if (MSVC_LIB_TYPE)
+			set(msvc_lib_type_param ${MSVC_LIB_TYPE})
+		endif()
+		if (NOT (${msvc_lib_type_param} STREQUAL "D" OR ${msvc_lib_type_param} STREQUAL "T"))
+			message(FATAL_ERROR "Invalid MSVC_LIB_TYPE, valid types are T and D")
+		endif()
+	endif()
+
+	if (enable_sanitizer)
+		target_compile_options(${target} PRIVATE "$<$<CONFIG:Debug>:-fsanitize=address>")
+		target_link_options(${target} PRIVATE "$<$<CONFIG:Debug>:-fsanitize=address>")
+	endif()
+
 	target_include_directories(${target} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}")
 
 	if(MSVC)
@@ -56,7 +74,7 @@ macro(set_asar_shared_properties target)
 	# Enable maximum warning level
 
 	if(MSVC)
-		target_compile_options(${target} PRIVATE /Wall /MT /EHa)
+		target_compile_options(${target} PRIVATE /Wall "/M${msvc_lib_type_param}$<$<CONFIG:Debug>:d>" /EHa)
 
 		# These certainly aren't worth a warning, though
 		target_compile_options(${target} PRIVATE
@@ -140,6 +158,7 @@ list(
 	"${CMAKE_CURRENT_SOURCE_DIR}/arch-shared.h"
 	"${CMAKE_CURRENT_SOURCE_DIR}/virtualfile.h"
 	"${CMAKE_CURRENT_SOURCE_DIR}/dll_helper.h"
+	"${CMAKE_CURRENT_SOURCE_DIR}/interface-lib.h"
 
 	"${CMAKE_CURRENT_SOURCE_DIR}/std-includes.h"
 	"${CMAKE_CURRENT_SOURCE_DIR}/platform/file-helpers.h"
@@ -201,7 +220,7 @@ if(ASAR_GEN_EXE)
 		${ASAR_RESOURCE_FILES}
 		)
 
-	set_asar_shared_properties(asar-standalone)
+	set_asar_shared_properties(asar-standalone "T" TRUE)
 
 	if(ASAR_COVERAGE)
 		target_compile_options(asar-standalone PRIVATE -fprofile-arcs -ftest-coverage)
@@ -228,7 +247,27 @@ if(ASAR_GEN_DLL)
 		${ASAR_LIB_RESOURCE_FILES}
 	)
 	target_compile_definitions(asar PRIVATE "ASAR_SHARED")
-	set_asar_shared_properties(asar)
+	set_asar_shared_properties(asar "T" TRUE)
 
 	set_target_properties(asar PROPERTIES PDB_NAME "asar.dll")
 endif(ASAR_GEN_DLL)
+
+
+
+
+
+# Define static library
+
+if (ASAR_GEN_LIB)
+	add_library(
+		asar-static STATIC
+		"${CMAKE_CURRENT_SOURCE_DIR}/interface-lib.cpp"
+
+		${ASAR_SHARED_SOURCE_FILES}
+		${ASAR_LIB_RESOURCE_FILES}
+	)
+	target_compile_definitions(asar-static PRIVATE "ASAR_STATIC")
+	set_asar_shared_properties(asar-static "D" FALSE)
+
+	# there's no need to set the PDB name since static libraries don't produce PDBs
+endif()

src/asar/interface-lib.cpp

@@ -17,7 +17,11 @@
 #if defined(CPPCLI)
 #define EXPORT extern "C"
 #elif defined(_WIN32)
+#ifdef ASAR_SHARED
 #define EXPORT extern "C" __declspec(dllexport)
+#elif ASAR_STATIC
+#define EXPORT extern "C"
+#endif
 #else
 #define EXPORT extern "C" __attribute__ ((visibility ("default")))
 #endif

src/asar/interface-lib.h

@@ -0,0 +1,187 @@
+#pragma once
+#ifndef ASAR_SHARED
+#define expectedapiversion 303
+
+#include <stdbool.h>
+#include <stddef.h> // for size_t
+
+//These structures are returned from various functions.
+struct errordata {
+	const char* fullerrdata;
+	const char* rawerrdata;
+	const char* block;
+	const char* filename;
+	int line;
+	const char* callerfilename;
+	int callerline;
+	int errid;
+};
+
+struct labeldata {
+	const char* name;
+	int location;
+};
+
+struct definedata {
+	const char* name;
+	const char* contents;
+};
+
+struct writtenblockdata {
+	int pcoffset;
+	int snesoffset;
+	int numbytes;
+};
+
+enum mappertype {
+	invalid_mapper,
+	lorom,
+	hirom,
+	sa1rom,
+	bigsa1rom,
+	sfxrom,
+	exlorom,
+	exhirom,
+	norom
+};
+
+struct warnsetting {
+	const char* warnid;
+	bool enabled;
+};
+
+struct memoryfile {
+	const char* path;
+	const void* buffer;
+	size_t length;
+};
+
+struct patchparams
+{
+	// The size of this struct. Set to (int)sizeof(patchparams).
+	int structsize;
+
+	// Same parameters as asar_patch()
+	const char* patchloc;
+	char* romdata;
+	int buflen;
+	int* romlen;
+
+	// Include paths to use when searching files.
+	const char** includepaths;
+	int numincludepaths;
+
+	// should everything be reset before patching? Setting it to false will make asar
+	// act like the currently patched file was directly appended to the previous one.
+	// note that you can't use the previous run's defines - you can use getalldefines()
+	// and additional_defines for that.
+	bool should_reset;
+
+	// A list of additional defines to make available to the patch.
+	const struct definedata* additional_defines;
+	int additional_define_count;
+
+	// Path to a text file to parse standard include search paths from.
+	// Set to NULL to not use any standard includes search paths.
+	const char* stdincludesfile;
+
+	// Path to a text file to parse standard defines from.
+	// Set to NULL to not use any standard defines.
+	const char* stddefinesfile;
+
+	// A list of warnings to enable or disable.
+	// Specify warnings in the format "WXXXX" where XXXX = warning ID.
+	const struct warnsetting* warning_settings;
+	int warning_setting_count;
+
+	// List of memory files to create on the virtual filesystem.
+	const struct memoryfile* memory_files;
+	int memory_file_count;
+
+	// Set override_checksum_gen to true and generate_checksum to true/false
+	// to force generating/not generating a checksum.
+	bool override_checksum_gen;
+	bool generate_checksum;
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+	//Returns the version, in the format major*10000+minor*100+bugfix*1. This means that 1.2.34 would be
+	// returned as 10234.
+	int asar_version(void);
+
+	//Returns the API version, format major*100+minor. Minor is incremented on backwards compatible
+	// changes; major is incremented on incompatible changes. Does not have any correlation with the
+	// Asar version.
+	//It's not very useful directly, since asar_init() verifies this automatically.
+	//Calling this one also sets a flag that makes asar_init not instantly return false; this is so
+	// programs expecting an older API won't do anything unexpected.
+	int asar_apiversion(void);
+
+	//Clears out all errors, warnings and printed statements, and clears the file cache. Not really
+	// useful, since asar_patch() already does this.
+	bool asar_reset(void);
+
+	//Applies a patch. The first argument is a filename (so Asar knows where to look for incsrc'd
+	// stuff); however, the ROM is in memory.
+	//This function assumes there are no headers anywhere, neither in romdata nor the sizes. romlen may
+	// be altered by this function; if this is undesirable, set romlen equal to buflen.
+	//The return value is whether any errors appeared (false=errors, call asar_geterrors for details).
+	// If there is an error, romdata and romlen will be left unchanged.
+	bool asar_patch(const char* patchloc, char* romdata, int buflen, int* romlen);
+
+	// An extended version of asar_patch() with a future-proof parameter format.
+	bool asar_patch_ex(const struct patchparams* params);
+
+	//Returns the maximum possible size of the output ROM from asar_patch(). Giving this size to buflen
+	// guarantees you will not get any buffer too small errors; however, it is safe to give smaller
+	// buffers if you don't expect any ROMs larger than 4MB or something.
+	int asar_maxromsize(void);
+
+	//Get a list of all errors.
+	//All pointers from these functions are valid only until the same function is called again, or until
+	// asar_patch, asar_reset or asar_close is called, whichever comes first. Copy the contents if you
+	// need it for a longer time.
+	const struct errordata* asar_geterrors(int* count);
+
+	//Get a list of all warnings.
+	const struct errordata* asar_getwarnings(int* count);
+
+	//Get a list of all printed data.
+	const char* const* asar_getprints(int* count);
+
+	//Get a list of all labels.
+	const struct labeldata* asar_getalllabels(int* count);
+
+	//Get the ROM location of one label. -1 means "not found".
+	int asar_getlabelval(const char* name);
+
+	//Gets the value of a define.
+	const char* asar_getdefine(const char* name);
+
+	//Gets the values and names of all defines.
+	const struct definedata* asar_getalldefines(int* count);
+
+	//Parses all defines in the parameter. The parameter controls whether it'll learn new defines in
+	// this string if it finds any. Note that it may emit errors.
+	const char* asar_resolvedefines(const char* data, bool learnnew);
+
+	//Parses a string containing math. It automatically assumes global scope (no namespaces), and has
+	// access to all functions and labels from the last call to asar_patch. Remember to check error to
+	// see if it's successful (NULL) or if it failed (non-NULL, contains a descriptive string). It does
+	// not affect asar_geterrors.
+	double asar_math(const char* math, const char** error);
+
+	//Get a list of all the blocks written to the ROM by calls such as asar_patch().
+	const struct writtenblockdata* asar_getwrittenblocks(int* count);
+
+	//Get the mapper currently used by Asar
+	enum mappertype asar_getmapper(void);
+
+	// Generates the contents of a symbols file for in a specific format.
+	const char* asar_getsymbolsfile(const char* format);
+#ifdef __cplusplus
+}
+#endif
+#endif