@dry-software/cmake-js 7.3.0

package/lib/buildSystem.js

@@ -0,0 +1,123 @@
+'use strict'
+const CMake = require('./cMake')
+const Dist = require('./dist')
+const CMLog = require('./cmLog')
+const appCMakeJSConfig = require('./appCMakeJSConfig')
+const npmConfig = require('./npmConfig')
+const path = require('path')
+const Toolset = require('./toolset')
+
+function isNodeApi(log, projectRoot) {
+	try {
+		const projectPkgJson = require(path.join(projectRoot, 'package.json'))
+		// Make sure the property exists
+		return !!projectPkgJson?.binary?.napi_versions
+	} catch (e) {
+		log.silly('CFG', "'package.json' not found.")
+		return false
+	}
+}
+
+class BuildSystem {
+	constructor(options) {
+		this.options = options || {}
+		this.options.directory = path.resolve(this.options.directory || process.cwd())
+		this.options.out = path.resolve(this.options.out || path.join(this.options.directory, 'build'))
+		this.log = new CMLog(this.options)
+		this.options.isNodeApi = isNodeApi(this.log, this.options.directory)
+		const appConfig = appCMakeJSConfig(this.options.directory, this.log)
+		const npmOptions = npmConfig(this.log)
+
+		if (npmOptions && typeof npmOptions === 'object' && Object.keys(npmOptions).length) {
+			this.options.runtimeDirectory = npmOptions['nodedir']
+			this.options.msvsVersion = npmOptions['msvs_version']
+		}
+		if (appConfig && typeof appConfig === 'object' && Object.keys(appConfig).length) {
+			this.log.verbose('CFG', 'Applying CMake.js config from root package.json:')
+			this.log.verbose('CFG', JSON.stringify(appConfig))
+			// Applying applications's config, if there is no explicit runtime related options specified
+			this.options.runtime = this.options.runtime || appConfig.runtime
+			this.options.runtimeVersion = this.options.runtimeVersion || appConfig.runtimeVersion
+			this.options.arch = this.options.arch || appConfig.arch
+		}
+
+		this.log.verbose('CFG', 'Build system options:')
+		this.log.verbose('CFG', JSON.stringify(this.options))
+		this.cmake = new CMake(this.options)
+		this.dist = new Dist(this.options)
+		this.toolset = new Toolset(this.options)
+	}
+	async _ensureInstalled() {
+		try {
+			await this.toolset.initialize(true)
+			if (!this.options.isNodeApi) {
+				await this.dist.ensureDownloaded()
+			}
+		} catch (e) {
+			this._showError(e)
+			throw e
+		}
+	}
+	_showError(e) {
+		if (this.log === undefined) {
+			// handle internal errors (init failed)
+			console.error('OMG', e.stack)
+			return
+		}
+		if (this.log.level === 'verbose' || this.log.level === 'silly') {
+			this.log.error('OMG', e.stack)
+		} else {
+			this.log.error('OMG', e.message)
+		}
+	}
+	install() {
+		return this._ensureInstalled()
+	}
+	async _invokeCMake(method) {
+		try {
+			await this._ensureInstalled()
+			return await this.cmake[method]()
+		} catch (e) {
+			this._showError(e)
+			throw e
+		}
+	}
+	getConfigureCommand() {
+		return this._invokeCMake('getConfigureCommand')
+	}
+	getCmakeJsLibString() {
+		return this._invokeCMake('getCmakeJsLibString')
+	}
+	getCmakeJsIncludeString() {
+		return this._invokeCMake('getCmakeJsIncludeString')
+	}
+	getCmakeJsSrcString() {
+		return this._invokeCMake('getCmakeJsSrcString')
+	}
+	configure() {
+		return this._invokeCMake('configure')
+	}
+	getBuildCommand() {
+		return this._invokeCMake('getBuildCommand')
+	}
+	build() {
+		return this._invokeCMake('build')
+	}
+	getCleanCommand() {
+		return this._invokeCMake('getCleanCommand')
+	}
+	clean() {
+		return this._invokeCMake('clean')
+	}
+	reconfigure() {
+		return this._invokeCMake('reconfigure')
+	}
+	rebuild() {
+		return this._invokeCMake('rebuild')
+	}
+	compile() {
+		return this._invokeCMake('compile')
+	}
+}
+
+module.exports = BuildSystem

package/lib/cMake.js

@@ -0,0 +1,362 @@
+'use strict'
+const which = require('which')
+const fs = require('fs-extra')
+const path = require('path')
+const environment = require('./environment')
+const Dist = require('./dist')
+const CMLog = require('./cmLog')
+const TargetOptions = require('./targetOptions')
+const processHelpers = require('./processHelpers')
+const locateNAN = require('./locateNAN')
+const locateNodeApi = require('./locateNodeApi')
+const npmConfigData = require('rc')('npm')
+const Toolset = require('./toolset')
+const headers = require('node-api-headers')
+
+class CMake {
+	get path() {
+		return this.options.cmakePath || 'cmake'
+	}
+	get isAvailable() {
+		if (this._isAvailable === null) {
+			this._isAvailable = CMake.isAvailable(this.options)
+		}
+		return this._isAvailable
+	}
+
+	constructor(options) {
+		this.options = options || {}
+		this.log = new CMLog(this.options)
+		this.dist = new Dist(this.options)
+		this.projectRoot = path.resolve(this.options.directory || process.cwd())
+		this.workDir = path.resolve(this.options.out || path.join(this.projectRoot, 'build'))
+		this.config = this.options.config || (this.options.debug ? 'Debug' : 'Release')
+		this.buildDir = path.join(this.workDir, this.config)
+		this._isAvailable = null
+		this.targetOptions = new TargetOptions(this.options)
+		this.toolset = new Toolset(this.options)
+		this.cMakeOptions = this.options.cMakeOptions || {}
+		this.extraCMakeArgs = this.options.extraCMakeArgs || []
+		this.silent = !!options.silent
+	}
+	static isAvailable(options) {
+		options = options || {}
+		try {
+			if (options.cmakePath) {
+				const stat = fs.lstatSync(options.cmakePath)
+				return !stat.isDirectory()
+			} else {
+				which.sync('cmake')
+				return true
+			}
+		} catch (e) {
+			// Ignore
+		}
+		return false
+	}
+	static async getGenerators(options, log) {
+		const arch = ' [arch]'
+		options = options || {}
+		const gens = []
+		if (CMake.isAvailable(options)) {
+			// try parsing machine-readable capabilities (available since CMake 3.7)
+			try {
+				const stdout = await processHelpers.execFile([options.cmakePath || 'cmake', '-E', 'capabilities'])
+				const capabilities = JSON.parse(stdout)
+				return capabilities.generators.map((x) => x.name)
+			} catch (error) {
+				if (log) {
+					log.verbose('TOOL', 'Failed to query CMake capabilities (CMake is probably older than 3.7)')
+				}
+			}
+
+			// fall back to parsing help text
+			const stdout = await processHelpers.execFile([options.cmakePath || 'cmake', '--help'])
+			const hasCr = stdout.includes('\r\n')
+			const output = hasCr ? stdout.split('\r\n') : stdout.split('\n')
+			let on = false
+			output.forEach(function (line, i) {
+				if (on) {
+					const parts = line.split('=')
+					if (
+						(parts.length === 2 && parts[0].trim()) ||
+						(parts.length === 1 && i !== output.length - 1 && output[i + 1].trim()[0] === '=')
+					) {
+						let gen = parts[0].trim()
+						if (gen.endsWith(arch)) {
+							gen = gen.substr(0, gen.length - arch.length)
+						}
+						gens.push(gen)
+					}
+				}
+				if (line.trim() === 'Generators') {
+					on = true
+				}
+			})
+		} else {
+			throw new Error('CMake is not installed. Install CMake.')
+		}
+		return gens
+	}
+	verifyIfAvailable() {
+		if (!this.isAvailable) {
+			throw new Error(
+				"CMake executable is not found. Please use your system's package manager to install it, or you can get installers from there: http://cmake.org.",
+			)
+		}
+	}
+	async getConfigureCommand() {
+		// Create command:
+		let command = [this.path, this.projectRoot, '--no-warn-unused-cli']
+
+		const D = []
+
+		// CMake.js watermark
+		D.push({ CMAKE_JS_VERSION: environment.cmakeJsVersion })
+
+		// Build configuration:
+		D.push({ CMAKE_BUILD_TYPE: this.config })
+		if (environment.isWin) {
+			D.push({ CMAKE_RUNTIME_OUTPUT_DIRECTORY: this.workDir })
+		} else if (this.workDir.endsWith(this.config)) {
+			D.push({ CMAKE_LIBRARY_OUTPUT_DIRECTORY: this.workDir })
+		} else {
+			D.push({ CMAKE_LIBRARY_OUTPUT_DIRECTORY: this.buildDir })
+		}
+
+		// In some configurations MD builds will crash upon attempting to free memory.
+		// This tries to encourage MT builds which are larger but less likely to have this crash.
+		D.push({ CMAKE_MSVC_RUNTIME_LIBRARY: 'MultiThreaded$<$<CONFIG:Debug>:Debug>' })
+
+		// Includes:
+		const includesString = await this.getCmakeJsIncludeString()
+		D.push({ CMAKE_JS_INC: includesString })
+
+		// Sources:
+		const srcsString = this.getCmakeJsSrcString()
+		D.push({ CMAKE_JS_SRC: srcsString })
+
+		// Runtime:
+		D.push({ NODE_RUNTIME: this.targetOptions.runtime })
+		D.push({ NODE_RUNTIMEVERSION: this.targetOptions.runtimeVersion })
+		D.push({ NODE_ARCH: this.targetOptions.arch })
+
+		if (environment.isOSX) {
+			if (this.targetOptions.arch) {
+				let xcodeArch = this.targetOptions.arch
+				if (xcodeArch === 'x64') xcodeArch = 'x86_64'
+				D.push({ CMAKE_OSX_ARCHITECTURES: xcodeArch })
+			}
+		}
+
+		// Custom options
+		for (const [key, value] of Object.entries(this.cMakeOptions)) {
+			D.push({ [key]: value })
+		}
+
+		// Toolset:
+		await this.toolset.initialize(false)
+
+		const libsString = this.getCmakeJsLibString()
+		D.push({ CMAKE_JS_LIB: libsString })
+
+		if (environment.isWin) {
+			const nodeLibDefPath = this.getNodeLibDefPath()
+			if (nodeLibDefPath) {
+				const nodeLibPath = path.join(this.workDir, 'node.lib')
+				D.push({ CMAKE_JS_NODELIB_DEF: nodeLibDefPath })
+				D.push({ CMAKE_JS_NODELIB_TARGET: nodeLibPath })
+			}
+		}
+
+		if (this.toolset.generator) {
+			command.push('-G', this.toolset.generator)
+		}
+		if (this.toolset.platform) {
+			command.push('-A', this.toolset.platform)
+		}
+		if (this.toolset.toolset) {
+			command.push('-T', this.toolset.toolset)
+		}
+		if (this.toolset.cppCompilerPath) {
+			D.push({ CMAKE_CXX_COMPILER: this.toolset.cppCompilerPath })
+		}
+		if (this.toolset.cCompilerPath) {
+			D.push({ CMAKE_C_COMPILER: this.toolset.cCompilerPath })
+		}
+		if (this.toolset.compilerFlags.length) {
+			D.push({ CMAKE_CXX_FLAGS: this.toolset.compilerFlags.join(' ') })
+		}
+		if (this.toolset.linkerFlags.length) {
+			D.push({ CMAKE_SHARED_LINKER_FLAGS: this.toolset.linkerFlags.join(' ') })
+		}
+		if (this.toolset.makePath) {
+			D.push({ CMAKE_MAKE_PROGRAM: this.toolset.makePath })
+		}
+
+		// Load NPM config
+		for (const [key, value] of Object.entries(npmConfigData)) {
+			if (key.startsWith('cmake_')) {
+				const sk = key.substr(6)
+				if (sk && value) {
+					D.push({ [sk]: value })
+				}
+			}
+		}
+
+		command = command.concat(
+			D.map(function (p) {
+				return '-D' + Object.keys(p)[0] + '=' + Object.values(p)[0]
+			}),
+		)
+
+		return command.concat(this.extraCMakeArgs)
+	}
+	getCmakeJsLibString() {
+		const libs = []
+		if (environment.isWin) {
+			const nodeLibDefPath = this.getNodeLibDefPath()
+			if (nodeLibDefPath) {
+				libs.push(path.join(this.workDir, 'node.lib'))
+			} else {
+				libs.push(...this.dist.winLibs)
+			}
+		}
+		return libs.join(';')
+	}
+	async getCmakeJsIncludeString() {
+		let incPaths = []
+		if (!this.options.isNodeApi) {
+			// Include and lib:
+			if (this.dist.headerOnly) {
+				incPaths = [path.join(this.dist.internalPath, '/include/node')]
+			} else {
+				const nodeH = path.join(this.dist.internalPath, '/src')
+				const v8H = path.join(this.dist.internalPath, '/deps/v8/include')
+				const uvH = path.join(this.dist.internalPath, '/deps/uv/include')
+				incPaths = [nodeH, v8H, uvH]
+			}
+
+			// NAN
+			const nanH = await locateNAN(this.projectRoot)
+			if (nanH) {
+				incPaths.push(nanH)
+			}
+		} else {
+			// Base headers
+			const apiHeaders = require('node-api-headers')
+			incPaths.push(apiHeaders.include_dir)
+
+			// Node-api
+			const napiH = await locateNodeApi(this.projectRoot)
+			if (napiH) {
+				incPaths.push(napiH)
+			}
+		}
+
+		return incPaths.join(';')
+	}
+	getCmakeJsSrcString() {
+		const srcPaths = []
+		if (environment.isWin) {
+			const delayHook = path.normalize(path.join(__dirname, 'cpp', 'win_delay_load_hook.cc'))
+
+			srcPaths.push(delayHook.replace(/\\/gm, '/'))
+		}
+
+		return srcPaths.join(';')
+	}
+	getNodeLibDefPath() {
+		return environment.isWin && this.options.isNodeApi ? headers.def_paths.node_api_def : undefined
+	}
+	async configure() {
+		this.verifyIfAvailable()
+
+		this.log.info('CMD', 'CONFIGURE')
+		const listPath = path.join(this.projectRoot, 'CMakeLists.txt')
+		const command = await this.getConfigureCommand()
+
+		try {
+			await fs.lstat(listPath)
+		} catch (e) {
+			throw new Error("'" + listPath + "' not found.")
+		}
+
+		try {
+			await fs.ensureDir(this.workDir)
+		} catch (e) {
+			// Ignore
+		}
+
+		const cwd = process.cwd()
+		process.chdir(this.workDir)
+		try {
+			await this._run(command)
+		} finally {
+			process.chdir(cwd)
+		}
+	}
+	async ensureConfigured() {
+		try {
+			await fs.lstat(path.join(this.workDir, 'CMakeCache.txt'))
+		} catch (e) {
+			await this.configure()
+		}
+	}
+	getBuildCommand() {
+		const command = [this.path, '--build', this.workDir, '--config', this.config]
+		if (this.options.target) {
+			command.push('--target', this.options.target)
+		}
+		if (this.options.parallel) {
+			command.push('--parallel', this.options.parallel)
+		}
+		return Promise.resolve(command.concat(this.extraCMakeArgs))
+	}
+	async build() {
+		this.verifyIfAvailable()
+
+		await this.ensureConfigured()
+		const buildCommand = await this.getBuildCommand()
+		this.log.info('CMD', 'BUILD')
+		await this._run(buildCommand)
+	}
+	getCleanCommand() {
+		return [this.path, '-E', 'remove_directory', this.workDir].concat(this.extraCMakeArgs)
+	}
+	clean() {
+		this.verifyIfAvailable()
+
+		this.log.info('CMD', 'CLEAN')
+		return this._run(this.getCleanCommand())
+	}
+	async reconfigure() {
+		this.extraCMakeArgs = []
+		await this.clean()
+		await this.configure()
+	}
+	async rebuild() {
+		this.extraCMakeArgs = []
+		await this.clean()
+		await this.build()
+	}
+	async compile() {
+		this.extraCMakeArgs = []
+		try {
+			await this.build()
+		} catch (e) {
+			this.log.info('REP', 'Build has been failed, trying to do a full rebuild.')
+			await this.rebuild()
+		}
+	}
+	_run(command) {
+		this.log.info('RUN', command)
+		return processHelpers.run(command, { silent: this.silent })
+	}
+
+	async getGenerators() {
+		return CMake.getGenerators(this.options, this.log)
+	}
+}
+
+module.exports = CMake

package/lib/cmLog.js

@@ -0,0 +1,61 @@
+'use strict'
+const log = require('npmlog')
+
+class CMLog {
+	get level() {
+		if (this.options.noLog) {
+			return 'silly'
+		} else {
+			return log.level
+		}
+	}
+
+	constructor(options) {
+		this.options = options || {}
+		this.debug = require('debug')(this.options.logName || 'cmake-js')
+	}
+	silly(cat, msg) {
+		if (this.options.noLog) {
+			this.debug(cat + ': ' + msg)
+		} else {
+			log.silly(cat, msg)
+		}
+	}
+	verbose(cat, msg) {
+		if (this.options.noLog) {
+			this.debug(cat + ': ' + msg)
+		} else {
+			log.verbose(cat, msg)
+		}
+	}
+	info(cat, msg) {
+		if (this.options.noLog) {
+			this.debug(cat + ': ' + msg)
+		} else {
+			log.info(cat, msg)
+		}
+	}
+	warn(cat, msg) {
+		if (this.options.noLog) {
+			this.debug(cat + ': ' + msg)
+		} else {
+			log.warn(cat, msg)
+		}
+	}
+	http(cat, msg) {
+		if (this.options.noLog) {
+			this.debug(cat + ': ' + msg)
+		} else {
+			log.http(cat, msg)
+		}
+	}
+	error(cat, msg) {
+		if (this.options.noLog) {
+			this.debug(cat + ': ' + msg)
+		} else {
+			log.error(cat, msg)
+		}
+	}
+}
+
+module.exports = CMLog

package/lib/cpp/win_delay_load_hook.cc

@@ -0,0 +1,52 @@
+/*
+ * When this file is linked to a DLL, it sets up a delay-load hook that
+ * intervenes when the DLL is trying to load 'node.exe' or 'iojs.exe'
+ * dynamically. Instead of trying to locate the .exe file it'll just return
+ * a handle to the process image.
+ *
+ * This allows compiled addons to work when node.exe or iojs.exe is renamed.
+ */
+
+#ifdef _MSC_VER
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+
+#include <windows.h>
+
+#include <delayimp.h>
+#include <string.h>
+
+static HMODULE node_dll = NULL;
+static HMODULE nw_dll = NULL;
+
+static FARPROC WINAPI load_exe_hook(unsigned int event, DelayLoadInfo* info) {
+  if (event == dliNotePreGetProcAddress) {
+    FARPROC ret = NULL;
+    ret = GetProcAddress(node_dll, info->dlp.szProcName);
+    if (ret)
+      return ret;
+    ret = GetProcAddress(nw_dll, info->dlp.szProcName);
+    return ret;
+  }
+  if (event == dliStartProcessing) {
+    node_dll = GetModuleHandleA("node.dll");
+    nw_dll = GetModuleHandleA("nw.dll");
+    return NULL;
+  }
+  if (event != dliNotePreLoadLibrary)
+    return NULL;
+
+  if (_stricmp(info->szDll, "node.exe") != 0)
+    return NULL;
+  
+  // Fall back to the current process
+  if(!node_dll) node_dll = GetModuleHandleA(NULL);
+
+  return (FARPROC) node_dll;
+}
+
+decltype(__pfnDliNotifyHook2) __pfnDliNotifyHook2 = load_exe_hook;
+
+#endif