�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2F'>php-8.4.5</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fwin32%2F'>win32</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fwin32%2Fbuild%2F'>build</a>/</p><hr><h3>✏️ Editing: confutils.js</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>// Utils for configure script
/*
  +----------------------------------------------------------------------+
  | Copyright (c) The PHP Group                                          |
  +----------------------------------------------------------------------+
  | This source file is subject to version 3.01 of the PHP license,      |
  | that is bundled with this package in the file LICENSE, and is        |
  | available through the world-wide-web at the following url:           |
  | https://www.php.net/license/3_01.txt                                 |
  | If you did not receive a copy of the PHP license and are unable to   |
  | obtain it through the world-wide-web, please send a note to          |
  | license@php.net so we can mail you a copy immediately.               |
  +----------------------------------------------------------------------+
  | Author: Wez Furlong &lt;wez@thebrainroom.com&gt;                           |
  +----------------------------------------------------------------------+
*/

var STDOUT = WScript.StdOut;
var STDERR = WScript.StdErr;
var WshShell = WScript.CreateObject(&quot;WScript.Shell&quot;);
var FSO = WScript.CreateObject(&quot;Scripting.FileSystemObject&quot;);
var MFO = null;
var SYSTEM_DRIVE = WshShell.Environment(&quot;Process&quot;).Item(&quot;SystemDrive&quot;);
var PROGRAM_FILES = WshShell.Environment(&quot;Process&quot;).Item(&quot;ProgramFiles&quot;);
var PROGRAM_FILESx86 = WshShell.Environment(&quot;Process&quot;).Item(&quot;ProgramFiles(x86)&quot;);
var VCINSTALLDIR = WshShell.Environment(&quot;Process&quot;).Item(&quot;VCINSTALLDIR&quot;);
var PHP_SRC_DIR=FSO.GetParentFolderName(WScript.ScriptFullName);

var VS_TOOLSET = true;
var CLANG_TOOLSET = false;
var ICC_TOOLSET = false;
var VCVERS = -1;
var CLANGVERS = -1;
var INTELVERS = -1;
var COMPILER_NUMERIC_VERSION = -1;
var COMPILER_NAME_LONG = &quot;unknown&quot;;
var COMPILER_NAME_SHORT = &quot;unknown&quot;;
var PHP_OBJECT_OUT_DIR = &quot;&quot;;
var PHP_CONFIG_PROFILE = &quot;no&quot;;
var PHP_SANITIZER = &quot;no&quot;;
var VERBOSITY = 0;
var CMD_MOD1 = &quot;@&quot;;
var CMD_MOD2 = &quot;@&quot;;

var PHP_TEST_INI_PATH = &quot;&quot;;
var PHP_TEST_INI = &quot;&quot;;
var PHP_TEST_INI_EXT_EXCLUDE = &quot;&quot;;

var PHP_MAKEFILE_FRAGMENTS = PHP_SRC_DIR + &quot;\\Makefile.fragments.w32&quot;;

/* Care also about NTDDI_VERSION and _WIN32_WINNT in config.w32.h.in
   and manifest. */
var WINVER = &quot;0x0602&quot;; /* 8/2012 */

// There&#039;s a minimum requirement for bison.
var MINBISON = &quot;3.0.0&quot;;

// There&#039;s a minimum requirement for re2c..
var MINRE2C = &quot;0.13.4&quot;;

/* Store the enabled extensions (summary + QA check) */
var extensions_enabled = new Array();

/* Store the SAPI enabled (summary + QA check) */
var sapi_enabled = new Array();

/* Store the headers to install */
var headers_install = new Array();

/* Store unknown configure options */
var INVALID_CONFIG_ARGS = new Array();

if (PROGRAM_FILES == null) {
	PROGRAM_FILES = &quot;C:\\Program Files&quot;;
}

if (MODE_PHPIZE) {
	if (!FSO.FileExists(&quot;config.w32&quot;)) {
		STDERR.WriteLine(&quot;Must be run from the root of the extension source&quot;);
		WScript.Quit(10);
	}
} else {
	if (!FSO.FileExists(&quot;main\\php_version.h&quot;)) {
		STDERR.WriteLine(&quot;Must be run from the root of the php source&quot;);
		WScript.Quit(10);
	}
}

var CWD = WshShell.CurrentDirectory;

if (typeof(CWD) == &quot;undefined&quot;) {
	CWD = FSO.GetParentFolderName(FSO.GetParentFolderName(FSO.GetAbsolutePathName(&quot;main\\php_version.h&quot;)));
}

if (!MODE_PHPIZE) {
	/* defaults; we pick up the precise versions from configure.ac */
	var PHP_VERSION = 8;
	var PHP_MINOR_VERSION = 4;
	var PHP_RELEASE_VERSION = 0;
	var PHP_EXTRA_VERSION = &quot;&quot;;
	var PHP_VERSION_STRING = &quot;8.4.0&quot;;
}

/* Get version numbers and DEFINE as a string */
function get_version_numbers()
{
	var cin = file_get_contents(&quot;configure.ac&quot;);
	var regex = /AC_INIT.+(\d+)\.(\d+)\.(\d+)([^\,^\]]*).+/g;

	if (cin.match(new RegExp(regex))) {
		PHP_VERSION = RegExp.$1;
		PHP_MINOR_VERSION = RegExp.$2;
		PHP_RELEASE_VERSION = RegExp.$3;
		PHP_EXTRA_VERSION = RegExp.$4;
	}

	PHP_VERSION_STRING = PHP_VERSION + &quot;.&quot; + PHP_MINOR_VERSION + &quot;.&quot; + PHP_RELEASE_VERSION + PHP_EXTRA_VERSION;

	DEFINE(&#039;PHP_VERSION_STRING&#039;, PHP_VERSION_STRING);
}

configure_args = new Array();
configure_subst = WScript.CreateObject(&quot;Scripting.Dictionary&quot;);

configure_hdr = WScript.CreateObject(&quot;Scripting.Dictionary&quot;);
build_dirs = new Array();

extension_include_code = &quot;&quot;;
extension_module_ptrs = &quot;&quot;;

(function () {
	var wmiservice = GetObject(&quot;winmgmts:{impersonationLevel=impersonate}!\\\\.\\root\\cimv2&quot;);
	var oss = wmiservice.ExecQuery(&quot;Select * from Win32_OperatingSystem&quot;);
	var os = oss.ItemIndex(0);
	AC_DEFINE(&quot;PHP_BUILD_SYSTEM&quot;, os.Caption + &quot; [&quot; + os.Version + &quot;]&quot;, &quot;The system that PHP was built on.&quot;);
	var build_provider = WshShell.Environment(&quot;Process&quot;).Item(&quot;PHP_BUILD_PROVIDER&quot;);
	if (build_provider) {
		AC_DEFINE(&quot;PHP_BUILD_PROVIDER&quot;, build_provider, &quot;The PHP build provider information.&quot;);
	}
}());

if (!MODE_PHPIZE) {
	get_version_numbers();
}

/* execute a command and return the output as a string */
function execute(command_line)
{
	var e = WshShell.Exec(command_line);
	var ret = &quot;&quot;;

	ret = e.StdOut.ReadAll();

//STDOUT.WriteLine(&quot;command &quot; + command_line);
//STDOUT.WriteLine(ret);

	return ret;
}

function probe_binary(EXE, what)
{
	// tricky escapes to get stderr redirection to work
	var command = &#039;cmd /c &quot;&quot;&#039; + EXE;
	if (what == &quot;version&quot;) {
		command = command + &#039;&quot; -v&quot;&#039;;
	} else if (what == &quot;longversion&quot;) {
		command = command + &#039;&quot; --version&quot;&#039;;
	}
	var version = execute(command + &#039;&quot; 2&gt;&amp;1&quot;&#039;);

	if (what == &quot;arch&quot;) {
		if (version.match(/x86/)) {
			return &quot;x86&quot;;
		} else if (version.match(/x64/)) {
			return &quot;x64&quot;;
		} else if (version.match(/ARM64/)) {
			return &quot;arm64&quot;;
		}
	} else {
		if (version.match(/(\d+\.\d+(\.\d+)?(\.\d+)?)/)) {
			return RegExp.$1;
		}
	}
	return 0;
}

function condense_path(path)
{
	path = FSO.GetAbsolutePathName(path);

	if (path.substr(0, CWD.length).toLowerCase()
			== CWD.toLowerCase() &amp;&amp;
			(path.charCodeAt(CWD.length) == 92 || path.charCodeAt(CWD.length) == 47)) {
		return path.substr(CWD.length + 1);
	}

	var a = CWD.split(&quot;\\&quot;);
	var b = path.split(&quot;\\&quot;);
	var i, j;

	for (i = 0; i &lt; b.length; i++) {
		if (a[i].toLowerCase() == b[i].toLowerCase())
			continue;
		if (i &gt; 0) {
			/* first difference found */
			path = &quot;&quot;;
			for (j = 0; j &lt; a.length - i; j++) {
				path += &quot;..\\&quot;;
			}
			for (j = i; j &lt; b.length; j++) {
				path += b[j];
				if (j &lt; b.length - 1)
					path += &quot;\\&quot;;
			}
			return path;
		}
		/* on a different drive */
		break;
	}

	return path;
}

function ConfigureArg(type, optname, helptext, defval)
{
	var opptype = type == &quot;enable&quot; ? &quot;disable&quot; : &quot;without&quot;;

	if (defval == &quot;yes&quot; || defval == &quot;yes,shared&quot;) {
		this.arg = &quot;--&quot; + opptype + &quot;-&quot; + optname;
		this.imparg = &quot;--&quot; + type + &quot;-&quot; + optname;
	} else {
		this.arg = &quot;--&quot; + type + &quot;-&quot; + optname;
		this.imparg = &quot;--&quot; + opptype + &quot;-&quot; + optname;
	}

	this.optname = optname;
	this.helptext = helptext;
	this.defval = defval;
	this.symval = optname.toUpperCase().replace(new RegExp(&quot;-&quot;, &quot;g&quot;), &quot;_&quot;);
	this.seen = false;
	this.argval = defval;
}

function ARG_WITH(optname, helptext, defval)
{
	configure_args[configure_args.length] = new ConfigureArg(&quot;with&quot;, optname, helptext, defval);
}

function ARG_ENABLE(optname, helptext, defval)
{
	configure_args[configure_args.length] = new ConfigureArg(&quot;enable&quot;, optname, helptext, defval);
}

function analyze_arg(argval)
{
	var ret = new Array();
	var shared = false;

	if (argval == &quot;shared&quot;) {
		shared = true;
		argval = &quot;yes&quot;;
	} else if (argval == null) {
		/* nothing */
	} else if (arg_match = argval.match(new RegExp(&quot;^shared,(.*)&quot;))) {
		shared = true;
		argval = arg_match[1];
	} else if (arg_match = argval.match(new RegExp(&quot;^(.*),shared$&quot;))) {
		shared = true;
		argval = arg_match[1];
	}

	ret[0] = shared;
	ret[1] = argval;
	return ret;
}

function word_wrap_and_indent(indent, text, line_suffix, indent_char)
{
	if (text == null) {
		return &quot;&quot;;
	}

	var words = text.split(new RegExp(&quot;\\s+&quot;, &quot;g&quot;));
	var i = 0;
	var ret_text = &quot;&quot;;
	var this_line = &quot;&quot;;
	var t;
	var space = &quot;&quot;;
	var lines = 0;

	if (line_suffix == null) {
		line_suffix = &quot;&quot;;
	}

	if (indent_char == null) {
		indent_char = &quot; &quot;;
	}

	for (i = 0; i &lt; indent; i++) {
		space += indent_char;
	}

	for (i = 0; i &lt; words.length; i++) {
		if (this_line.length) {
			t = this_line + &quot; &quot; + words[i];
		} else {
			t = words[i];
		}

		if (t.length + indent &gt; 78) {
			if (lines++) {
				ret_text += space;
			}
			ret_text += this_line + line_suffix + &quot;\r\n&quot;;
			this_line = &quot;&quot;;
		}

		if (this_line.length) {
			this_line += &quot; &quot; + words[i];
		} else {
			this_line = words[i];
		}
	}

	if (this_line.length) {
		if (lines)
			ret_text += space;
		ret_text += this_line;
	}

	return ret_text;
}

function conf_process_args()
{
	var i, j;
	var configure_help_mode = false;
	var analyzed = false;
	var nice = &quot;cscript /nologo /e:jscript configure.js &quot;;
	var disable_all = false;

	args = WScript.Arguments;
	for (i = 0; i &lt; args.length; i++) {
		arg = args(i);
		nice += &#039; &quot;&#039; + arg + &#039;&quot;&#039;;

		if (arg == &quot;--help&quot;) {
			configure_help_mode = true;
			break;
		}
		if (arg == &quot;--disable-all&quot;) {
			disable_all = true;
			continue;
		}

		// If it is --foo=bar, split on the equals sign
		arg = arg.split(&quot;=&quot;, 2);
		argname = arg[0];
		if (arg.length &gt; 1) {
			argval = arg[1];
		} else {
			argval = null;
		}

		// Find the arg
		found = false;
		for (j = 0; j &lt; configure_args.length; j++) {
			if (argname == configure_args[j].imparg || argname == configure_args[j].arg) {
				found = true;

				arg = configure_args[j];
				arg.seen = true;

				analyzed = analyze_arg(argval);

				/* Force shared when called after phpize */
				if (MODE_PHPIZE) {
					shared = &quot;shared&quot;;
				} else {
					shared = analyzed[0];
				}
				argval = analyzed[1];

				if (argname == arg.imparg) {
					/* we matched the implicit, or default arg */
					if (argval == null) {
						argval = arg.defval;
					}
				} else {
					/* we matched the non-default arg */
					if (argval == null) {
						if (arg.defval == &quot;no&quot;) {
							argval = &quot;yes&quot;;
						} else if (arg.defval == &quot;no,shared&quot;) {
							argval = &quot;yes,shared&quot;;
							shared = true;
						} else {
							argval = &quot;no&quot;;
						}
					}
				}

				arg.argval = argval;
				eval(&quot;PHP_&quot; + arg.symval + &quot; = argval;&quot;);
				eval(&quot;PHP_&quot; + arg.symval + &quot;_SHARED = shared;&quot;);
				break;
			}
		}
		if (!found) {
			INVALID_CONFIG_ARGS[INVALID_CONFIG_ARGS.length] = argname;
		}
	}

	if (PHP_SNAPSHOT_BUILD != &#039;no&#039; &amp;&amp; INVALID_CONFIG_ARGS.length) {
		STDERR.WriteLine(&#039;Unknown option &#039; + INVALID_CONFIG_ARGS[0] + &#039;; please try configure.js --help for a list of valid options&#039;);
		WScript.Quit(2);
	}

	if (configure_help_mode) {
		STDOUT.WriteLine(word_wrap_and_indent(0,
&quot;Options that enable extensions and SAPI will accept \
&#039;yes&#039; or &#039;no&#039; as a parameter.  They also accept &#039;shared&#039; \
as a synonym for &#039;yes&#039; and request a shared build of that \
module.  Not all modules can be built as shared modules; \
configure will display [shared] after the module name if \
can be built that way. \
&quot;
			));
		STDOUT.WriteBlankLines(1);

		// Measure width to pretty-print the output
		max_width = 0;
		for (i = 0; i &lt; configure_args.length; i++) {
			arg = configure_args[i];
			if (arg.arg.length &gt; max_width)
				max_width = arg.arg.length;
		}

		for (i = 0; i &lt; configure_args.length; i++) {
			arg = configure_args[i];

			n = max_width - arg.arg.length;
			pad = &quot;   &quot;;
			for (j = 0; j &lt; n; j++) {
				pad += &quot; &quot;;
			}
			STDOUT.WriteLine(&quot;  &quot; + arg.arg + pad + word_wrap_and_indent(max_width + 5, arg.helptext));
		}
		STDOUT.WriteBlankLines(1);
		STDOUT.WriteLine(&quot;Some influential environment variables:&quot;);
		STDOUT.WriteLine(&quot;  CFLAGS      C compiler flags&quot;);
		STDOUT.WriteLine(&quot;  LDFLAGS     linker flags&quot;);
		WScript.Quit(1);
	}

	var snapshot_build_exclusions = new Array(
		&#039;debug&#039;, &#039;lzf-better-compression&#039;, &#039;php-build&#039;, &#039;snapshot-template&#039;, &#039;zts&#039;,
		&#039;ipv6&#039;, &#039;fd-setsize&#039;, &#039;pgi&#039;, &#039;pgo&#039;, &#039;all-shared&#039;, &#039;config-profile&#039;, &#039;sanitizer&#039;,
		&#039;phpdbg-debug&#039;, &#039;openssl-legacy-provider&#039;
	);
	var force;

	// Now set any defaults we might have missed out earlier
	for (i = 0; i &lt; configure_args.length; i++) {
		arg = configure_args[i];
		if (arg.seen)
			continue;
		analyzed = analyze_arg(arg.defval);
		shared = analyzed[0];
		argval = analyzed[1];

		// Don&#039;t trust a default &quot;yes&quot; answer for a non-core module
		// in a snapshot build
		if (PHP_SNAPSHOT_BUILD != &quot;no&quot; &amp;&amp; argval == &quot;yes&quot; &amp;&amp; !shared) {

			force = true;
			for (j = 0; j &lt; snapshot_build_exclusions.length; j++) {
				if (snapshot_build_exclusions[j] == arg.optname) {
					force = false;
					break;
				}
			}

			if (force) {
				/* now check if it is a core module */
				force = false;
				for (j = 0; j &lt; core_module_list.length; j++) {
					if (core_module_list[j] == arg.optname) {
						force = true;
						break;
					}
				}

				if (!force) {
					STDOUT.WriteLine(&quot;snapshot: forcing &quot; + arg.arg + &quot; shared&quot;);
					shared = true;
				}
			}
		}

		if (PHP_SNAPSHOT_BUILD != &quot;no&quot; &amp;&amp; argval == &quot;no&quot;) {
			force = true;
			for (j = 0; j &lt; snapshot_build_exclusions.length; j++) {
				if (snapshot_build_exclusions[j] == arg.optname) {
					force = false;
					break;
				}
			}
			if (force) {
				STDOUT.WriteLine(&quot;snapshot: forcing &quot; + arg.optname + &quot; on&quot;);
				argval = &quot;yes&quot;;
				shared = true;
			}
		}

		if (disable_all) {
			force = true;
			for (j = 0; j &lt; snapshot_build_exclusions.length; j++) {
				if (snapshot_build_exclusions[j] == arg.optname) {
					force = false;
					break;
				}
			}
			if (force) {
				if (arg.defval == &#039;&#039;) {
					argval = &#039;&#039;;
				} else {
					argval = &quot;no&quot;;
				}
				shared = false;
			}
		}

		eval(&quot;PHP_&quot; + arg.symval + &quot; = argval;&quot;);
		eval(&quot;PHP_&quot; + arg.symval + &quot;_SHARED = shared;&quot;);
	}

	MFO = FSO.CreateTextFile(&quot;Makefile.objects&quot;, true);

	var profile = false;

	if (PHP_CONFIG_PROFILE != &#039;no&#039;) {
		if (PHP_CONFIG_PROFILE.toLowerCase() == &#039;nice&#039;) {
			WARNING(&#039;Config profile name cannot be named \&#039;nice\&#039;&#039;);
		} else {
			var config_profile = FSO.CreateTextFile(&#039;config.&#039; + PHP_CONFIG_PROFILE + &#039;.bat&#039;, true);

			config_profile.WriteLine(&#039;@echo off&#039;);
			config_profile.WriteLine(nice + &#039; %*&#039;);
			config_profile.Close();

			profile = true;
		}
	}

	// Only generate an updated config.nice.bat file if a profile was not used
	if (!profile) {
		STDOUT.WriteLine(&quot;Saving configure options to config.nice.bat&quot;);

		var nicefile = FSO.CreateTextFile(&quot;config.nice.bat&quot;, true);
		nicefile.WriteLine(&#039;@echo off&#039;);
		nicefile.WriteLine(nice +  &quot; %*&quot;);
		nicefile.Close();
	}

	AC_DEFINE(&#039;CONFIGURE_COMMAND&#039;, nice, &quot;Configure line&quot;);
}

function DEFINE(name, value)
{
	if (configure_subst.Exists(name)) {
		configure_subst.Remove(name);
	}
	configure_subst.Add(name, value);
}

function verbalize_deps_path(path)
{
	var absolute_path = FSO.GetAbsolutePathName(path);

	if (absolute_path.indexOf(PHP_PHP_BUILD) == 0) {
		absolute_path = absolute_path.substring(PHP_PHP_BUILD.length).split(&#039;\\&#039;);

		if (absolute_path[1] == &#039;include&#039; || absolute_path[1] == &#039;lib&#039;) {
			return &quot;&lt;in deps path&gt; &quot; + absolute_path.join(&#039;\\&#039;);
		}
	}

	return path;
}

// Searches a set of paths for a file;
// returns the dir in which the file was found,
// true if it was found in the default env path,
// or false if it was not found at all.
// env_name is the optional name of an env var
// specifying the default path to search
function search_paths(thing_to_find, explicit_path, env_name)
{
	var i, found = false, place = false, file, env;

	STDOUT.Write(&quot;Checking for &quot; + thing_to_find + &quot; ... &quot;);

	thing_to_find = thing_to_find.replace(new RegExp(&quot;/&quot;, &quot;g&quot;), &quot;\\&quot;);

	if (explicit_path != null) {
		if (typeof(explicit_path) == &quot;string&quot;) {
			explicit_path = explicit_path.split(&quot;;&quot;);
		}

		for (i = 0; i &lt; explicit_path.length; i++) {
			file = glob(explicit_path[i] + &quot;\\&quot; + thing_to_find);
			if (file) {
				found = true;
				place = file[0];
				place = place.substr(0, place.length - thing_to_find.length - 1);
				break;
			}
		}
	}

	if (!found &amp;&amp; env_name != null) {
		env = WshShell.Environment(&quot;Process&quot;).Item(env_name);
		env = env.split(&quot;;&quot;);
		for (i = 0; i &lt; env.length; i++) {
			file = glob(env[i] + &quot;\\&quot; + thing_to_find);
			if (file) {
				found = true;
				place = true;
				break;
			}
		}
	}

	if (found &amp;&amp; place == true) {
		STDOUT.WriteLine(&quot; &lt;in default path&gt;&quot;);
	} else if (found) {
		STDOUT.WriteLine(&quot; &quot; + verbalize_deps_path(place));
	} else {
		STDOUT.WriteLine(&quot; &lt;not found&gt;&quot;);
	}
	return place;
}

function PATH_PROG(progname, additional_paths, symbol)
{
	var exe;
	var place;
	var cyg_path = PHP_CYGWIN + &quot;\\bin;&quot; + PHP_CYGWIN + &quot;\\usr\\local\\bin&quot;;
	var php_build_bin_path = PHP_PHP_BUILD + &quot;\\bin&quot;

	exe = progname + &quot;.exe&quot;;

	if (additional_paths == null) {
		additional_paths = cyg_path;
	} else {
		additional_paths += &quot;;&quot; + cyg_path;
	}

	additional_paths = additional_paths + &quot;;&quot; + php_build_bin_path;

	place = search_paths(exe, additional_paths, &quot;PATH&quot;);

	if (place == true) {
		place = exe;
	} else if (place != false) {
		place = place + &quot;\\&quot; + exe;
	}

	if (place) {
		if (symbol == null) {
			symbol = progname.toUpperCase();
		}
		DEFINE(symbol, place);
	}
	return place;
}

function find_pattern_in_path(pattern, path)
{
	if (path == null) {
		return false;
	}

	var dirs = path.split(&#039;;&#039;);
	var i;
	var items;

	for (i = 0; i &lt; dirs.length; i++) {
		items = glob(dirs[i] + &quot;\\&quot; + pattern);
		if (items) {
			return condense_path(items[0]);
		}
	}
	return false;
}

function copy_dep_pdb_into_build_dir(libpath)
{
	var candidate;
	var build_dir = get_define(&quot;BUILD_DIR&quot;);
	var libdir = FSO.GetParentFolderName(libpath);
	var bindir = FSO.GetAbsolutePathName(libdir + &quot;\\..\\bin&quot;);

	var names = [];

	var libname = FSO.GetFileName(libpath);

	/* Within same .lib, everything should be bound to the same .pdb. No check
		for every single object in the static libs. */
	var _tmp = execute(&quot;dumpbin /section:.debug$T /rawdata:1,256 &quot; + libpath);
	if (!_tmp.match(&quot;LNK4039&quot;)) {
		if (_tmp.match(/\d{2,}:\s+([a-z0-9\s]+)/i)) {
			var m = RegExp.$1;
			var a = m.split(/ /);
			var s = &quot;&quot;;
			for (var i in a) {
				s = s + String.fromCharCode(parseInt(&quot;0x&quot; + a[i]));
			}

			if (s.match(/([^\\]+\.pdb)/i)) {
				if (RegExp.$1 != names[0]) {
					names.push(RegExp.$1);
				}
			}
		}
	}

	/* This is rather a fallback, if the bin has no debug section or
		something went wrong with parsing. */
	names.push(libname.replace(new RegExp(&quot;\\.lib$&quot;), &quot;.pdb&quot;));

	for (var k = 0; k &lt; names.length; k++) {
		var pdbname = names[k];

		candidate = bindir + &quot;\\&quot; + pdbname;
		if (FSO.FileExists(candidate)) {
			FSO.CopyFile(candidate, build_dir + &quot;\\&quot; + pdbname, true);
			return true;
		}

		candidate = libdir + &quot;\\&quot; + pdbname;
		if (FSO.FileExists(candidate)) {
			FSO.CopyFile(candidate, build_dir + &quot;\\&quot; + pdbname, true);
			return true;
		}
	}

	return false;
}

function CHECK_LIB(libnames, target, path_to_check, common_name)
{
	STDOUT.Write(&quot;Checking for library &quot; + libnames + &quot; ... &quot;);

	if (common_name == null &amp;&amp; target != null) {
		common_name = target;
	}

	if (path_to_check == null) {
		path_to_check = &quot;&quot;;
	}

	// if they specified a common name for the package that contains
	// the library, tag some useful defaults on to the end of the
	// path to be searched
	if (common_name != null) {
		path_to_check += &quot;;&quot; + PHP_PHP_BUILD + &quot;\\&quot; + common_name + &quot;*&quot;;
		path_to_check += &quot;;&quot; + PHP_PHP_BUILD + &quot;\\lib\\&quot; + common_name + &quot;*&quot;;
		path_to_check += &quot;;..\\&quot; + common_name + &quot;*&quot;;
	}

	// Determine target for build flags
	if (target == null) {
		target = &quot;&quot;;
	} else {
		target = &quot;_&quot; + target.toUpperCase();
	}

	// Expand path to include general dirs
	path_to_check += &quot;;&quot; + php_usual_lib_suspects;

	// It is common practice to put libs under one of these dir names
	var subdirs = new Array(PHP_DEBUG == &quot;yes&quot; ? &quot;Debug&quot; : (PHP_DEBUG_PACK == &quot;yes&quot;?&quot;Release_Dbg&quot;:&quot;Release&quot;), &quot;lib&quot;, &quot;libs&quot;, &quot;libexec&quot;);

	// libnames can be ; separated list of accepted library names
	libnames = libnames.split(&#039;;&#039;);

	// for debug builds, lib may have _debug appended, we want that first
	if (PHP_DEBUG == &quot;yes&quot;) {
		var length = libnames.length;
		for (var i = 0; i &lt; length; i++) {
			var name = new String(libnames[i]);
			rExp = /.lib$/i;
			name = name.replace(rExp,&quot;_debug.lib&quot;);
			libnames.unshift(name);
		}
	}

	var i, j, k, libname;
	var location = false;
	var path = path_to_check.split(&#039;;&#039;);

	for (i = 0; i &lt; libnames.length; i++) {
		libname = libnames[i];

		for (k = 0; k &lt; path.length; k++) {
			location = glob(path[k] + &quot;\\&quot; + libname);
			if (location) {
				location = location[0];
				break;
			}
			for (j = 0; j &lt; subdirs.length; j++) {
				location = glob(path[k] + &quot;\\&quot; + subdirs[j] + &quot;\\&quot; + libname);
				if (location) {
					location = location[0];
					break;
				}
			}
			if (location)
				break;
		}

		if (location) {
			location = condense_path(location);
			var libdir = FSO.GetParentFolderName(location);
			libname = FSO.GetFileName(location);
			ADD_FLAG(&quot;LDFLAGS&quot; + target, &#039;/libpath:&quot;&#039; + libdir + &#039;&quot; &#039;);
			ADD_FLAG(&quot;ARFLAGS&quot; + target, &#039;/libpath:&quot;&#039; + libdir + &#039;&quot; &#039;);
			ADD_FLAG(&quot;LIBS&quot; + target, libname);

			STDOUT.WriteLine(verbalize_deps_path(location));

			copy_dep_pdb_into_build_dir(location);

			return location;
		}

		// Check in their standard lib path
		location = find_pattern_in_path(libname, WshShell.Environment(&quot;Process&quot;).Item(&quot;LIB&quot;));

		if (location) {
			location = condense_path(location);
			libname = FSO.GetFileName(location);
			ADD_FLAG(&quot;LIBS&quot; + target, libname);

			STDOUT.WriteLine(&quot;&lt;in LIB path&gt; &quot; + libname);

			return location;
		}

		// Check in their general extra libs path
		location = find_pattern_in_path(libname, PHP_EXTRA_LIBS);
		if (location) {
			location = condense_path(location);
			libname = FSO.GetFileName(location);
			ADD_FLAG(&quot;LIBS&quot; + target, libname);
			STDOUT.WriteLine(&quot;&lt;in extra libs path&gt;&quot;);
			copy_dep_pdb_into_build_dir(location);
			return location;
		}
	}

	STDOUT.WriteLine(&quot;&lt;not found&gt;&quot;);

	return false;
}

function OLD_CHECK_LIB(libnames, target, path_to_check)
{
	if (target == null) {
		target = &quot;&quot;;
	} else {
		target = &quot;_&quot; + target.toUpperCase();
	}

	if (path_to_check == null) {
		path_to_check = php_usual_lib_suspects;
	} else {
		path_to_check += &quot;;&quot; + php_usual_lib_suspects;
	}
	var have = 0;
	var p;
	var i;
	var libname;

	var subdir = PHP_DEBUG == &quot;yes&quot; ? &quot;Debug&quot; : (PHP_DEBUG_PACK == &quot;yes&quot;?&quot;Release_Dbg&quot;:&quot;Release&quot;);

	libnames = libnames.split(&#039;;&#039;);
	for (i = 0; i &lt; libnames.length; i++) {
		libname = libnames[i];
		p = search_paths(libname, path_to_check, &quot;LIB&quot;);

		if (!p) {
			p = search_paths(subdir + &quot;\\&quot; + libname, path_to_check, &quot;LIB&quot;);
			if (p) {
				p += &quot;\\&quot; + subdir;
			}
		}

		if (typeof(p) == &quot;string&quot;) {
			ADD_FLAG(&quot;LDFLAGS&quot; + target, &#039;/libpath:&quot;&#039; + p + &#039;&quot; &#039;);
			ADD_FLAG(&quot;ARFLAGS&quot; + target, &#039;/libpath:&quot;&#039; + p + &#039;&quot; &#039;);
			ADD_FLAG(&quot;LIBS&quot; + target, libname);
			have = 1;
		} else if (p == true) {
			ADD_FLAG(&quot;LIBS&quot; + target, libname);
			have = 1;
		} else {
			/* not found in the defaults or the explicit paths,
			 * so check the general extra libs; if we find
			 * it here, no need to add another /libpath: for it as we
			 * already have it covered, but we need to add the lib
			 * to LIBS_XXX */
			if (false != search_paths(libname, PHP_EXTRA_LIBS, null)) {
				ADD_FLAG(&quot;LIBS&quot; + target, libname);
				have = 1;
			}
		}

		if (have) {
			break;
		}
	}

//	AC_DEFINE(&quot;HAVE_&quot; + header_name.toUpperCase().replace(new RegExp(&quot;/\\\\-\.&quot;, &quot;g&quot;), &quot;_&quot;), have);

	return have;

}

function CHECK_FUNC_IN_HEADER(header_name, func_name, path_to_check, add_to_flag)
{
	var c = false;
	var sym;

	STDOUT.Write(&quot;Checking for &quot; + func_name + &quot; in &quot; + header_name + &quot; ... &quot;);

	c = GREP_HEADER(header_name, func_name, path_to_check);

	sym = func_name.toUpperCase();
	sym = sym.replace(new RegExp(&quot;[\\\\/\.-]&quot;, &quot;g&quot;), &quot;_&quot;);

	if (typeof(add_to_flag) == &quot;undefined&quot;) {
		AC_DEFINE(&quot;HAVE_&quot; + sym, c ? 1 : 0);
	} else {
		ADD_FLAG(add_to_flag, &quot;/DHAVE_&quot; + sym + &quot;=&quot; + (c ? &quot;1&quot; : &quot;0&quot;));
	}

	if (c) {
		STDOUT.WriteLine(&quot;OK&quot;);
		return c;
	}
	STDOUT.WriteLine(&quot;No&quot;);
	return false;
}

function GREP_HEADER(header_name, regex, path_to_check)
{
	var c = false;

	if (FSO.FileExists(path_to_check + &quot;\\&quot; + header_name)) {
		c = file_get_contents(path_to_check + &quot;\\&quot; + header_name);
	}

	if (!c) {
		/* look in the include path */
		if (path_to_check == null) {
			path_to_check = php_usual_include_suspects;
		} else {
			path_to_check += &quot;;&quot; + php_usual_include_suspects;
		}

		var p = search_paths(header_name, path_to_check, &quot;INCLUDE&quot;);
		if (typeof(p) == &quot;string&quot;) {
			c = file_get_contents(p + &quot;\\&quot; + header_name);
		} else if (p == false) {
			p = search_paths(header_name, PHP_EXTRA_INCLUDES, null);
			if (typeof(p) == &quot;string&quot;) {
				c = file_get_contents(p + &quot;\\&quot; + header_name);
			}
		}
		if (!c) {
			return false;
		}
	}

	if (typeof(regex) == &quot;string&quot;) {
		regex = new RegExp(regex);
	}

	if (c.match(regex)) {
		/* caller can now use RegExp.$1 etc. to get at patterns */
		return true;
	}
	return false;
}

function CHECK_HEADER_ADD_INCLUDE(header_name, flag_name, path_to_check, use_env, add_dir_part, add_to_flag_only)
{
	var dir_part_to_add = &quot;&quot;;

	if (use_env == null) {
		use_env = true;
	}

	// if true, add the dir part of the header_name to the include path
	if (add_dir_part == null) {
		add_dir_part = false;
	} else if (add_dir_part) {
		var basename = FSO.GetFileName(header_name);
		dir_part_to_add = &quot;\\&quot; + header_name.substr(0, header_name.length - basename.length - 1);
	}

	if (path_to_check == null) {
		path_to_check = php_usual_include_suspects;
	} else {
		path_to_check += &quot;;&quot; + php_usual_include_suspects;
	}

	var p = search_paths(header_name, path_to_check, use_env ? &quot;INCLUDE&quot; : null);
	var have = 0;
	var sym;

	if (typeof(p) == &quot;string&quot;) {
		ADD_FLAG(flag_name, &#039;/I &quot;&#039; + p + dir_part_to_add + &#039;&quot; &#039;);
	} else if (p == false) {
		/* Not found in the defaults or the explicit paths,
		 * so check the general extra includes; if we find
		 * it here, no need to add another /I for it as we
		 * already have it covered, unless we are adding
		 * the dir part.... */
		p = search_paths(header_name, PHP_EXTRA_INCLUDES, null);
		if (typeof(p) == &quot;string&quot; &amp;&amp; add_dir_part) {
			ADD_FLAG(flag_name, &#039;/I &quot;&#039; + p + dir_part_to_add + &#039;&quot; &#039;);
		}
	}
	have = p ? 1 : 0

	sym = header_name.toUpperCase();
	sym = sym.replace(new RegExp(&quot;[\\\\/\.-]&quot;, &quot;g&quot;), &quot;_&quot;);

	if (typeof(add_to_flag_only) == &quot;undefined&quot; &amp;&amp;
			flag_name.match(new RegExp(&quot;^CFLAGS_(.*)$&quot;))) {
		add_to_flag_only = true;
	}

	if (typeof(add_to_flag_only) != &quot;undefined&quot; &amp;&amp; have) {
		ADD_FLAG(flag_name, &quot;/DHAVE_&quot; + sym + &quot;=&quot; + have);
	} else if (!configure_hdr.Exists(&#039;HAVE_&#039; + sym) &amp;&amp; have) {
		AC_DEFINE(&quot;HAVE_&quot; + sym, have, &quot;Define to 1 if you have the &lt;&quot; + header_name + &quot;&gt; header file.&quot;);
	}

	return p;
}

/* XXX check whether some manifest was originally supplied, otherwise keep using the default. */
function generate_version_info_manifest(makefiletarget)
{
	var manifest_name = makefiletarget + &quot;.manifest&quot;;

	if (MODE_PHPIZE) {
		MFO.WriteLine(&quot;$(BUILD_DIR)\\&quot; + manifest_name + &quot;: &quot; + PHP_DIR + &quot;\\build\\default.manifest&quot;);
		MFO.WriteLine(&quot;\t&quot; + CMD_MOD2 + &quot;copy &quot; + PHP_DIR + &quot;\\build\\default.manifest $(BUILD_DIR)\\&quot; + makefiletarget + &quot;.manifest &gt;nul&quot;);
	} else {
		MFO.WriteLine(&quot;$(BUILD_DIR)\\&quot; + manifest_name + &quot;: win32\\build\\default.manifest&quot;);
		MFO.WriteLine(&quot;\t&quot; + CMD_MOD2 + &quot;copy $(PHP_SRC_DIR)\\win32\\build\\default.manifest $(BUILD_DIR)\\&quot; + makefiletarget + &quot;.manifest &gt;nul&quot;);
	}

	return manifest_name;
}

/* Emits rule to generate version info for a SAPI
 * or extension.  Returns the name of the .res file
 * that will be generated */
function generate_version_info_resource(makefiletarget, basename, creditspath, sapi)
{
	var resname = makefiletarget + &quot;.res&quot;;
	var res_desc = makefiletarget;
	var res_prod_name = &quot;PHP &quot; + makefiletarget;
	var credits;
	var thanks = &quot;&quot;;
	var logo = &quot;&quot;;
	var debug = &quot;&quot;;
	var project_url = &quot;https://www.php.net&quot;;
	var project_header = creditspath + &quot;/php_&quot; + basename + &quot;.h&quot;;
	var versioning = &quot;&quot;;

	if (sapi) {
		var internal_name = basename.toUpperCase() + &quot; SAPI&quot;;
	} else {
		var internal_name = basename.toUpperCase() + &quot; extension&quot;;
	}

	if (FSO.FileExists(creditspath + &#039;/CREDITS&#039;)) {
		credits = FSO.OpenTextFile(creditspath + &#039;/CREDITS&#039;, 1);
		res_desc = credits.ReadLine();
		try {
			thanks = credits.ReadLine();
		} catch (e) {
			thanks = null;
		}
		if (thanks == null) {
			thanks = &quot;&quot;;
		} else {
			thanks = &quot;Thanks to &quot; + thanks.replace(/([&lt;&gt;&amp;|%])/g, &quot;^$1&quot;).replace(/&quot;/g, &#039;\\&quot;\\&quot;&#039;);
		}
		credits.Close();
	}

	if (creditspath.match(new RegExp(&quot;pecl&quot;))) {
		/* PECL project url - this will eventually work correctly for all */
		project_url = &quot;https://pecl.php.net/&quot; + basename;

		/* keep independent versioning PECL-specific for now */
		if (FSO.FileExists(project_header)) {
			if (header = FSO.OpenTextFile(project_header, 1)) {
				contents = header.ReadAll();
				/* allowed: x.x.x[a|b|-alpha|-beta][RCx][-dev] */
				if (contents.match(new RegExp(&#039;PHP_&#039; + basename.toUpperCase() + &#039;_VERSION(\\s+)&quot;((\\d+\.\\d+(\.\\d+)?)((a|b)(\\d)?|\-[a-z]{3,5})?(RC\\d+)?(\-dev)?)&#039;))) {
					project_version = RegExp.$2;
					file_version = RegExp.$3.split(&#039;.&#039;);
					if (!file_version[2]) {
						file_version[2] = 0;
					}
					versioning = &#039;\\&quot;&quot; /d EXT_FILE_VERSION=&#039; + file_version[0] + &#039;,&#039; + file_version[1] + &#039;,&#039; + file_version[2] + &#039; /d EXT_VERSION=&quot;\\&quot;&#039; + project_version;
				}
				header.Close();
			}
		}
	}

	if (makefiletarget.match(new RegExp(&quot;\\.exe$&quot;))) {
		logo = &quot; /d WANT_LOGO &quot;;
	}

	if (PHP_DEBUG != &quot;no&quot;) {
		debug = &quot; /d _DEBUG&quot;;
	}

	/**
	 * Use user supplied template.rc if it exists
	 */
	if (FSO.FileExists(creditspath + &#039;\\template.rc&#039;)) {
		MFO.WriteLine(&quot;$(BUILD_DIR)\\&quot; + resname + &quot;: &quot; + creditspath + &quot;\\template.rc&quot;);
		MFO.WriteLine(&quot;\t&quot; + CMD_MOD1 + &quot;$(RC) /nologo $(BASE_INCLUDES) /fo $(BUILD_DIR)\\&quot; + resname + logo + debug +
			&#039; /d FILE_DESCRIPTION=&quot;\\&quot;&#039; + res_desc + &#039;\\&quot;&quot; /d FILE_NAME=&quot;\\&quot;&#039; +
			makefiletarget + &#039;\\&quot;&quot; /d PRODUCT_NAME=&quot;\\&quot;&#039; + res_prod_name +
			versioning + &#039;\\&quot;&quot; /d THANKS_GUYS=&quot;\\&quot;&#039; + thanks + &#039;\\&quot;&quot; &#039; +
			creditspath + &#039;\\template.rc&#039;);
		return resname;
	}
	if (MODE_PHPIZE) {
		MFO.WriteLine(&quot;$(BUILD_DIR)\\&quot; + resname + &quot;: $(PHP_DIR)\\build\\template.rc&quot;);
		MFO.WriteLine(&quot;\t&quot; + CMD_MOD1 + &quot;$(RC) /nologo  $(BASE_INCLUDES) /I $(PHP_DIR)/include /n /fo $(BUILD_DIR)\\&quot; + resname + logo + debug +
			&#039; /d FILE_DESCRIPTION=&quot;\\&quot;&#039; + res_desc + &#039;\\&quot;&quot; /d FILE_NAME=&quot;\\&quot;&#039;
			+ makefiletarget + &#039;\\&quot;&quot; /d URL=&quot;\\&quot;&#039; + project_url +
			&#039;\\&quot;&quot; /d INTERNAL_NAME=&quot;\\&quot;&#039; + internal_name + versioning +
			&#039;\\&quot;&quot; /d THANKS_GUYS=&quot;\\&quot;&#039; + thanks + &#039;\\&quot;&quot; $(PHP_DIR)\\build\\template.rc&#039;);
	} else {
		MFO.WriteLine(&quot;$(BUILD_DIR)\\&quot; + resname + &quot;: win32\\build\\template.rc&quot;);
		MFO.WriteLine(&quot;\t&quot; + CMD_MOD1 + &quot;$(RC) /nologo  $(BASE_INCLUDES) /n /fo $(BUILD_DIR)\\&quot; + resname + logo + debug +
			&#039; /d FILE_DESCRIPTION=&quot;\\&quot;&#039; + res_desc + &#039;\\&quot;&quot; /d FILE_NAME=&quot;\\&quot;&#039;
			+ makefiletarget + &#039;\\&quot;&quot; /d URL=&quot;\\&quot;&#039; + project_url +
			&#039;\\&quot;&quot; /d INTERNAL_NAME=&quot;\\&quot;&#039; + internal_name + versioning +
			&#039;\\&quot;&quot; /d THANKS_GUYS=&quot;\\&quot;&#039; + thanks + &#039;\\&quot;&quot; win32\\build\\template.rc&#039;);
	}
	MFO.WriteBlankLines(1);
	return resname;
}

/* Check if PGO is enabled for given module. To disable PGO for a particular module,
define a global variable by the following name scheme before SAPI() or EXTENSION() call
var PHP_MYMODULE_PGO = false; */
function is_pgo_desired(mod)
{
	var varname = &quot;PHP_&quot; + mod.toUpperCase() + &quot;_PGO&quot;;

	/* XXX enable PGO in phpize mode */
	if (MODE_PHPIZE) {
		return false;
	}

	/* don&#039;t disable if there&#039;s no mention of the varname */
	if (eval(&quot;typeof &quot; + varname + &quot; == &#039;undefined&#039;&quot;)) {
		return true;
	}

	return eval(&quot;!!&quot; + varname);
}

function SAPI(sapiname, file_list, makefiletarget, cflags, obj_dir)
{
	var SAPI = sapiname.toUpperCase();
	var ldflags;
	var resname;
	var ld;
	var manifest;

	if (typeof(obj_dir) == &quot;undefined&quot;) {
		sapiname_for_printing = configure_module_dirname;
	} else {
		sapiname_for_printing = configure_module_dirname + &quot; (via &quot; + obj_dir + &quot;)&quot;;
	}

	STDOUT.WriteLine(&quot;Enabling SAPI &quot; + sapiname_for_printing);

	MFO.WriteBlankLines(1);
	MFO.WriteLine(&quot;# objects for SAPI &quot; + sapiname);
	MFO.WriteBlankLines(1);

	if (cflags) {
		ADD_FLAG(&#039;CFLAGS_&#039; + SAPI, cflags);
	}

	ADD_SOURCES(configure_module_dirname, file_list, sapiname, obj_dir);
	MFO.WriteBlankLines(1);
	MFO.WriteLine(&quot;# SAPI &quot; + sapiname);
	MFO.WriteBlankLines(1);

	/* generate a .res file containing version information */
	resname = generate_version_info_resource(makefiletarget, sapiname, configure_module_dirname, true);

	manifest_name = generate_version_info_manifest(makefiletarget);

	MFO.WriteLine(makefiletarget + &quot;: $(BUILD_DIR)\\&quot; + makefiletarget);
	MFO.WriteLine(&quot;\t&quot; + CMD_MOD2 + &quot;echo SAPI &quot; + sapiname_for_printing + &quot; build complete&quot;);
	if (MODE_PHPIZE) {
		MFO.WriteLine(&quot;$(BUILD_DIR)\\&quot; + makefiletarget + &quot;: $(DEPS_&quot; + SAPI + &quot;) $(&quot; + SAPI + &quot;_GLOBAL_OBJS) $(PHPLIB) $(BUILD_DIR)\\&quot; + resname + &quot; $(BUILD_DIR)\\&quot; + manifest_name);
	} else {
		MFO.WriteLine(&quot;$(BUILD_DIR)\\&quot; + makefiletarget + &quot;: $(DEPS_&quot; + SAPI + &quot;) $(&quot; + SAPI + &quot;_GLOBAL_OBJS) $(BUILD_DIR)\\$(PHPLIB) $(BUILD_DIR)\\&quot; + resname  + &quot; $(BUILD_DIR)\\&quot; + manifest_name);
	}

	var is_lib = makefiletarget.match(new RegExp(&quot;\\.lib$&quot;));
	if (makefiletarget.match(new RegExp(&quot;\\.dll$&quot;))) {
		ldflags = &quot;/dll $(LDFLAGS)&quot;;
		manifest = &quot;-&quot; + CMD_MOD2 + &quot;$(_VC_MANIFEST_EMBED_DLL)&quot;;
	} else if (is_lib) {
		ldflags = &quot;$(ARFLAGS)&quot;;
		ld = CMD_MOD1 + &quot;$(MAKE_LIB)&quot;;
	} else {
		ldflags = &quot;$(LDFLAGS)&quot;;
		manifest = &quot;-&quot; + CMD_MOD2 + &quot;$(_VC_MANIFEST_EMBED_EXE)&quot;;
	}

	if (PHP_SANITIZER == &quot;yes&quot;) {
		if (CLANG_TOOLSET) {
			add_asan_opts(&quot;CFLAGS_&quot; + SAPI, &quot;LIBS_&quot; + SAPI, (is_lib ? &quot;ARFLAGS_&quot; : &quot;LDFLAGS_&quot;) + SAPI);
		}
	}

	if(is_pgo_desired(sapiname) &amp;&amp; (PHP_PGI == &quot;yes&quot; || PHP_PGO != &quot;no&quot;)) {
		// Add compiler and link flags if PGO options are selected
		if (PHP_DEBUG != &quot;yes&quot; &amp;&amp; PHP_PGI == &quot;yes&quot;) {
			ADD_FLAG(&#039;CFLAGS_&#039; + SAPI, &quot;/GL /O2&quot;);
			ADD_FLAG(&#039;LDFLAGS_&#039; + SAPI, &quot;/LTCG /GENPROFILE&quot;);
			ADD_FLAG(&#039;LDFLAGS_&#039; + SAPI, &quot;/d2:-FuncCache1&quot;);
		}
		else if (PHP_DEBUG != &quot;yes&quot; &amp;&amp; PHP_PGO != &quot;no&quot;) {
			ADD_FLAG(&#039;CFLAGS_&#039; + SAPI, &quot;/GL /O2&quot;);
			ADD_FLAG(&#039;LDFLAGS_&#039; + SAPI, &quot;/LTCG /USEPROFILE&quot;);
			ADD_FLAG(&#039;LDFLAGS_&#039; + SAPI, &quot;/d2:-FuncCache1&quot;);
		}

		ldflags += &quot; /PGD:$(PGOPGD_DIR)\\&quot; + makefiletarget.substring(0, makefiletarget.indexOf(&quot;.&quot;)) + &quot;.pgd&quot;;
	}

	if (MODE_PHPIZE) {
		if (ld) {
			MFO.WriteLine(&quot;\t&quot; + ld + &quot; /nologo /out:$(BUILD_DIR)\\&quot; + makefiletarget + &quot; &quot; + ldflags + &quot; $(&quot; + SAPI + &quot;_GLOBAL_OBJS_RESP) $(PHPLIB) $(ARFLAGS_&quot; + SAPI + &quot;) $(LIBS_&quot; + SAPI + &quot;) $(BUILD_DIR)\\&quot; + resname);
		} else {
			ld = CMD_MOD1 + &#039;&quot;$(LINK)&quot;&#039;;
			MFO.WriteLine(&quot;\t&quot; + ld + &quot; /nologo &quot; + &quot; $(&quot; + SAPI + &quot;_GLOBAL_OBJS_RESP) $(PHPLIB) $(LIBS_&quot; + SAPI + &quot;) $(BUILD_DIR)\\&quot; + resname + &quot; /out:$(BUILD_DIR)\\&quot; + makefiletarget + &quot; &quot; + ldflags + &quot; $(LDFLAGS_&quot; + SAPI + &quot;)&quot;);
		}
	} else {
		if (ld) {
			MFO.WriteLine(&quot;\t&quot; + ld + &quot; /nologo /out:$(BUILD_DIR)\\&quot; + makefiletarget + &quot; &quot; + ldflags + &quot; $(&quot; + SAPI + &quot;_GLOBAL_OBJS_RESP) $(BUILD_DIR)\\$(PHPLIB) $(ARFLAGS_&quot; + SAPI + &quot;) $(LIBS_&quot; + SAPI + &quot;) $(BUILD_DIR)\\&quot; + resname);
		} else {
			ld = CMD_MOD1 + &#039;&quot;$(LINK)&quot;&#039;;
			MFO.WriteLine(&quot;\t&quot; + ld + &quot; /nologo &quot; + &quot; $(&quot; + SAPI + &quot;_GLOBAL_OBJS_RESP) $(BUILD_DIR)\\$(PHPLIB) $(LIBS_&quot; + SAPI + &quot;) $(BUILD_DIR)\\&quot; + resname + &quot; /out:$(BUILD_DIR)\\&quot; + makefiletarget + &quot; &quot; + ldflags + &quot; $(LDFLAGS_&quot; + SAPI + &quot;)&quot;);
		}
	}

	if (manifest) {
		MFO.WriteLine(&quot;\t&quot; + manifest);
	}

	DEFINE(&#039;CFLAGS_&#039; + SAPI + &#039;_OBJ&#039;, &#039;$(CFLAGS_&#039; + SAPI + &#039;)&#039;);

	if (configure_module_dirname.match(&quot;pecl&quot;)) {
		ADD_FLAG(&quot;PECL_TARGETS&quot;, makefiletarget);
	} else {
		ADD_FLAG(&quot;SAPI_TARGETS&quot;, makefiletarget);
	}

	MFO.WriteBlankLines(1);
	sapi_enabled[sapi_enabled.length] = [sapiname];
}

function ADD_DIST_FILE(filename)
{
	if (configure_module_dirname.match(&quot;pecl&quot;)) {
		ADD_FLAG(&quot;PECL_EXTRA_DIST_FILES&quot;, filename);
	} else {
		ADD_FLAG(&quot;PHP_EXTRA_DIST_FILES&quot;, filename);
	}
}

function file_get_contents(filename)
{
	var f, c;
	try {
		f = FSO.OpenTextFile(filename, 1);
		c = f.ReadAll();
		f.Close();
		return c;
	} catch (e) {
		STDOUT.WriteLine(&quot;Problem reading &quot; + filename);
		return false;
	}
}

// Add a dependency on another extension, so that
// the dependencies are built before extname
function ADD_EXTENSION_DEP(extname, dependson, optional)
{
	var EXT = extname.toUpperCase();
	var DEP = dependson.toUpperCase();
	var dep_present = false;
	var dep_shared = false;

	try {
		dep_present = eval(&quot;PHP_&quot; + DEP);

		if (dep_present != &quot;no&quot;) {
			try {
				dep_shared = eval(&quot;PHP_&quot; + DEP + &quot;_SHARED&quot;);
			} catch (e) {
				dep_shared = false;
			}
		}

	} catch (e) {
		dep_present = &quot;no&quot;;
	}

	if (optional) {
		if (dep_present == &quot;no&quot;) {
			MESSAGE(&quot;\t&quot; + dependson + &quot; not found: &quot; + dependson + &quot; support in &quot; + extname + &quot; disabled&quot;);
			return false;
		}
	}

	var ext_shared = eval(&quot;PHP_&quot; + EXT + &quot;_SHARED&quot;);

	if (dep_shared) {
		if (!ext_shared) {
			if (optional) {
				MESSAGE(&quot;\tstatic &quot; + extname + &quot; cannot depend on shared &quot; + dependson + &quot;: &quot; + dependson + &quot;support disabled&quot;);
				return false;
			}
			ERROR(&quot;static &quot; + extname + &quot; cannot depend on shared &quot; + dependson);
		}

		ADD_FLAG(&quot;LIBS_&quot; + EXT, &quot;php_&quot; + dependson + &quot;.lib&quot;);
		if (MODE_PHPIZE) {
			ADD_FLAG(&quot;LDFLAGS_&quot; + EXT, &quot;/libpath:$(BUILD_DIR_DEV)\\lib&quot;);
			ADD_FLAG(&quot;DEPS_&quot; + EXT, &quot;$(BUILD_DIR_DEV)\\lib\\php_&quot; + dependson + &quot;.lib&quot;);
		} else {
			ADD_FLAG(&quot;LDFLAGS_&quot; + EXT, &quot;/libpath:$(BUILD_DIR)&quot;);
			ADD_FLAG(&quot;DEPS_&quot; + EXT, &quot;$(BUILD_DIR)\\php_&quot; + dependson + &quot;.lib&quot;);
		}

	} else {

		if (dep_present == &quot;no&quot;) {
			if (ext_shared) {
				WARNING(extname + &quot; cannot be built: missing dependency, &quot; + dependson + &quot; not found&quot;);

				var dllname = &#039; php_&#039; + extname + &#039;.dll&#039;;

				if (!REMOVE_TARGET(dllname, &#039;EXT_TARGETS&#039;)) {
					REMOVE_TARGET(dllname, &#039;PECL_TARGETS&#039;);
				}

				return false;

			}

			ERROR(&quot;Cannot build &quot; + extname + &quot;; &quot; + dependson + &quot; not enabled&quot;);
			return false;
		}
	} // dependency is statically built-in to PHP
	return true;
}

var static_pgo_enabled = false;

function ZEND_EXTENSION(extname, file_list, shared, cflags, dllname, obj_dir)
{
	EXTENSION(extname, file_list, shared, cflags, dllname, obj_dir);

	extensions_enabled[extensions_enabled.length - 1][2] = true;
}

function EXTENSION(extname, file_list, shared, cflags, dllname, obj_dir)
{
	var objs = null;
	var EXT = extname.toUpperCase();
	var extname_for_printing;
	var ldflags;

	if (shared == null) {
		if (force_all_shared()) {
			shared = true;
			eval(&quot;PHP_&quot; + EXT + &quot;_SHARED = true;&quot;);
		} else {
			eval(&quot;shared = PHP_&quot; + EXT + &quot;_SHARED;&quot;);
		}
	} else {
		eval(&quot;PHP_&quot; + EXT + &quot;_SHARED = shared;&quot;);
	}

	if (cflags == null) {
		cflags = &quot;&quot;;
	}

	if (typeof(obj_dir) == &quot;undefined&quot;) {
		extname_for_printing = configure_module_dirname;
	} else {
		extname_for_printing = configure_module_dirname + &quot; (via &quot; + obj_dir + &quot;)&quot;;
	}

	if (shared) {
		STDOUT.WriteLine(&quot;Enabling extension &quot; + extname_for_printing + &quot; [shared]&quot;);
		cflags = &quot;/D ZEND_COMPILE_DL_EXT=1 /D COMPILE_DL_&quot; + EXT + &quot; /D &quot; + EXT + &quot;_EXPORTS=1 &quot; + cflags;
		ADD_FLAG(&quot;CFLAGS_PHP&quot;, &quot;/D COMPILE_DL_&quot; + EXT);
	} else {
		STDOUT.WriteLine(&quot;Enabling extension &quot; + extname_for_printing);
	}

	MFO.WriteBlankLines(1);
	MFO.WriteLine(&quot;# objects for EXT &quot; + extname);
	MFO.WriteBlankLines(1);

	ADD_SOURCES(configure_module_dirname, file_list, extname, obj_dir);

	MFO.WriteBlankLines(1);

	if (shared) {
		if (dllname == null) {
			dllname = &quot;php_&quot; + extname + &quot;.dll&quot;;
		}
		var libname = dllname.substring(0, dllname.length-4) + &quot;.lib&quot;;

		var resname = generate_version_info_resource(dllname, extname, configure_module_dirname, false);
		var ld = CMD_MOD1 + &#039;&quot;$(LINK)&quot;&#039;;
		var manifest_name = generate_version_info_manifest(dllname);

		ldflags = &quot;&quot;;
		if (is_pgo_desired(extname) &amp;&amp; (PHP_PGI == &quot;yes&quot; || PHP_PGO != &quot;no&quot;)) {
			// Add compiler and link flags if PGO options are selected
			if (PHP_DEBUG != &quot;yes&quot; &amp;&amp; PHP_PGI == &quot;yes&quot;) {
				ADD_FLAG(&#039;LDFLAGS_&#039; + EXT, &quot;/LTCG /GENPROFILE&quot;);
				ADD_FLAG(&#039;LDFLAGS_&#039; + EXT, &quot;/d2:-FuncCache1&quot;);
			}
			else if (PHP_DEBUG != &quot;yes&quot; &amp;&amp; PHP_PGO != &quot;no&quot;) {
				ADD_FLAG(&#039;LDFLAGS_&#039; + EXT, &quot;/LTCG /USEPROFILE&quot;);
				ADD_FLAG(&#039;LDFLAGS_&#039; + EXT, &quot;/d2:-FuncCache1&quot;);
			}

			ADD_FLAG(&#039;CFLAGS_&#039; + EXT, &quot;/GL /O2&quot;);

			ldflags = &quot; /PGD:$(PGOPGD_DIR)\\&quot; + dllname.substring(0, dllname.indexOf(&quot;.&quot;)) + &quot;.pgd&quot;;
		}

		MFO.WriteLine(&quot;$(BUILD_DIR)\\&quot; + libname + &quot;: $(BUILD_DIR)\\&quot; + dllname);
		MFO.WriteBlankLines(1);
		if (MODE_PHPIZE) {
			MFO.WriteLine(&quot;$(BUILD_DIR)\\&quot; + dllname + &quot;: $(DEPS_&quot; + EXT + &quot;) $(&quot; + EXT + &quot;_GLOBAL_OBJS) $(PHPLIB) $(BUILD_DIR)\\&quot; + resname + &quot; $(BUILD_DIR)\\&quot; + manifest_name);
			MFO.WriteLine(&quot;\t&quot; + ld + &quot; $(&quot; + EXT + &quot;_GLOBAL_OBJS_RESP) $(PHPLIB) $(LIBS_&quot; + EXT + &quot;) $(LIBS) $(BUILD_DIR)\\&quot; + resname + &quot; /out:$(BUILD_DIR)\\&quot; + dllname + &quot; $(DLL_LDFLAGS) $(LDFLAGS) $(LDFLAGS_&quot; + EXT + &quot;)&quot;);
		} else {
			MFO.WriteLine(&quot;$(BUILD_DIR)\\&quot; + dllname + &quot;: $(DEPS_&quot; + EXT + &quot;) $(&quot; + EXT + &quot;_GLOBAL_OBJS) $(BUILD_DIR)\\$(PHPLIB) $(BUILD_DIR)\\&quot; + resname + &quot; $(BUILD_DIR)\\&quot; + manifest_name);
			MFO.WriteLine(&quot;\t&quot; + ld + &quot; $(&quot; + EXT + &quot;_GLOBAL_OBJS_RESP) $(BUILD_DIR)\\$(PHPLIB) $(LIBS_&quot; + EXT + &quot;) $(LIBS) $(BUILD_DIR)\\&quot; + resname + &quot; /out:$(BUILD_DIR)\\&quot; + dllname + ldflags + &quot; $(DLL_LDFLAGS) $(LDFLAGS) $(LDFLAGS_&quot; + EXT + &quot;)&quot;);
		}
		MFO.WriteLine(&quot;\t-&quot; + CMD_MOD2 + &quot;$(_VC_MANIFEST_EMBED_DLL)&quot;);
		MFO.WriteBlankLines(1);

		if (configure_module_dirname.match(&quot;pecl&quot;)) {
			ADD_FLAG(&quot;PECL_TARGETS&quot;, dllname);
		} else {
			ADD_FLAG(&quot;EXT_TARGETS&quot;, dllname);
		}
		MFO.WriteLine(dllname + &quot;: $(BUILD_DIR)\\&quot; + dllname);
		MFO.WriteLine(&quot;\t&quot; + CMD_MOD2 + &quot;echo EXT &quot; + extname + &quot; build complete&quot;);
		MFO.WriteBlankLines(1);

		DEFINE(&#039;CFLAGS_&#039; + EXT + &#039;_OBJ&#039;, &#039;$(CFLAGS_&#039; + EXT + &#039;)&#039;);
	} else {
		ADD_FLAG(&quot;STATIC_EXT_OBJS&quot;, &quot;$(&quot; + EXT + &quot;_GLOBAL_OBJS)&quot;);
		ADD_FLAG(&quot;STATIC_EXT_OBJS_RESP&quot;, &quot;$(&quot; + EXT + &quot;_GLOBAL_OBJS_RESP)&quot;);
		ADD_FLAG(&quot;STATIC_EXT_LIBS&quot;, &quot;$(LIBS_&quot; + EXT + &quot;)&quot;);
		ADD_FLAG(&quot;STATIC_EXT_LDFLAGS&quot;, &quot;$(LDFLAGS_&quot; + EXT + &quot;)&quot;);
		ADD_FLAG(&quot;STATIC_EXT_CFLAGS&quot;, &quot;$(CFLAGS_&quot; + EXT + &quot;)&quot;);
		if (is_pgo_desired(extname) &amp;&amp; (PHP_PGI == &quot;yes&quot; || PHP_PGO != &quot;no&quot;)) {
			if (!static_pgo_enabled) {
				if (PHP_DEBUG != &quot;yes&quot; &amp;&amp; PHP_PGI == &quot;yes&quot;) {
					ADD_FLAG(&#039;STATIC_EXT_LDFLAGS&#039;, &quot;/LTCG:PGINSTRUMENT&quot;);
				}
				else if (PHP_DEBUG != &quot;yes&quot; &amp;&amp; PHP_PGO != &quot;no&quot;) {
					ADD_FLAG(&#039;STATIC_EXT_LDFLAGS&#039;, &quot;/LTCG:PGUPDATE&quot;);
				}

				ADD_FLAG(&quot;STATIC_EXT_CFLAGS&quot;, &quot;/GL /O2&quot;);
				static_pgo_enabled = true;
			}
		}

		/* find the header that declares the module pointer,
		 * so we can include it in internal_functions.c */
		var ext_dir = FSO.GetFolder(configure_module_dirname);
		var fc = new Enumerator(ext_dir.Files);
		var re = /\.h$/;
		var s, c;
		for (; !fc.atEnd(); fc.moveNext()) {
			s = fc.item() + &quot;&quot;;
			if (s.match(re)) {
				c = file_get_contents(s);
				if (c.match(&quot;phpext_&quot;)) {
					extension_include_code += &#039;#include &quot;&#039; + configure_module_dirname + &#039;/&#039; + FSO.GetFileName(s) + &#039;&quot;\r\n&#039;;
				}
			}
		}

		extension_module_ptrs += &#039;\tphpext_&#039; + extname + &#039;_ptr,\r\n&#039;;

		DEFINE(&#039;CFLAGS_&#039; + EXT + &#039;_OBJ&#039;, &#039;$(CFLAGS_PHP) $(CFLAGS_&#039; + EXT + &#039;)&#039;);
	}
	if (MODE_PHPIZE) {
		if (!FSO.FileExists(PHP_DIR + &quot;/include/main/config.pickle.h&quot;)) {
			var _tmp = FSO.CreateTextFile(PHP_DIR + &quot;/include/main/config.pickle.h&quot;, true);
			_tmp.Close();
		}
	}
	ADD_FLAG(&quot;CFLAGS_&quot; + EXT, cflags);

	// [extname, shared, zend]
	extensions_enabled[extensions_enabled.length] = [extname, shared ? &#039;shared&#039; : &#039;static&#039;, false];
}

function ADD_SOURCES(dir, file_list, target, obj_dir)
{
	var i;
	var tv;
	var src, obj, sym, flags;

	if (target == null) {
		target = &quot;php&quot;;
	}

	sym = target.toUpperCase() + &quot;_GLOBAL_OBJS&quot;;
	flags = &quot;CFLAGS_&quot; + target.toUpperCase() + &#039;_OBJ&#039;;

	var bd = get_define(&#039;BUILD_DIR&#039;);
	var respd = bd + &#039;\\resp&#039;;
	if (!FSO.FolderExists(respd)) {
		FSO.CreateFolder(respd);
	}
	var obj_lst_fn = respd + &#039;\\&#039; + sym + &#039;.txt&#039;;
	var resp = &quot;&quot;;

	if (configure_subst.Exists(sym)) {
		tv = configure_subst.Item(sym);
	} else {
		if (FSO.FileExists(obj_lst_fn)) {
			FSO.DeleteFile(obj_lst_fn, true);
		}
		tv = &quot;&quot;;
	}

	file_list = file_list.split(new RegExp(&quot;\\s+&quot;));
	file_list.sort();

	var re = new RegExp(&quot;\.[a-z0-9A-Z]+$&quot;);

	dir = dir.replace(new RegExp(&quot;/&quot;, &quot;g&quot;), &quot;\\&quot;);
	var objs_line = &quot;&quot;;
	var srcs_line = &quot;&quot;;

	var sub_build = &quot;$(BUILD_DIR)\\&quot;;

	var srcs_by_dir = {};

	/* Parse the file list to create an aggregated structure based on the subdirs passed. */
	for (i in file_list) {
		src = file_list[i];

		var _tmp = src.split(&quot;\\&quot;);

		var filename = _tmp.pop();

		// build the obj out dir and use it as a key
		var dirname = _tmp.join(&quot;\\&quot;);

		//WARNING(&quot;dir: &quot; + dir + &quot; dirname: &quot; + dirname + &quot; filename: &quot; + filename);

		/* if module dir is not a child of the main source dir,
		 * we need to tweak it; we should have detected such a
		 * case in condense_path and rewritten the path to
		 * be relative.
		 * This probably breaks for non-sibling dirs, but that
		 * is not a problem as buildconf only checks for pecl
		 * as either a child or a sibling */
		if (obj_dir == null) {
			if (MODE_PHPIZE) {
				/* In the phpize mode, the subdirs are always relative to BUID_DIR.
					No need to differentiate by extension, only one gets built. */
				var build_dir = (dirname ? dirname : &quot;&quot;).replace(new RegExp(&quot;^..\\\\&quot;), &quot;&quot;);
			} else {
				var build_dir = (dirname ? (dir + &quot;\\&quot; + dirname) : dir).replace(new RegExp(&quot;^..\\\\&quot;), &quot;&quot;);
			}
		}
		else {
			var build_dir = (dirname ? obj_dir + &quot;\\&quot; + dirname : obj_dir).replace(new RegExp(&quot;^..\\\\&quot;), &quot;&quot;);
		}

		obj = sub_build + build_dir + &quot;\\&quot; + filename.replace(re, &quot;.obj&quot;);

		if (i &gt; 0) {
			srcs_line += &quot; &quot; + dir + &quot;\\&quot; + src;
			objs_line += &quot; &quot; + obj
		} else {
			srcs_line = dir + &quot;\\&quot; + src;
			objs_line = obj;
		}

		resp += &quot; &quot; + obj.replace(&#039;$(BUILD_DIR)&#039;, bd);
		tv += &quot; &quot; + obj;

		if (!srcs_by_dir.hasOwnProperty(build_dir)) {
			srcs_by_dir[build_dir] = [];
		}

		/* storing the index from the file_list */
		srcs_by_dir[build_dir].push(i);
	}

	/* Create makefile build targets and dependencies. */
	MFO.WriteLine(objs_line + &quot;: &quot; + srcs_line);

	/* Create target subdirs if any and produce the compiler calls, /mp is respected if enabled. */
	for (var k in srcs_by_dir) {
		var dirs = k.split(&quot;\\&quot;);
		var i, d = &quot;&quot;;
		for (i = 0; i &lt; dirs.length; i++) {
			d += dirs[i];
			build_dirs[build_dirs.length] = d;
			d += &quot;\\&quot;;
		}

		var mangle_dir = k.replace(new RegExp(&quot;[\\\\/.-]&quot;, &quot;g&quot;), &quot;_&quot;);
		var bd_flags_name = &quot;CFLAGS_BD_&quot; + mangle_dir.toUpperCase();

		DEFINE(bd_flags_name, &quot;/Fp&quot; + sub_build + d + &quot; /FR&quot; + sub_build + d + &quot; &quot;);
		if (VS_TOOLSET) {
			ADD_FLAG(bd_flags_name, &quot;/Fd&quot; + sub_build + d);
		}

		if (PHP_ANALYZER == &quot;clang&quot;) {
			var analyzer_base_args = TARGET_ARCH == &#039;x86&#039; ? &quot;-m32&quot; : &quot;-m64&quot;;
			var analyzer_base_flags = &quot;&quot;;

			analyzer_base_args += &quot; --analyze&quot;;

			var vc_ver;
			if (VS_TOOLSET) {
				vc_ver = VCVERS;
			} else {
				vc_ver = probe_binary(PATH_PROG(&#039;cl&#039;, null));
			}

			analyzer_base_args += &quot; -fms-compatibility -fms-compatibility-version=&quot; + vc_ver + &quot; -fms-extensions -Xclang -analyzer-output=text -Xclang -fmodules&quot;;
		} else if (PHP_ANALYZER == &quot;cppcheck&quot;) {
			var analyzer_base_args = &quot;&quot;;
			var analyzer_base_flags = &quot;&quot;;

			if (VS_TOOLSET) {
				analyzer_base_flags += &quot; -D _MSC_VER=&quot; + VCVERS;
			} else {
				analyzer_base_flags += &quot; -D _MSC_VER=&quot; + probe_binary(PATH_PROG(&#039;cl&#039;, null));
			}

			if (TARGET_ARCH == &#039;x64&#039;) {
				analyzer_base_flags += &quot; -D _M_X64 -D _WIN64&quot;;
			} else if (TARGET_ARCH == &#039;ARM64&#039;) {
				analyzer_base_flags += &quot; -D _M_ARM64 -D _WIN64&quot;;
			} else if (TARGET_ARCH == &#039;x86&#039;) {
				analyzer_base_flags += &quot; -D _M_IX86 &quot;;
			} else {
				ERROR(&quot;analyzer is not supported at arch &quot; + TARGET_ARCH);
			}
			analyzer_base_flags += &quot; -D _WIN32 -D WIN32 -D _WINDOWS&quot;;

			var vc_incs = WshShell.Environment(&quot;Process&quot;).Item(&quot;INCLUDE&quot;).split(&quot;;&quot;)
			for (i in vc_incs) {
				if (!vc_incs[i].length) {
					continue;
				}
				analyzer_base_flags += &quot; -I &quot; + &quot;\&quot;&quot; + vc_incs[i] + &quot;\&quot;&quot;;
			}

			var cppcheck_platform = TARGET_ARCH == &#039;x86&#039; ? &quot;win32A&quot; : &quot;win64&quot;;
			var cppcheck_lib = &quot;win32\\build\\cppcheck_&quot; + (TARGET_ARCH == &#039;x86&#039; ? &quot;x86&quot; : &quot;x64&quot;) + &quot;.cfg&quot;; // use x64 for arm64 yet
			analyzer_base_args += &quot;--enable=warning,performance,portability,information,missingInclude &quot; +
						&quot;--platform=&quot; + cppcheck_platform + &quot; &quot; +
						&quot;--library=windows.cfg --library=microsoft_sal.cfg &quot; +
						&quot;--library=win32\\build\\cppcheck.cfg &quot; +
						&quot;--library=&quot; + cppcheck_lib + &quot; &quot; +
						/* &quot;--rule-file=win32\build\cppcheck_rules.xml &quot; + */
						&quot; --std=c89 --std=c++11 &quot; +
						&quot;--quiet --inconclusive --template=vs -j 4 &quot; +
						&quot;--suppress=unmatchedSuppression &quot; +
						&quot;--suppressions-list=win32\\build\\cppcheck_suppress.txt &quot;;

			var cppcheck_build_dir = get_define(&quot;CPPCHECK_BUILD_DIR&quot;);
			if (!!cppcheck_build_dir) {
				analyzer_base_args += &quot;--cppcheck-build-dir=$(CPPCHECK_BUILD_DIR)&quot;;
			}
		}

		if (PHP_MP_DISABLED) {
			for (var j in srcs_by_dir[k]) {
				src = file_list[srcs_by_dir[k][j]];

				var _tmp = src.split(&quot;\\&quot;);
				var filename = _tmp.pop();
				obj = filename.replace(re, &quot;.obj&quot;);

				MFO.WriteLine(&quot;\t&quot; + CMD_MOD1 + &quot;$(CC) $(&quot; + flags + &quot;) $(CFLAGS) $(&quot; + bd_flags_name + &quot;) /c &quot; + dir + &quot;\\&quot; + src + &quot; /Fo&quot; + sub_build + d + obj);

				if (&quot;clang&quot; == PHP_ANALYZER) {
					MFO.WriteLine(&quot;\t&quot; + CMD_MOD1 + &quot;\&quot;$(CLANG_CL)\&quot; &quot; + analyzer_base_args + &quot; $(&quot; + flags + &quot;_ANALYZER) $(CFLAGS_ANALYZER) $(&quot; + bd_flags_name + &quot;_ANALYZER) &quot; + dir + &quot;\\&quot; + src);
				} else if (&quot;cppcheck&quot; == PHP_ANALYZER) {
					MFO.WriteLine(&quot;\t\&quot;&quot; + CMD_MOD1 + &quot;$(CPPCHECK)\&quot; &quot; + analyzer_base_args + &quot; $(&quot; + flags + &quot;_ANALYZER) $(CFLAGS_ANALYZER) $(&quot; + bd_flags_name + &quot;_ANALYZER) &quot; + analyzer_base_flags + &quot; &quot; + dir + &quot;\\&quot; + src);
				}else if (PHP_ANALYZER == &quot;pvs&quot;) {
					MFO.WriteLine(&quot;\t&quot; + CMD_MOD1 + &quot;\&quot;$(PVS_STUDIO)\&quot; --cl-params $(&quot; + flags + &quot;) $(CFLAGS) $(&quot; + bd_flags_name + &quot;) /c &quot; + dir + &quot;\\&quot; + src + &quot; --source-file &quot;  + dir + &quot;\\&quot; + src
						+ &quot; --cfg PVS-Studio.conf --errors-off \&quot;V122 V117 V111\&quot; &quot;);
				}
			}
		} else {
			/* TODO create a response file at least for the source files to work around the cmd line length limit. */
			var src_line = &quot;&quot;;
			for (var j in srcs_by_dir[k]) {
				src_line += dir + &quot;\\&quot; + file_list[srcs_by_dir[k][j]] + &quot; &quot;;
			}

			MFO.WriteLine(&quot;\t&quot; + CMD_MOD1 + &quot;$(CC) $(&quot; + flags + &quot;) $(CFLAGS) /Fo&quot; + sub_build + d + &quot; $(&quot; + bd_flags_name + &quot;) /c &quot; + src_line);

			if (&quot;clang&quot; == PHP_ANALYZER) {
				MFO.WriteLine(&quot;\t\&quot;$(CLANG_CL)\&quot; &quot; + analyzer_base_args + &quot; $(&quot; + flags + &quot;_ANALYZER) $(CFLAGS_ANALYZER)  $(&quot; + bd_flags_name + &quot;_ANALYZER) &quot; + src_line);
			} else if (&quot;cppcheck&quot; == PHP_ANALYZER) {
				MFO.WriteLine(&quot;\t\&quot;$(CPPCHECK)\&quot; &quot; + analyzer_base_args + &quot; $(&quot; + flags + &quot;_ANALYZER) $(CFLAGS_ANALYZER)  $(&quot; + bd_flags_name + &quot;_ANALYZER) &quot; + analyzer_base_flags + &quot; &quot; + src_line);
			}
		}
	}

	DEFINE(sym, tv);

	/* Generate the object response file and define it to the Makefile. This can be
	   useful when getting the &quot;command line too long&quot; linker errors.
	   TODO pack this into a function when response files are used for other kinds of info. */
	var obj_lst_fh = null;
	if (!FSO.FileExists(obj_lst_fn)) {
		obj_lst_fh = FSO.CreateTextFile(obj_lst_fn);
	} else {
		obj_lst_fh = FSO.OpenTextFile(obj_lst_fn, 8);
	}

	obj_lst_fh.Write(&quot; &quot; + resp);
	obj_lst_fh.Close();
	DEFINE(sym + &quot;_RESP&quot;, &#039;@&quot;&#039; + obj_lst_fn + &#039;&quot;&#039;);
}

function REMOVE_TARGET(dllname, flag)
{
	var dllname = dllname.replace(/\s/g, &quot;&quot;);
	var EXT = dllname.replace(/php_(\S+)\.dll/, &quot;$1&quot;).toUpperCase();
	var php_flags = configure_subst.Item(&quot;CFLAGS_PHP&quot;);

	if (configure_subst.Exists(flag)) {
		var targets = configure_subst.Item(flag);

		if (targets.match(dllname)) {
			configure_subst.Remove(flag);
			targets = targets.replace(dllname, &quot;&quot;);
			targets = targets.replace(/\s+/, &quot; &quot;);
			targets = targets.replace(/\s$/, &quot;&quot;);
			configure_subst.Add(flag, targets);
			configure_hdr.Add(&quot;HAVE_&quot; + EXT, new Array(0, &quot;&quot;));
			configure_subst.Item(&quot;CFLAGS_PHP&quot;) = php_flags.replace(&quot; /D COMPILE_DL_&quot; + EXT, &quot;&quot;);
			extensions_enabled.pop();
			return true;
		}
	}
	return false;
}

function generate_internal_functions()
{
	var infile, outfile;
	var indata;

	STDOUT.WriteLine(&quot;Generating main/internal_functions.c&quot;);

	infile = FSO.OpenTextFile(&quot;main/internal_functions.c.in&quot;, 1);
	indata = infile.ReadAll();
	infile.Close();

	indata = indata.replace(&quot;@EXT_INCLUDE_CODE@&quot;, extension_include_code);
	indata = indata.replace(&quot;@EXT_MODULE_PTRS@&quot;, extension_module_ptrs);

	if (FSO.FileExists(&quot;main/internal_functions.c&quot;)) {
		var origdata = file_get_contents(&quot;main/internal_functions.c&quot;);

		if (origdata == indata) {
			STDOUT.WriteLine(&quot;\t[content unchanged; skipping]&quot;);
			return;
		}
	}

	outfile = FSO.CreateTextFile(&quot;main/internal_functions.c&quot;, true);
	outfile.Write(indata);
	outfile.Close();
}

function output_as_table(header, ar_out)
{
	var l = header.length;
	var cols = 80;
	var fixedlength = &quot;&quot;;
	var t = 0;
	var i,j,k,m;
	var out = &quot;| &quot;;
	var min = new Array(l);
	var max = new Array(l);

	if (!!ar_out[0] &amp;&amp; l != ar_out[0].length) {
		STDOUT.WriteLine(&quot;Invalid header argument, can&#039;t output the table &quot; + l + &quot; &quot; + ar_out[0].length  );
		return;
	}

	for (j=0; j &lt; l; j++) {
		var tmax, tmin;

		/* Figure out the max length per column */
		tmin = 0;
		tmax = 0;
		for (k = 0; k &lt; ar_out.length; k++) {
			if(typeof ar_out[k][j] != &#039;undefined&#039;) {
				var t = ar_out[k][j].length;
				if (t &gt; tmax) tmax = t;
				else if (t &lt; tmin) tmin = t;
			}
		}
		if (tmax &gt; header[j].length) {
			max[j] = tmax;
		} else {
			max[j] = header[j].length;
		}
		if (tmin &lt; header[j].length) {
			min[j] = header[j].length;
		}
	}

	sep = &quot;&quot;;
	k = 0;
	for (i = 0; i &lt; l; i++) {
		k += max[i] + 3;
	}
	k++;

	for (j=0; j &lt; k; j++) {
		sep += &quot;-&quot;;
	}

	STDOUT.WriteLine(sep);
	out = &quot;|&quot;;
	for (j=0; j &lt; l; j++) {
		out += &quot; &quot; + header[j];
		for (var i = 0; i &lt; (max[j] - header[j].length); i++){
			out += &quot; &quot;;
		}
		out += &quot; |&quot;;
	}
	STDOUT.WriteLine(out);

	STDOUT.WriteLine(sep);

	out = &quot;|&quot;;
	for (i=0; i &lt; ar_out.length; i++) {
		line = ar_out[i];
		for (j=0; j &lt; l; j++) {
			out += &quot; &quot; + line[j];
			if(typeof line[j] != &#039;undefined&#039;) {
				for (var k = 0; k &lt; (max[j] - line[j].length); k++){
					out += &quot; &quot;;
				}
			}
			out += &quot; |&quot;;
		}
		STDOUT.WriteLine(out);
		out = &quot;|&quot;;
	}

	STDOUT.WriteLine(sep);
}

function write_extensions_summary()
{
	var exts = new Array();
	var zend_exts = new Array();

	for(var x = 0; x &lt; extensions_enabled.length; ++x)
	{
		var l = extensions_enabled[x];

		if(l[2])
		{
			zend_exts.push([l[0], l[1]]);
		}
		else
		{
			exts.push([l[0], l[1]]);
		}
	}

	STDOUT.WriteLine(&#039;Enabled extensions:&#039;);
	output_as_table([&#039;Extension&#039;, &#039;Mode&#039;], exts.sort());

	if(zend_exts.length)
	{
		STDOUT.WriteBlankLines(2);
		STDOUT.WriteLine(&#039;Enabled Zend extensions:&#039;);
		output_as_table([&#039;Extension&#039;, &#039;Mode&#039;], zend_exts.sort());
	}
}

function write_summary()
{
	var ar = new Array();
	var k = 0;

	STDOUT.WriteBlankLines(2);
	write_extensions_summary();
	STDOUT.WriteBlankLines(2);
	if (!MODE_PHPIZE) {
		STDOUT.WriteLine(&quot;Enabled SAPI:&quot;);
		output_as_table([&quot;Sapi Name&quot;], sapi_enabled);
		STDOUT.WriteBlankLines(2);
	}
	ar[k++] = [&#039;Build type&#039;, PHP_DEBUG == &quot;yes&quot; ? &quot;Debug&quot; : &quot;Release&quot;];
	ar[k++] = [&#039;Thread Safety&#039;, PHP_ZTS == &quot;yes&quot; ? &quot;Yes&quot; : &quot;No&quot;];
	ar[k++] = [&#039;Compiler&#039;, COMPILER_NAME_LONG];
	ar[k++] = [&#039;Target Architecture&#039;, TARGET_ARCH];
	ar[k++] = [&#039;Host Architecture&#039;, HOST_ARCH];
	if (PHP_PGO == &quot;yes&quot;) {
		ar[k++] = [&#039;Optimization&#039;, &quot;PGO&quot;];
	} else if (PHP_PGI == &quot;yes&quot;) {
		ar[k++] = [&#039;Optimization&#039;, &quot;PGI&quot;];
	} else {
		ar[k++] = [&#039;Optimization&#039;, PHP_DEBUG == &quot;yes&quot; ? &quot;disabled&quot; : &quot;PGO disabled&quot;];
	}
	var simd = configure_subst.Item(&quot;PHP_SIMD_SCALE&quot;);
	if (!!simd) {
		ar[k++] = [&quot;Native intrinsics&quot;, simd];
	}
	if (PHP_ANALYZER == &quot;vs&quot;) {
		ar[k++] = [&#039;Static analyzer&#039;, &#039;Visual Studio&#039;];
	} else if (PHP_ANALYZER == &quot;clang&quot;) {
		ar[k++] = [&#039;Static analyzer&#039;, &#039;clang&#039;];
	} else if (PHP_ANALYZER == &quot;cppcheck&quot;) {
		ar[k++] = [&#039;Static analyzer&#039;, &#039;Cppcheck&#039;];
	} else if (PHP_ANALYZER == &quot;pvs&quot;) {
		ar[k++] = [&#039;Static analyzer&#039;, &#039;PVS-Studio&#039;];
	} else {
		ar[k++] = [&#039;Static analyzer&#039;, &#039;disabled&#039;];
	}

	output_as_table([&quot;&quot;,&quot;&quot;], ar);
	STDOUT.WriteBlankLines(2);
}

function is_on_exclude_list_for_test_ini(list, name)
{
	for (var i in list) {
		if (name == list[i]) {
			return true;
		}
	}

	return false;
}

function generate_tmp_php_ini()
{
	if (&quot;no&quot; == PHP_TEST_INI) {
		/* Test ini generation is disabled. */
		return;
	}

	var ini_dir = PHP_OBJECT_OUT_DIR + (&quot;yes&quot; == PHP_DEBUG ? &quot;Debug&quot; : &quot;Release&quot;) + (&quot;yes&quot; == PHP_ZTS ? &quot;_TS&quot; : &quot;&quot;);
	PHP_TEST_INI_PATH = ini_dir + &quot;\\tmp-php.ini&quot;;

	if (FSO.FileExists(PHP_TEST_INI_PATH)) {
		STDOUT.WriteLine(&quot;Generating &quot; + PHP_TEST_INI_PATH + &quot; ...&quot;);
		var INI = FSO.OpenTextFile(PHP_TEST_INI_PATH, 2);
	} else {
		STDOUT.WriteLine(&quot;Regenerating &quot; + PHP_TEST_INI_PATH + &quot; ...&quot;);
		var INI = FSO.CreateTextFile(PHP_TEST_INI_PATH, true);
	}

	var ext_list = PHP_TEST_INI_EXT_EXCLUDE.split(&quot;,&quot;);
	INI.WriteLine(&quot;extension_dir=&quot; + ini_dir);
	for (var i in extensions_enabled) {
		if (&quot;shared&quot; != extensions_enabled[i][1]) {
			continue;
		}

		var directive = (extensions_enabled[i][2] ? &#039;zend_extension&#039; : &#039;extension&#039;);

		var ext_name = extensions_enabled[i][0];

		if (!is_on_exclude_list_for_test_ini(ext_list, ext_name)) {
			INI.WriteLine(directive + &quot;=php_&quot; + ext_name + &quot;.dll&quot;);

			if (&quot;opcache&quot; == ext_name) {
				var dir = get_define(&quot;BUILD_DIR&quot;) + &quot;\\&quot; + &quot;test_file_cache&quot;;
				if (FSO.FolderExists(dir)) {
					STDOUT.Write(execute(&quot;powershell -Command Remove-Item -path \&quot;\\\\?\\&quot; + dir + &quot;\&quot; -recurse&quot;));
				}
				FSO.CreateFolder(dir);

				/* Fallback is implied, if filecache is enabled. */
				INI.WriteLine(&quot;opcache.file_cache=&quot; + dir);
				INI.WriteLine(&quot;opcache.enable=1&quot;);
				INI.WriteLine(&quot;opcache.enable_cli=1&quot;);
			}
		}
	}

	INI.Close();
}

function generate_files()
{
	var i, dir, bd, last;

	STDOUT.WriteBlankLines(1);
	STDOUT.WriteLine(&quot;Creating build dirs...&quot;);
	dir = get_define(&quot;BUILD_DIR&quot;);
	build_dirs.sort();
	last = null;

	if (!FSO.FolderExists(dir)) {
		FSO.CreateFolder(dir);
	}

	for (i = 0; i &lt; build_dirs.length; i++) {
		bd = FSO.BuildPath(dir, build_dirs[i]);
		if (bd == last) {
			continue;
		}
		last = bd;

		build_dir = get_define(&#039;BUILD_DIR&#039;);
		build_dir = build_dir.replace(new RegExp(&quot;\\\\&quot;, &quot;g&quot;), &quot;\\\\&quot;);
		if (build_dir.substr(build_dir.Length - 2, 2) != &#039;\\\\&#039;) {
			build_dir += &#039;\\\\&#039;;
		}
		ADD_FLAG(&quot;BUILD_DIRS_SUB&quot;, bd.replace(new RegExp(build_dir), &#039;&#039;));

		if (!FSO.FolderExists(bd)) {
			FSO.CreateFolder(bd);
		}
	}

	STDOUT.WriteLine(&quot;Generating files...&quot;);
	generate_tmp_php_ini();
	generate_makefile();
	if (!MODE_PHPIZE) {
		generate_internal_functions();
		generate_config_h();
		generate_phpize();
	} else {
		generate_config_pickle_h();
		generate_ext_pickle();
	}
	STDOUT.WriteLine(&quot;Done.&quot;);
	STDOUT.WriteBlankLines(1);
	write_summary();

	if (INVALID_CONFIG_ARGS.length) {
		STDOUT.WriteLine(&#039;WARNING&#039;);
		STDOUT.WriteLine(&#039;The following &#039; +
			(INVALID_CONFIG_ARGS.length &gt; 1 ? &#039;arguments are&#039; : &#039;argument is&#039;) +
			&#039; invalid, and therefore ignored:&#039;);

		for (var i = 0; i &lt; INVALID_CONFIG_ARGS.length; ++i) {
			STDOUT.WriteLine(&#039; &#039; + INVALID_CONFIG_ARGS[i]);
		}

		STDOUT.WriteBlankLines(2);
	}

	if (PHP_SNAPSHOT_BUILD != &quot;no&quot;) {
		STDOUT.WriteLine(&quot;Type &#039;nmake snap&#039; to build a PHP snapshot&quot;);
	} else {
		STDOUT.WriteLine(&quot;Type &#039;nmake&#039; to build PHP&quot;);
	}
}

function generate_ext_pickle()
{
	var content;
	var DEPS = null;
	var dest;
	var deps_lines = new Array();

	var build_var_name = function(name) {
		return &quot;PHP_&quot; + name.toUpperCase();
	}

	STDOUT.WriteLine(&quot;Generating pickle deps&quot;);
	dest = PHP_DIR + &quot;/script/&quot;;

	if (!FSO.FolderExists(dest)) {
		FSO.CreateFolder(dest);
	}

	if (FSO.FileExists(dest + &quot;/ext_pickle.js&quot;)) {
		DEPS = FSO.OpenTextFile(dest + &quot;/ext_pickle.js&quot;, 1);

		while (!DEPS.AtEndOfStream) {
			var ln = DEPS.ReadLine();
			var found = false;

			for (var i in extensions_enabled) {
				var reg0 = new RegExp(build_var_name(extensions_enabled[i][0]) + &quot;\s*=.+&quot;, &quot;g&quot;);
				var reg1 = new RegExp(build_var_name(extensions_enabled[i][0]) + &quot;_SHARED&quot; + &quot;\s*=.+&quot;, &quot;g&quot;);

				if (ln.match(reg1) || ln.match(reg0)) {
					found = true;
					break;
				}
			}

			if (!found) {
				deps_lines.push(ln);
			}
		}
	}

	for (var i in extensions_enabled) {
		deps_lines.push(build_var_name(extensions_enabled[i][0]) + &quot;=true;&quot;);
		deps_lines.push(build_var_name(extensions_enabled[i][0]) + &quot;_SHARED=&quot; + (extensions_enabled[i][1] == &#039;shared&#039; ? &#039;true&#039; : &#039;false&#039;) + &quot;;&quot;);
	}

	if (!!DEPS) {
		DEPS.Close();
		DEPS = null;
	}

	/* Replace the ext_pickle.js with the new content */
	DEPS = FSO.CreateTextFile(dest + &quot;/ext_pickle.js&quot;, true);

	for (var j in deps_lines) {
		DEPS.WriteLine(deps_lines[j]);
	}

	DEPS.Close();
}

function generate_config_pickle_h()
{
	var outfile = null;
	var lines = new Array();
	var keys = (new VBArray(configure_hdr.Keys())).toArray();
	dest = PHP_DIR + &quot;/include/main&quot;;

	var ignore_key = function(key) {
		var ignores = [ &quot;CONFIGURE_COMMAND&quot;, &quot;PHP_COMPILER_ID&quot;, &quot;COMPILER&quot;, &quot;ARCHITECTURE&quot;, &quot;HAVE_STRNLEN&quot;, &quot;PHP_DIR&quot; ];

		for (var k in ignores) {
			if (ignores[k] == key) {
				return true;
			}
		}

		return false;
	}


	STDOUT.WriteLine(&quot;Generating main/config.pickle.h&quot;);

	if (FSO.FileExists(dest + &quot;/config.pickle.h&quot;)) {
		outfile = FSO.OpenTextFile(dest + &quot;/config.pickle.h&quot;, 1);

		while (!outfile.AtEndOfStream) {
			var found = false;
			var ln = outfile.ReadLine();

			for (var i in keys) {
				var reg = new RegExp(&quot;#define[\s ]+&quot; + keys[i] + &quot;[\s ]*.*|#undef[\s ]+&quot; + keys[i], &quot;g&quot;);

				if (ln.match(reg)) {
					found = true;
					break;
				}
			}

			if (!found) {
				lines.push(ln);
			}
		}
	}

	for (var i in keys) {
		var item = configure_hdr.Item(keys[i]);

		if (ignore_key(keys[i])) {
			continue;
		}

		/* XXX fix comment handling */
		/*if (!lines[j].match(/^#define.+/g)) {
			continue;
		}*/

		lines.push(&quot;#undef &quot; + keys[i]);
		lines.push(&quot;#define &quot; + keys[i] + &quot; &quot; + item[0]);
	}

	if (outfile) {
		outfile.Close();
		outfile = null;
	}

	outfile = FSO.CreateTextFile(dest + &quot;/config.pickle.h&quot;, true);

	for (var k in lines) {
		outfile.WriteLine(lines[k]);
	}

	outfile.Close();
}

function generate_config_h()
{
	var infile, outfile;
	var indata;
	var prefix;

	prefix = PHP_PREFIX.replace(new RegExp(&quot;\\\\&quot;, &quot;g&quot;), &quot;\\\\&quot;);

	STDOUT.WriteLine(&quot;Generating main/config.w32.h&quot;);

	infile = FSO.OpenTextFile(&quot;win32/build/config.w32.h.in&quot;, 1);
	indata = infile.ReadAll();
	infile.Close();

	outfile = FSO.CreateTextFile(&quot;main/config.w32.h&quot;, true);

	indata = indata.replace(new RegExp(&quot;@PREFIX@&quot;, &quot;g&quot;), prefix);
	outfile.Write(indata);

	var keys = (new VBArray(configure_hdr.Keys())).toArray();
	var i, j;
	var item;
	var pieces, stuff_to_crack, chunk;

	outfile.WriteBlankLines(1);
	outfile.WriteLine(&quot;/* values determined by configure.js */&quot;);

	for (i in keys) {
		item = configure_hdr.Item(keys[i]);
		outfile.WriteBlankLines(1);
		pieces = item[0];

		if (item[1] != undefined) {
			outfile.WriteLine(&quot;/* &quot; + item[1] + &quot; */&quot;);
		}

		if (typeof(pieces) == &quot;string&quot; &amp;&amp; pieces.charCodeAt(0) == 34) {
			/* quoted string have a maximal length of 2k under vc.
			 * solution is to crack them and let the compiler concat
			 * them implicitly */
			stuff_to_crack = pieces;
			pieces = &quot;&quot;;

			while (stuff_to_crack.length) {
				j = 65;
				while (stuff_to_crack.charCodeAt(j) != 32 &amp;&amp; j &lt; stuff_to_crack.length)
					j++;

				chunk = stuff_to_crack.substr(0, j);
				pieces += chunk;
				stuff_to_crack = stuff_to_crack.substr(chunk.length);
				if (stuff_to_crack.length)
					pieces += &#039;&quot; &quot;&#039;;
			}
		}

		outfile.WriteLine(&quot;#define &quot; + keys[i] + &quot; &quot; + pieces);
	}

	outfile.WriteBlankLines(1);
	outfile.WriteLine(&quot;#if __has_include(\&quot;main/config.pickle.h\&quot;)&quot;);
	outfile.WriteLine(&quot;#include \&quot;main/config.pickle.h\&quot;&quot;);
	outfile.WriteLine(&quot;#endif&quot;);

	outfile.Close();
}

/* Generate phpize */
function generate_phpize()
{
	STDOUT.WriteLine(&quot;Generating phpize&quot;);
	dest = get_define(&quot;BUILD_DIR&quot;) + &#039;/devel&#039;;

	if (!FSO.FolderExists(dest)) {
		FSO.CreateFolder(dest);
	}

	var MF = FSO.CreateTextFile(dest + &quot;/phpize.js&quot;, true);
	var DEPS = FSO.CreateTextFile(dest + &quot;/ext_deps.js&quot;, true);

	prefix = get_define(&quot;PHP_PREFIX&quot;);
	prefix = prefix.replace(new RegExp(&quot;/&quot;, &quot;g&quot;), &quot;\\&quot;);
	prefix = prefix.replace(new RegExp(&quot;\\\\&quot;, &quot;g&quot;), &quot;\\\\&quot;);
	MF.WriteLine(&quot;var PHP_PREFIX=&quot; + &#039;&quot;&#039; + prefix + &#039;&quot;&#039;);
	MF.WriteLine(&quot;var PHP_ZTS=&quot; + &#039;&quot;&#039; + (PHP_ZTS.toLowerCase() == &quot;yes&quot; ? &quot;Yes&quot; : &quot;No&quot;) + &#039;&quot;&#039;);
	MF.WriteLine(&quot;var VC_VERSION=&quot; + VCVERS);
	MF.WriteLine(&quot;var PHP_VERSION=&quot; + PHP_VERSION);
	MF.WriteLine(&quot;var PHP_MINOR_VERSION=&quot; + PHP_MINOR_VERSION);
	MF.WriteLine(&quot;var PHP_RELEASE_VERSION=&quot; + PHP_RELEASE_VERSION);
	MF.WriteLine(&quot;var PHP_EXTRA_VERSION=\&quot;&quot; + PHP_EXTRA_VERSION + &quot;\&quot;&quot;);
	MF.WriteLine(&quot;var PHP_VERSION_STRING=\&quot;&quot; + PHP_VERSION_STRING + &quot;\&quot;&quot;);
	MF.WriteBlankLines(1);
	MF.WriteLine(&quot;/* Generated extensions list with mode (static/shared) */&quot;);

	var count = extensions_enabled.length;
	for (i in extensions_enabled) {
		out = &quot;PHP_&quot; + extensions_enabled[i][0].toUpperCase() + &quot;_SHARED=&quot; + (extensions_enabled[i][1] == &#039;shared&#039; ? &#039;true&#039; : &#039;false&#039;) + &quot;;&quot;;
		DEPS.WriteLine(&quot;PHP_&quot; + extensions_enabled[i][0].toUpperCase() + &quot;=true;&quot;);
		DEPS.WriteLine(out);
		MF.WriteLine(out);
	}

	MF.WriteBlankLines(2);
	MF.WriteLine(&quot;/* Generated win32/build/phpize.js.in */&quot;);
	MF.WriteBlankLines(1);
	MF.Write(file_get_contents(&quot;win32/build/phpize.js.in&quot;));
	MF.Close();
	DEPS.Close();

	/* Generate flags file */
	/* spit out variable definitions */
	CJ = FSO.CreateTextFile(dest + &quot;/config.phpize.js&quot;);

	CJ.WriteLine(&quot;var PHP_ZTS =&quot; + &#039;&quot;&#039; + PHP_ZTS + &#039;&quot;&#039;);
	CJ.WriteLine(&quot;var PHP_DEBUG=&quot; + &#039;&quot;&#039; + PHP_DEBUG + &#039;&quot;&#039;);
	CJ.WriteLine(&quot;var PHP_DLL_LIB =&quot; + &#039;&quot;&#039; + get_define(&#039;PHPLIB&#039;) + &#039;&quot;&#039;);
	CJ.WriteLine(&quot;var PHP_DLL =&quot; + &#039;&quot;&#039; + get_define(&#039;PHPDLL&#039;) + &#039;&quot;&#039;);
	CJ.WriteLine(&quot;var PHP_SECURITY_FLAGS =&quot; + &#039;&quot;&#039; + PHP_SECURITY_FLAGS + &#039;&quot;&#039;);

	/* The corresponding configure options aren&#039;t enabled through phpize,
		thus these dummy declarations are required. */
	CJ.WriteLine(&quot;var PHP_ANALYZER =&quot; + &#039;&quot;no&quot;&#039;);
	CJ.WriteLine(&quot;var PHP_PGO =&quot; + &#039;&quot;no&quot;&#039;);
	CJ.WriteLine(&quot;var PHP_PGI =&quot; + &#039;&quot;no&quot;&#039;);
	CJ.WriteLine(&quot;var PHP_ALL_SHARED =&quot; + &#039;&quot;no&quot;&#039;);

	CJ.WriteBlankLines(1);
	CJ.Close();
}

function extract_convert_style_line(val, match_sw, to_sw, keep_mkfile_vars)
{
	var ret = &quot;&quot;;

	/*var re = new RegExp(match_sw + &quot;(.*)&quot;, &quot;g&quot;);
	var r;

	while (r = re.execute(val)) {
		WARNING(r);
	}
	return ret;*/

	var cf = val.replace(/\s+/g, &quot; &quot;).split(&quot; &quot;);

	var i_val = false;
	for (var i in cf) {
		var r;

		if (keep_mkfile_vars) {
			r = cf[i].match(/^\$\((.*)\)/);
			if (!!r) {
				ret += &quot; &quot; + r[0];
				continue;
			}
		}

		if (i_val &amp;&amp; !!cf[i]) {
			i_val = false;
			ret += &quot; &quot; + to_sw + &quot; &quot; + cf[i];
			continue;
		}

		var re;

		re = new RegExp(match_sw + &quot;(.*)&quot;);
		r = cf[i].match(re);
		if (!!r &amp;&amp; r.length &gt; 1 &amp;&amp; !!r[1]) {
			/* The value is not ws separated from the switch. */
			ret += &quot; &quot; + to_sw + &quot; &quot; + r[1];
			continue;
		}

		r = cf[i].match(match_sw);
		if (!!r) {
			//WARNING(cf[i]);
			/* Value is going to be added in the next iteration. */
			i_val = true;
		}
	}

	return ret;
}

function handle_analyzer_makefile_flags(fd, key, val)
{
	var relevant = false;

	/* VS integrates /analyze with the build process,
		no further action is required. */
	if (&quot;no&quot; == PHP_ANALYZER || &quot;vs&quot; == PHP_ANALYZER) {
		return;
	}

	if (key.match(&quot;CFLAGS&quot;)) {
		var new_val = val;
		var reg = /\$\(([^\)]+)\)/g;
		var r;
		while (r = reg.exec(val)) {
			var repl = &quot;$(&quot; + r[1] + &quot;_ANALYZER)&quot;
			new_val = new_val.replace(r[0], repl);
		}
		val = new_val;

		if (&quot;clang&quot; == PHP_ANALYZER) {
			val = val.replace(/\/FD /, &quot;&quot;)
				.replace(/\/Fp.+? /, &quot;&quot;)
				.replace(/\/Fo.+? /, &quot;&quot;)
				.replace(/\/Fd.+? /, &quot;&quot;)
				//.replace(/\/Fd.+?/, &quot; &quot;)
				.replace(/\/FR.+? /, &quot;&quot;)
				.replace(&quot;/guard:cf &quot;, &quot;&quot;)
				.replace(/\/MP \d+ /, &quot;&quot;)
				.replace(/\/MP /, &quot;&quot;)
				.replace(&quot;/LD &quot;, &quot;&quot;)
				.replace(&quot;/Qspectre &quot;, &quot;&quot;);
		} else if (&quot;cppcheck&quot; == PHP_ANALYZER) {
			new_val = &quot;&quot;;

			new_val += extract_convert_style_line(val, &quot;/I&quot;, &quot;-I&quot;, true);
			new_val += extract_convert_style_line(val, &quot;/D&quot;, &quot;-D&quot;, false);

			val = new_val;
		}

		relevant = true;
	} else if (key.match(&quot;BASE_INCLUDES&quot;)) {
		if (&quot;cppcheck&quot; == PHP_ANALYZER) {
			new_val = &quot;&quot;;

			new_val += extract_convert_style_line(val, &quot;/I&quot;, &quot;-I&quot;, true);
			new_val += extract_convert_style_line(val, &quot;/D&quot;, &quot;-D&quot;, false);

			val = new_val;
		}

		relevant = true;
	}

	if (!relevant) {
		return;
	}

	key += &quot;_ANALYZER&quot;;
	//WARNING(&quot;KEY: &quot; + key + &quot; VAL: &quot; + val);

	fd.WriteLine(key + &quot;=&quot; + val + &quot; &quot;);
	fd.WriteBlankLines(1);
}

/* Generate the Makefile */
function generate_makefile()
{
	STDOUT.WriteLine(&quot;Generating Makefile&quot;);
	var MF = FSO.CreateTextFile(&quot;Makefile&quot;, true);

	MF.WriteLine(&quot;# Generated by configure.js&quot;);
	/* spit out variable definitions */
	var keys = (new VBArray(configure_subst.Keys())).toArray();
	var i;
	MF.WriteLine(&quot;PHP_SRC_DIR =&quot; + PHP_SRC_DIR);
	for (i in keys) {
		// The trailing space is needed to prevent the trailing backslash
		// that is part of the build dir flags (CFLAGS_BD_XXX) from being
		// seen as a line continuation character

		/* \s+\/ eliminates extra whitespace caused when using \ for string continuation,
			whereby \/ is the start of the next compiler switch */
		var val = trim(configure_subst.Item(keys[i])).replace(/\s+\//gm, &quot; /&quot;);

		MF.WriteLine(keys[i] + &quot;=&quot; + val + &quot; &quot;);
		MF.WriteBlankLines(1);

		/* If static analyze is enabled, add analyzer specific stuff to the Makefile. */
		handle_analyzer_makefile_flags(MF, keys[i], val);
	}

	var val = &quot;yes&quot; == PHP_TEST_INI ? PHP_TEST_INI_PATH : &quot;&quot;;
	/* Be sure it&#039;s done after generate_tmp_php_ini(). */
	MF.WriteLine(&quot;PHP_TEST_INI_PATH=\&quot;&quot; + val + &quot;\&quot;&quot;);

	MF.WriteBlankLines(1);
	if (MODE_PHPIZE) {
		var TF = FSO.OpenTextFile(PHP_DIR + &quot;/script/Makefile.phpize&quot;, 1);
	} else {
		var TF = FSO.OpenTextFile(&quot;win32/build/Makefile&quot;, 1);
	}

	MF.Write(TF.ReadAll());

	MF.WriteLine(&quot;build-headers:&quot;);
	MF.WriteLine(&quot;	&quot; + CMD_MOD2 + &quot;if not exist $(BUILD_DIR_DEV)\\include mkdir $(BUILD_DIR_DEV)\\include &gt;nul&quot;);
	MF.WriteLine(&quot;	&quot; + CMD_MOD2 + &quot;for %D in ($(INSTALL_HEADERS_DIR)) do &quot; + CMD_MOD2 + &quot;if not exist $(BUILD_DIR_DEV)\\include\\%D mkdir $(BUILD_DIR_DEV)\\include\\%D &gt;nul&quot;);
	for (i in headers_install) {
		if (headers_install[i][2] != &quot;&quot;) {
				MF.WriteLine(&quot;	&quot; + CMD_MOD2 + &quot;if not exist $(BUILD_DIR_DEV)\\include\\&quot; + headers_install[i][2] + &quot; mkdir $(BUILD_DIR_DEV)\\include\\&quot; +
												headers_install[i][2] + &quot;&gt;nul&quot;);
				MF.WriteLine(&quot;	&quot; + CMD_MOD2 + &quot;copy &quot; + headers_install[i][0] + &quot; &quot; + &quot;$(BUILD_DIR_DEV)\\include\\&quot; + headers_install[i][2] + &quot; /y &gt;nul&quot;);
		}
	}
	MF.WriteLine(&quot;	&quot; + CMD_MOD2 + &quot;for %D in ($(INSTALL_HEADERS_DIR)) do &quot; + CMD_MOD2 + &quot;copy %D*.h $(BUILD_DIR_DEV)\\include\\%D /y &gt;nul&quot;);
	if (MODE_PHPIZE) {
		MF.WriteBlankLines(1);
		MF.WriteLine(&quot;build-bins:&quot;);
		for (var i in extensions_enabled) {
			var lib = &quot;php_&quot; + extensions_enabled[i][0] + &quot;.lib&quot;;
			var dll = &quot;php_&quot; + extensions_enabled[i][0] + &quot;.dll&quot;;
			MF.WriteLine(&quot;	&quot; + CMD_MOD2 + &quot;copy $(BUILD_DIR)\\&quot; + lib + &quot; $(BUILD_DIR_DEV)\\lib&quot;);
			MF.WriteLine(&quot;  &quot; + CMD_MOD2 + &quot;if not exist $(PHP_PREFIX) mkdir $(PHP_PREFIX) &gt;nul&quot;);
			MF.WriteLine(&quot;  &quot; + CMD_MOD2 + &quot;if not exist $(PHP_PREFIX)\\ext mkdir $(PHP_PREFIX)\\ext &gt;nul&quot;);
			MF.WriteLine(&quot;	&quot; + CMD_MOD2 + &quot;copy $(BUILD_DIR)\\&quot; + dll + &quot; $(PHP_PREFIX)\\ext&quot;);
		}
	} else {
		MF.WriteBlankLines(1);
		MF.WriteLine(&quot;build-ext-libs:&quot;);
		MF.WriteLine(&quot;	&quot; + CMD_MOD2 + &quot;if not exist $(BUILD_DIR_DEV)\\lib mkdir $(BUILD_DIR_DEV)\\lib &gt;nul&quot;);
		for (var i in extensions_enabled) {
			var lib;

			lib = &quot;php_&quot; + extensions_enabled[i][0] + &quot;*.lib&quot;;

			if (&#039;shared&#039; == extensions_enabled[i][1]) {
				MF.WriteLine(&quot;	&quot; + CMD_MOD2 + &quot;if exist $(BUILD_DIR)\\&quot; + lib + &quot; copy $(BUILD_DIR)\\&quot; + lib + &quot; $(BUILD_DIR_DEV)\\lib&quot;);
			}
		}
	}
	TF.Close();

	MF.WriteBlankLines(1);

	var extra_path = &quot;$(PHP_BUILD)\\bin&quot;;
	if (PHP_EXTRA_LIBS.length) {
		path = PHP_EXTRA_LIBS.split(&#039;;&#039;);
		for (i = 0; i &lt; path.length; i++) {
			f = FSO.GetAbsolutePathName(path[i] + &quot;\\..\\bin&quot;);
			if (FSO.FolderExists(f)) {
				extra_path = extra_path + &quot;;&quot; + f;
			}
		}
	}
	if (PHP_SANITIZER == &quot;yes&quot;) {
		if (CLANG_TOOLSET) {
			extra_path = extra_path + &quot;;&quot; + get_clang_lib_dir() + &quot;\\windows&quot;;
		}
	}
	MF.WriteLine(&quot;set-tmp-env:&quot;);
	MF.WriteLine(&quot;	&quot; + CMD_MOD2 + &quot;set PATH=&quot; + extra_path + &quot;;$(PATH)&quot;);

	MF.WriteBlankLines(2);

	MF.WriteLine(&quot;dump-tmp-env: set-tmp-env&quot;);
	MF.WriteLine(&quot;	&quot; + CMD_MOD2 + &quot;set&quot;);

	MF.WriteBlankLines(2);

	MFO.Close();
	TF = FSO.OpenTextFile(&quot;Makefile.objects&quot;, 1);
	if (!TF.AtEndOfStream) {
		MF.Write(TF.ReadAll());
	}
	TF.Close();
	MF.WriteBlankLines(2);

	if (FSO.FileExists(PHP_MAKEFILE_FRAGMENTS)) {
		TF = FSO.OpenTextFile(PHP_MAKEFILE_FRAGMENTS, 1);
		if (!TF.AtEndOfStream) {
			MF.Write(TF.ReadAll());
		}
		TF.Close();
		MF.WriteBlankLines(2);
		FSO.DeleteFile(PHP_MAKEFILE_FRAGMENTS, true);
	}

	MF.Close();
}

function ADD_FLAG(name, flags, target)
{
	if (target != null) {
		name = target.toUpperCase() + &quot;_&quot; + name;
	}
	flags = trim(flags);
	if (configure_subst.Exists(name)) {
		var curr_flags = configure_subst.Item(name);

		/* Prefix with a space, thus making sure the
		   current flag is not a substring of some
		   other. It&#039;s still not a complete check if
		   some flags with spaces got added.

		   TODO rework to use an array, so direct
		        match can be done. This will also
			help to normalize flags and to not
			to insert duplicates. */
		if (curr_flags.indexOf(&quot; &quot; + flags) &gt;= 0 || curr_flags.indexOf(flags + &quot; &quot;) &gt;= 0) {
			return;
		}

		flags = curr_flags + &quot; &quot; + flags;
		configure_subst.Remove(name);
	}
	configure_subst.Add(name, flags);
}

function get_define(name)
{
	if (configure_subst.Exists(name)) {
		return configure_subst.Item(name);
	}
	return &quot;&quot;;
}

// Add a .def to the core to export symbols
function ADD_DEF_FILE(name)
{
	if (!configure_subst.Exists(&quot;PHPDEF&quot;)) {
		DEFINE(&quot;PHPDEF&quot;, &quot;$(BUILD_DIR)\\$(PHPDLL).def&quot;);
		ADD_FLAG(&quot;PHP_LDFLAGS&quot;, &quot;/def:$(PHPDEF)&quot;);
	}
	ADD_FLAG(&quot;PHP_DLL_DEF_SOURCES&quot;, name);
}

function AC_DEFINE(name, value, comment, quote)
{
	if (quote == null) {
		quote = true;
	}
	if (quote &amp;&amp; typeof(value) == &quot;string&quot;) {
		value = &#039;&quot;&#039; + value.replace(new RegExp(&#039;([&quot;\\\\])&#039;, &quot;g&quot;), &#039;\\$1&#039;) + &#039;&quot;&#039;;
	} else if (typeof(value) != &quot;undefined&quot; &amp;&amp; value.length == 0) {
		value = &#039;&quot;&quot;&#039;;
	}
	var item = new Array(value, comment);
	if (configure_hdr.Exists(name)) {
		var orig_item = configure_hdr.Item(name);
		STDOUT.WriteLine(&quot;AC_DEFINE[&quot; + name + &quot;]=&quot; + value + &quot;: is already defined to &quot; + orig_item[0]);
	} else {
		configure_hdr.Add(name, item);
	}
}

function MESSAGE(msg)
{
	STDOUT.WriteLine(&quot;&quot; + msg);
}

function ERROR(msg)
{
	STDERR.WriteLine(&quot;ERROR: &quot; + msg);
	WScript.Quit(3);
}

function WARNING(msg)
{
	STDERR.WriteLine(&quot;WARNING: &quot; + msg);
	STDERR.WriteBlankLines(1);
}

function copy_and_subst(srcname, destname, subst_array)
{
	if (!FSO.FileExists(srcname)) {
		srcname = configure_module_dirname + &quot;\\&quot; + srcname;
		destname = configure_module_dirname + &quot;\\&quot; + destname;
	}

	var content = file_get_contents(srcname);
	var i;

	for (i = 0; i &lt; subst_array.length; i+=2) {
		var re = subst_array[i];
		var rep = subst_array[i+1];

		content = content.replace(re, rep);
	}

	var f = FSO.CreateTextFile(destname, true);
	f.Write(content);
	f.Close();
}

// glob using simple filename wildcards
// returns an array of matches that are found
// in the filesystem
function glob(path_pattern)
{
	var path_parts = path_pattern.replace(new RegExp(&quot;/&quot;, &quot;g&quot;), &quot;\\&quot;).split(&quot;\\&quot;);
	var p;
	var base = &quot;&quot;;
	var is_pat_re = /\*/;

//STDOUT.WriteLine(&quot;glob: &quot; + path_pattern);

	if (FSO.FileExists(path_pattern)) {
		return new Array(path_pattern);
	}

	// first, build as much as possible that doesn&#039;t have a pattern
	for (p = 0; p &lt; path_parts.length; p++) {
		if (path_parts[p].match(is_pat_re))
			break;
		if (p)
			base += &quot;\\&quot;;
		base += path_parts[p];
	}

	return _inner_glob(base, p, path_parts);
}

function _inner_glob(base, p, parts)
{
	var pat = parts[p];
	var full_name = base + &quot;\\&quot; + pat;
	var re = null;
	var items = null;

	if (p == parts.length) {
		return false;
	}

//STDOUT.WriteLine(&quot;inner: base=&quot; + base + &quot; p=&quot; + p + &quot; pat=&quot; + pat);

	if (FSO.FileExists(full_name)) {
		if (p &lt; parts.length - 1) {
			// we didn&#039;t reach the full extent of the pattern
			return false;
		}
		return new Array(full_name);
	}

	if (FSO.FolderExists(full_name) &amp;&amp; p == parts.length - 1) {
		// we have reached the end of the pattern; no need to recurse
		return new Array(full_name);
	}

	// Convert the pattern into a regexp
	re = new RegExp(&quot;^&quot; + pat.replace(/\./g, &#039;\\.&#039;).replace(/\*/g, &#039;.*&#039;).replace(/\?/g, &#039;.&#039;) + &quot;$&quot;, &quot;i&quot;);

	items = new Array();

	if (!FSO.FolderExists(base)) {
		return false;
	}

	var folder = FSO.GetFolder(base);
	var fc = null;
	var subitems = null;
	var item_name = null;
	var j;

	fc = new Enumerator(folder.SubFolders);
	for (; !fc.atEnd(); fc.moveNext()) {
		item_name = FSO.GetFileName(fc.item());

		if (item_name.match(re)) {
			// got a match; if we are at the end of the pattern, just add these
			// things to the items array
			if (p == parts.length - 1) {
				items[items.length] = fc.item();
			} else {
				// we should recurse and do more matches
				subitems = _inner_glob(base + &quot;\\&quot; + item_name, p + 1, parts);
				if (subitems) {
					for (j = 0; j &lt; subitems.length; j++) {
						items[items.length] = subitems[j];
					}
				}
			}
		}
	}

	// if we are at the end of the pattern, we should match
	// files too
	if (p == parts.length - 1) {
		fc = new Enumerator(folder.Files);
		for (; !fc.atEnd(); fc.moveNext()) {
			item_name = FSO.GetFileName(fc.item());
			if (item_name.match(re)) {
				items[items.length] = fc.item();
			}
		}
	}

	if (items.length == 0)
		return false;

	return items;
}

/* Install Headers */
function PHP_INSTALL_HEADERS(dir, headers_list)
{
	headers_list = headers_list.split(new RegExp(&quot;\\s+&quot;));
	headers_list.sort();
	if (dir.length &gt; 0 &amp;&amp; dir.substr(dir.length - 1) != &#039;/&#039; &amp;&amp; dir.substr(dir.length - 1) != &#039;\\&#039;) {
		dir += &#039;/&#039;;
	}
	dir = dir.replace(new RegExp(&quot;/&quot;, &quot;g&quot;), &quot;\\&quot;);

	for (i in headers_list) {
		found = false;
		src = headers_list[i];
		src = src.replace(new RegExp(&quot;/&quot;, &quot;g&quot;), &quot;\\&quot;);
		isdir = FSO.FolderExists(dir + src);
		isfile = FSO.FileExists(dir + src);
		if (isdir) {
			if (src.length &gt; 0 &amp;&amp; src.substr(src.length - 1) != &#039;/&#039; &amp;&amp; src.substr(src.length - 1) != &#039;\\&#039;) {
				src += &#039;\\&#039;;
			}
			headers_install[headers_install.length] = [dir + src, &#039;dir&#039;,&#039;&#039;];
			ADD_FLAG(&quot;INSTALL_HEADERS_DIR&quot;, dir + src);
			found = true;
		} else if (isfile) {
			dirname = FSO.GetParentFolderName(dir + src);
			headers_install[headers_install.length] = [dir + src, &#039;file&#039;, dirname];
			ADD_FLAG(&quot;INSTALL_HEADERS&quot;, dir + src);
			found = true;
		} else {
			path =  configure_module_dirname + &quot;\\&quot;+ src;
			isdir = FSO.FolderExists(path);
			isfile = FSO.FileExists(path);
			if (isdir) {
				if (src.length &gt; 0 &amp;&amp; src.substr(src.length - 1) != &#039;/&#039; &amp;&amp; src.substr(src.length - 1) != &#039;\\&#039;) {
					src += &#039;\\&#039;;
				}
				headers_install[headers_install.length] = [path, &#039;dir&#039;,&#039;&#039;];
				ADD_FLAG(&quot;INSTALL_HEADERS_DIR&quot;, path);
			} else if (isfile) {
				dirname = FSO.GetParentFolderName(path);
				headers_install[headers_install.length] = [path, &#039;file&#039;, dir];
				ADD_FLAG(&quot;INSTALL_HEADERS&quot;, dir + src);
				found = true;
			}
		}

		if (found == false) {
			STDOUT.WriteLine(headers_list);
			ERROR(&quot;Cannot find header &quot; + dir + src);
		}
	}
}

// For snapshot builders, this option will attempt to enable everything
// and you can then build everything, ignoring fatal errors within a module
// by running &quot;nmake snap&quot;
PHP_SNAPSHOT_BUILD = &quot;no&quot;;
if (!MODE_PHPIZE) {
	ARG_ENABLE(&#039;snapshot-build&#039;, &#039;Build a snapshot; turns on everything it can and ignores build errors&#039;, &#039;no&#039;);
}

function toolset_option_handle()
{
	if (&quot;clang&quot; == PHP_TOOLSET) {
		VS_TOOLSET = false;
		CLANG_TOOLSET = true;
		ICC_TOOLSET = false;
	} else if (&quot;icc&quot; == PHP_TOOLSET) {
		VS_TOOLSET = false;
		CLANG_TOOLSET = false;
		ICC_TOOLSET = true;
	} else {
		/* Visual Studio is the default toolset. */
		PHP_TOOLSET = &quot;no&quot; == PHP_TOOLSET ? &quot;vs&quot; : PHP_TOOLSET;
		if (!!PHP_TOOLSET &amp;&amp; &quot;vs&quot; != PHP_TOOLSET) {
			ERROR(&quot;Unsupported toolset &#039;&quot; + PHP_TOOLSET + &quot;&#039;&quot;);
		}
		VS_TOOLSET = true;
		CLANG_TOOLSET = false;
		ICC_TOOLSET = false;
	}
}

function toolset_setup_compiler()
{
	PHP_CL = toolset_get_compiler();
	if (!PHP_CL) {
		ERROR(&quot;Compiler not found&quot;);
	}

	COMPILER_NUMERIC_VERSION = toolset_get_compiler_version();
	COMPILER_NAME_LONG = toolset_get_compiler_name();
	COMPILER_NAME_SHORT = toolset_get_compiler_name(true);

	if (VS_TOOLSET) {
		VCVERS = COMPILER_NUMERIC_VERSION;

		if (&quot;unknown&quot; == COMPILER_NAME_LONG) {
			var tmp = probe_binary(PHP_CL);
			COMPILER_NAME_LONG = COMPILER_NAME_SHORT = &quot;MSVC &quot; + tmp + &quot;, untested&quot;;

			WARNING(&quot;Using unknown MSVC version &quot; + tmp);

			AC_DEFINE(&#039;PHP_BUILD_COMPILER&#039;, COMPILER_NAME_LONG, &quot;The compiler used for the PHP build.&quot;);
			DEFINE(&quot;PHP_COMPILER_SHORT&quot;, tmp);
			AC_DEFINE(&#039;PHP_COMPILER_ID&#039;, tmp, &quot;Compiler compatibility ID&quot;);
		} else {
			AC_DEFINE(&#039;PHP_BUILD_COMPILER&#039;, COMPILER_NAME_LONG, &quot;The compiler used for the PHP build.&quot;);
			DEFINE(&quot;PHP_COMPILER_SHORT&quot;, COMPILER_NAME_SHORT.toLowerCase());
			AC_DEFINE(&#039;PHP_COMPILER_ID&#039;, COMPILER_NAME_SHORT.toUpperCase(), &quot;Compiler compatibility ID&quot;);
		}
	} else if (CLANG_TOOLSET) {
		CLANGVERS = COMPILER_NUMERIC_VERSION;

		AC_DEFINE(&#039;PHP_BUILD_COMPILER&#039;, COMPILER_NAME_LONG, &quot;The compiler used for the PHP build.&quot;);
		DEFINE(&quot;PHP_COMPILER_SHORT&quot;, &quot;clang&quot;);
		AC_DEFINE(&#039;PHP_COMPILER_ID&#039;, &quot;clang&quot;); /* XXX something better were to write here */

	} else if (ICC_TOOLSET) {
		INTELVERS = COMPILER_NUMERIC_VERSION;

		AC_DEFINE(&#039;PHP_BUILD_COMPILER&#039;, COMPILER_NAME_LONG, &quot;The compiler used for the PHP build.&quot;);
		DEFINE(&quot;PHP_COMPILER_SHORT&quot;, &quot;icc&quot;);
		AC_DEFINE(&#039;PHP_COMPILER_ID&#039;, &quot;icc&quot;); /* XXX something better were to write here */
	}
	STDOUT.WriteLine(&quot;  Detected compiler &quot; + COMPILER_NAME_LONG);
}

function toolset_setup_project_tools()
{
	PATH_PROG(&#039;nmake&#039;);

	// we don&#039;t want to define LIB, as that will override the default library path
	// that is set in that env var
	PATH_PROG(&#039;lib&#039;, null, &#039;MAKE_LIB&#039;);

	var BISON = PATH_PROG(&#039;bison&#039;);
	DEFINE(&#039;BISON_FLAGS&#039;, &#039;-Wall&#039;);
	if (BISON) {
		var BISONVERS = probe_binary(BISON, &quot;longversion&quot;);
		STDOUT.WriteLine(&#039;  Detected bison version &#039; + BISONVERS);

		if (BISONVERS.match(/^\d+.\d+$/)) {
			BISONVERS += &quot;.0&quot;;
		}

		var hm = BISONVERS.match(/(\d+)\.(\d+)\.(\d+)/);
		var nm = MINBISON.match(/(\d+)\.(\d+)\.(\d+)/);

		var intvers =  (hm[1]-0)*10000 + (hm[2]-0)*100 + (hm[3]-0);
		var intmin =  (nm[1]-0)*10000 + (nm[2]-0)*100 + (nm[3]-0);

		if (intvers &lt; intmin) {
			ERROR(&#039;The minimum bison version requirement is &#039; + MINBISON);
		}
	} else {
		ERROR(&#039;bison is required&#039;)
	}

	if (!PATH_PROG(&#039;sed&#039;)) {
		ERROR(&#039;sed is required&#039;)
	}

	var RE2C = PATH_PROG(&#039;re2c&#039;);
	DEFINE(&#039;RE2C_FLAGS&#039;, &#039;--no-generation-date&#039;);
	if (RE2C) {
		var RE2CVERS = probe_binary(RE2C, &quot;version&quot;);
		STDOUT.WriteLine(&#039;  Detected re2c version &#039; + RE2CVERS);

		if (RE2CVERS.match(/^\d+.\d+$/)) {
			RE2CVERS += &quot;.0&quot;;
		}

		var hm = RE2CVERS.match(/(\d+)\.(\d+)\.(\d+)/);
		var nm = MINRE2C.match(/(\d+)\.(\d+)\.(\d+)/);

		var intvers =  (hm[1]-0)*10000 + (hm[2]-0)*100 + (hm[3]-0);
		var intmin =  (nm[1]-0)*10000 + (nm[2]-0)*100 + (nm[3]-0);

		if (intvers &lt; intmin) {
			ERROR(&#039;The minimum RE2C version requirement is &#039; + MINRE2C);
		}
	} else {
		ERROR(&#039;re2c is required&#039;)
	}
	PATH_PROG(&#039;zip&#039;);
	PATH_PROG(&#039;lemon&#039;);
	PATH_PROG(&#039;7za&#039;);

	// avoid picking up midnight commander from cygwin
	if (!PATH_PROG(&#039;mc&#039;, WshShell.Environment(&quot;Process&quot;).Item(&quot;PATH&quot;))) {
		ERROR(&#039;mc is required&#039;)
	}

	// Try locating the manifest tool
	if (VS_TOOLSET) {
		if (!PATH_PROG(&#039;mt&#039;, WshShell.Environment(&quot;Process&quot;).Item(&quot;PATH&quot;))) {
			ERROR(&#039;mt is required&#039;)
		}
	}
}
/* Get compiler if the toolset is supported */
function toolset_get_compiler()
{
	if (VS_TOOLSET) {
		return PATH_PROG(&#039;cl&#039;, null, &#039;PHP_CL&#039;)
	} else if (CLANG_TOOLSET) {
		return PATH_PROG(&#039;clang-cl&#039;, null, &#039;PHP_CL&#039;)
	} else if (ICC_TOOLSET) {
		return PATH_PROG(&#039;icl&#039;, null, &#039;PHP_CL&#039;)
	}

	ERROR(&quot;Unsupported toolset&quot;);
}

/* Get compiler version if the toolset is supported */
function toolset_get_compiler_version()
{
	var version;

	if (VS_TOOLSET) {
		version = probe_binary(PHP_CL).substr(0, 5).replace(&#039;.&#039;, &#039;&#039;);
		if (version &lt; 1920) {
			ERROR(&quot;Building with MSC_VER &quot; + version + &quot; is no longer supported&quot;);
		}
		return version;
	} else if (CLANG_TOOLSET) {
		var command = &#039;cmd /c &quot;&quot;&#039; + PHP_CL + &#039;&quot; -v&quot;&#039;;
		var full = execute(command + &#039;&quot; 2&gt;&amp;1&quot;&#039;);

		if (full.match(/clang version ([\d\.]+)/)) {
			version = RegExp.$1;
			version = version.replace(/\./g, &#039;&#039;);
			if (version &lt; 400) {
				ERROR(&quot;Building with clang &quot; + version + &quot; is no longer supported&quot;);
			}
			return version;
		}
	} else if (ICC_TOOLSET) {
		var command = &#039;cmd /c &quot;&quot;&#039; + PHP_CL + &#039;&quot; -v&quot;&#039;;
		var full = execute(command + &#039;&quot; 2&gt;&amp;1&quot;&#039;);

		if (full.match(/Version (\d+\.\d+\.\d+)/)) {
			version = RegExp.$1;
			version = version.replace(/\./g, &#039;&#039;);
			version = version/100 &lt; 1 ? version*10 : version;

			return version;
		}
	}

	ERROR(&quot;Failed to parse compiler version or unsupported toolset&quot;);
}

/* Get compiler name if the toolset is supported */
function toolset_get_compiler_name(short)
{
	var version;
	short = !!short;

	if (VS_TOOLSET) {
		var name = &quot;unknown&quot;;

		version = probe_binary(PHP_CL).substr(0, 5).replace(&#039;.&#039;, &#039;&#039;);

		if (version &gt;= 1950) {
			// skip
		} else if (version &gt;= 1930) {
			name = short ? &quot;VS17&quot; : &quot;Visual C++ 2022&quot;;
		} else if (version &gt;= 1920) {
			/* NOTE - VS is intentional. Due to changes in recent Visual Studio
						versioning scheme referring to the exact VC++ version is
						hardly predictable. From this version on, it refers to
						Visual Studio version and implies the default toolset.
						When new versions are introduced, adapt also checks in
						php_win32_image_compatible(), if needed. */
			name = short ? &quot;VS16&quot; : &quot;Visual C++ 2019&quot;;
		}

		return name;
	} else if (CLANG_TOOLSET || ICC_TOOLSET) {
		var command = &#039;cmd /c &quot;&quot;&#039; + PHP_CL + &#039;&quot; -v&quot;&#039;;
		var full = execute(command + &#039;&quot; 2&gt;&amp;1&quot;&#039;);

		return full.split(/\n/)[0].replace(/\s/g, &#039; &#039;);
	}

	WARNING(&quot;Unsupported toolset&quot;);
}


function toolset_host_arch()
{
	var command = &#039;cmd /c &quot;where cl.exe&quot;&#039;;
	var clpath = execute(command).split(/\n/)[0].replace(/\s$/, &#039;&#039;);

	var command = &#039;cmd /c &quot;dumpbin &quot;&#039; + clpath + &#039;&quot; /nologo /headers&quot;&#039;;
	var full = execute(command);

	/*
	output is something like
	FILE HEADER VALUES
		8664 machine (x64)
	*/
	var matches = full.match(/FILE HEADER VALUES\s+[A-F0-9]{3,4}\smachine \((x64|x86|ARM64)\)/);

	if(!matches){
		ERROR(&quot;Unsupported toolset host&quot;);
	}

	return matches[1].toLowerCase();
}

function toolset_target_arch()
{
	if (VS_TOOLSET) {
		return probe_binary(PHP_CL, &#039;arch&#039;);
	} else if (CLANG_TOOLSET) {
		/*var command = &#039;cmd /c &quot;&quot;&#039; + PHP_CL + &#039;&quot; -v&quot;&#039;;
		var full = execute(command + &#039;&quot; 2&gt;&amp;1&quot;&#039;);

		return null != full.match(/x86_64/);*/

		/* Even executed within an environment setup with vcvars32.bat,
		clang-cl doesn&#039;t recognize the arch toolset. But as it needs
		the VS environment, checking the arch of cl.exe is correct. */
		return probe_binary(PATH_PROG(&#039;cl&#039;, null), &#039;arch&#039;);
	} else if (ICC_TOOLSET) {
		var command = &#039;cmd /c &quot;where cl&quot;&#039;;
		var full = execute(command + &#039;&quot; 2&gt;&amp;1&quot;&#039;);

		return null != full.match(/Intel\(R\) 64/);
	}

	ERROR(&quot;Unsupported toolset target&quot;);
}

function toolset_setup_arch()
{
	STDOUT.WriteLine(&quot;  Detected &quot; + TARGET_ARCH + &quot; compiler&quot; + (TARGET_ARCH == HOST_ARCH ? &quot;&quot; : &quot; (cross compile from &quot; + HOST_ARCH + &quot;)&quot;));
	AC_DEFINE(&#039;PHP_BUILD_ARCH&#039;, TARGET_ARCH, &quot;The build architecture.&quot;);
	DEFINE(&quot;PHP_ARCHITECTURE&quot;, TARGET_ARCH);
}

function toolset_setup_codegen_arch()
{
	if(&quot;no&quot; == PHP_CODEGEN_ARCH || &quot;yes&quot; == PHP_CODEGEN_ARCH) {
		return;
	}

	if (VS_TOOLSET) {
		var arc = PHP_CODEGEN_ARCH.toUpperCase();

		if (&quot;IA32&quot; != arc) {
			ERROR(&quot;Only IA32 arch is supported by --with-codegen-arch, got &#039;&quot; + arc + &quot;&#039;&quot;);
		} else if (TARGET_ARCH != &#039;x86&#039;) {
			ERROR(&quot;IA32 arch is only supported with 32-bit build&quot;);
		}
		ADD_FLAG(&quot;CFLAGS&quot;, &quot;/arch:&quot; + arc);
		PHP_NATIVE_INTRINSICS = &quot;disabled&quot;;
	}
}

function toolset_setup_linker()
{
	var lnk = false;
	if (VS_TOOLSET) {
		lnk = PATH_PROG(&#039;link&#039;, null);
	} else if (CLANG_TOOLSET) {
		//return PATH_PROG(&#039;lld&#039;, WshShell.Environment(&quot;Process&quot;).Item(&quot;PATH&quot;), &quot;LINK&quot;);
		lnk = PATH_PROG(&#039;link&#039;, WshShell.Environment(&quot;Process&quot;).Item(&quot;PATH&quot;));
	} else if (ICC_TOOLSET) {
		lnk = PATH_PROG(&#039;xilink&#039;, WshShell.Environment(&quot;Process&quot;).Item(&quot;PATH&quot;), &quot;LINK&quot;);
	}

	if (!lnk) {
		ERROR(&quot;Unsupported toolset&quot;);
	}

	var ver = probe_binary(lnk);

	var major = ver.substr(0, 2);
	var minor = ver.substr(3, 2);

	AC_DEFINE(&#039;PHP_LINKER_MAJOR&#039;, major, &quot;Linker major version&quot;, false);
	AC_DEFINE(&#039;PHP_LINKER_MINOR&#039;, minor, &quot;Linker minor version&quot;, false);

	return lnk;
}

function toolset_setup_common_cflags()
{
	var envCFLAGS = WshShell.Environment(&quot;PROCESS&quot;).Item(&quot;CFLAGS&quot;);

	// CFLAGS for building the PHP dll
	DEFINE(&quot;CFLAGS_PHP&quot;, &quot;/D _USRDLL /D PHP_EXPORTS \
	/D LIBZEND_EXPORTS /D TSRM_EXPORTS /D SAPI_EXPORTS /D WINVER=&quot; + WINVER);

	DEFINE(&#039;CFLAGS_PHP_OBJ&#039;, &#039;$(CFLAGS_PHP) $(STATIC_EXT_CFLAGS)&#039;);

	// General CFLAGS for building objects
	DEFINE(&quot;CFLAGS&quot;, &quot;/nologo $(BASE_INCLUDES) /D _WINDOWS /D WINDOWS=1 \
		/D ZEND_WIN32=1 /D PHP_WIN32=1 /D WIN32 /D _MBCS \
		/D _USE_MATH_DEFINES&quot;);

	if (envCFLAGS) {
		ADD_FLAG(&quot;CFLAGS&quot;, envCFLAGS);
	}

	if (VS_TOOLSET) {
		ADD_FLAG(&quot;CFLAGS&quot;, &quot; /FD &quot;);

		// fun stuff: MS deprecated ANSI stdio and similar functions
		// disable annoying warnings.  In addition, time_t defaults
		// to 64-bit.  Ask for 32-bit.
		if (TARGET_ARCH == &#039;x86&#039;) {
			ADD_FLAG(&#039;CFLAGS&#039;, &#039; /wd4996 /D_USE_32BIT_TIME_T=1 &#039;);
		} else {
			ADD_FLAG(&#039;CFLAGS&#039;, &#039; /wd4996 &#039;);
		}

		if (PHP_DEBUG == &quot;yes&quot;) {
			// Set some debug/release specific options
			ADD_FLAG(&#039;CFLAGS&#039;, &#039; /RTC1 &#039;);
		} else {
			if (PHP_DEBUG == &quot;no&quot; &amp;&amp; PHP_SECURITY_FLAGS == &quot;yes&quot;) {
				/* Mitigations for CVE-2017-5753. */
				ADD_FLAG(&#039;CFLAGS&#039;, &quot;/Qspectre&quot;);
			}
			if (PHP_SECURITY_FLAGS == &quot;yes&quot;) {
				ADD_FLAG(&#039;CFLAGS&#039;, &quot;/guard:cf&quot;);
			}
			if (PHP_PGI != &quot;yes&quot; &amp;&amp; PHP_PGO != &quot;yes&quot;) {
				ADD_FLAG(&#039;CFLAGS&#039;, &quot;/Zc:inline&quot;);
			}
			/* We enable /opt:icf only with the debug pack, so /Gw only makes sense there, too. */
			if (PHP_DEBUG_PACK == &quot;yes&quot;) {
				ADD_FLAG(&#039;CFLAGS&#039;, &quot;/Gw&quot;);
			}
		}

		/* This is only in effect for CXX sources, __cplusplus is not defined in C sources. */
		ADD_FLAG(&quot;CFLAGS&quot;, &quot;/Zc:__cplusplus&quot;);

		ADD_FLAG(&quot;CFLAGS&quot;, &quot;/d2FuncCache1&quot;);

		if (VCVERS &gt;= 1930) {
			ADD_FLAG(&quot;CFLAGS&quot;, &quot;/Zc:preprocessor&quot;);
		}

		ADD_FLAG(&quot;CFLAGS&quot;, &quot;/Zc:wchar_t&quot;);
	} else if (CLANG_TOOLSET) {
		if (TARGET_ARCH == &#039;x86&#039;) {
			ADD_FLAG(&#039;CFLAGS&#039;, &#039;-m32&#039;);
		} else {
			ADD_FLAG(&#039;CFLAGS&#039;, &#039;-m64&#039;);
		}
		if (CLANGVERS &lt; 1300) {
			ADD_FLAG(&quot;CFLAGS&quot;, &quot; /fallback &quot;);
		}
		ADD_FLAG(&quot;CFLAGS&quot;, &quot;-Xclang -fmodules&quot;);

		var vc_ver = probe_binary(PATH_PROG(&#039;cl&#039;, null));
		ADD_FLAG(&quot;CFLAGS&quot;,&quot; -fms-compatibility -fms-compatibility-version=&quot; + vc_ver + &quot; -fms-extensions&quot;);
	}
}

function toolset_setup_intrinsic_cflags()
{
	var default_enabled = &quot;sse2&quot;;
	var avail = WScript.CreateObject(&quot;Scripting.Dictionary&quot;);
	avail.Add(&quot;sse&quot;, &quot;__SSE__&quot;);
	avail.Add(&quot;sse2&quot;, &quot;__SSE2__&quot;);
	avail.Add(&quot;sse3&quot;, &quot;__SSE3__&quot;);
	avail.Add(&quot;ssse3&quot;, &quot;__SSSE3__&quot;);
	avail.Add(&quot;sse4.1&quot;, &quot;__SSE4_1__&quot;);
	avail.Add(&quot;sse4.2&quot;, &quot;__SSE4_2__&quot;);
	/* From oldest to newest. */
	var scale = new Array(&quot;sse&quot;, &quot;sse2&quot;, &quot;sse3&quot;, &quot;ssse3&quot;, &quot;sse4.1&quot;, &quot;sse4.2&quot;, &quot;avx&quot;, &quot;avx2&quot;, &quot;avx512&quot;);

	if (VS_TOOLSET) {
		if (&quot;disabled&quot; == PHP_NATIVE_INTRINSICS) {
			ERROR(&quot;Can&#039;t enable intrinsics, --with-codegen-arch passed with an incompatible option. &quot;)
		}

		if (TARGET_ARCH == &#039;arm64&#039;) {
			/* arm64 supports neon */
			configure_subst.Add(&quot;PHP_SIMD_SCALE&quot;, &#039;NEON&#039;);
			/* all officially supported arm64 cpu supports crc32 (TODO: to be confirmed) */
			AC_DEFINE(&#039;HAVE_ARCH64_CRC32&#039;, 1);
			return;
		}

		if (&quot;no&quot; == PHP_NATIVE_INTRINSICS || &quot;yes&quot; == PHP_NATIVE_INTRINSICS) {
			PHP_NATIVE_INTRINSICS = default_enabled;
		}

		if (&quot;all&quot; == PHP_NATIVE_INTRINSICS) {
			var list = (new VBArray(avail.Keys())).toArray();

			for (var i in list) {
				AC_DEFINE(avail.Item(list[i]), 1);
			}

			/* All means all. __AVX__, __AVX2__, and __AVX512*__ are defined by compiler. */
			ADD_FLAG(&quot;CFLAGS&quot;,&quot;/arch:AVX512&quot;);
			configure_subst.Add(&quot;PHP_SIMD_SCALE&quot;, &quot;AVX512&quot;);
		} else {
			var list = PHP_NATIVE_INTRINSICS.split(&quot;,&quot;);
			var j = 0;
			for (var k = 0; k &lt; scale.length; k++) {
				for (var i = 0; i &lt; list.length; i++) {
					var it = list[i].toLowerCase();
					if (scale[k] == it) {
						j = k &gt; j ? k : j;
					} else if (!avail.Exists(it) &amp;&amp; &quot;avx512&quot; != it &amp;&amp; &quot;avx2&quot; != it &amp;&amp; &quot;avx&quot; != it) {
						WARNING(&quot;Unknown intrinsic name &#039;&quot; + it + &quot;&#039; ignored&quot;);
					}
				}
			}
			if (TARGET_ARCH == &#039;x86&#039;) {
				/* SSE2 is currently the default on 32-bit. It could change later,
					for now no need to pass it. But, if SSE only was chosen,
					/arch:SSE is required. */
				if (&quot;sse&quot; == scale[j]) {
					ADD_FLAG(&quot;CFLAGS&quot;,&quot;/arch:SSE&quot;);
				}
			}
			configure_subst.Add(&quot;PHP_SIMD_SCALE&quot;, scale[j].toUpperCase());
			/* There is no explicit way to enable intrinsics between SSE3 and SSE4.2.
				The declared macros therefore won&#039;t affect the code generation,
				but will enable the guarded code parts. */
			if (&quot;avx512&quot; == scale[j]) {
				ADD_FLAG(&quot;CFLAGS&quot;,&quot;/arch:AVX512&quot;);
				j -= 3;
			} else if (&quot;avx2&quot; == scale[j]) {
				ADD_FLAG(&quot;CFLAGS&quot;,&quot;/arch:AVX2&quot;);
				j -= 2;
			} else if (&quot;avx&quot; == scale[j]) {
				ADD_FLAG(&quot;CFLAGS&quot;,&quot;/arch:AVX&quot;);
				j -= 1;
			}
			for (var i = 0; i &lt;= j; i++) {
				var it = scale[i];
				AC_DEFINE(avail.Item(it), 1);
			}
		}
	}
}

function toolset_setup_common_ldlags()
{
	var envLDFLAGS = WshShell.Environment(&quot;PROCESS&quot;).Item(&quot;LDFLAGS&quot;);

	// General DLL link flags
	DEFINE(&quot;DLL_LDFLAGS&quot;, &quot;/dll &quot;);

	// PHP DLL link flags
	DEFINE(&quot;PHP_LDFLAGS&quot;, &quot;$(DLL_LDFLAGS)&quot;);

	DEFINE(&quot;LDFLAGS&quot;, &quot;/nologo &quot;);

	if (envLDFLAGS) {
		ADD_FLAG(&quot;LDFLAGS&quot;, envLDFLAGS);
	}

	// we want msvcrt in the PHP DLL
	ADD_FLAG(&quot;PHP_LDFLAGS&quot;, &quot;/nodefaultlib:libcmt&quot;);

	if (VS_TOOLSET) {
		if (PHP_SECURITY_FLAGS == &quot;yes&quot;) {
			ADD_FLAG(&#039;LDFLAGS&#039;, &quot;/GUARD:CF&quot;);
		}
		if (PHP_VS_LINK_COMPAT != &quot;no&quot;) {
			// Allow compatible IL versions, do not require an exact match.
			// Prevents build failures where different libs were built with different (but compatible) IL versions.
			// See fatal error C1047.
			ADD_FLAG(&quot;LDFLAGS&quot;, &quot;/d2:-AllowCompatibleILVersions &quot;);
		}
	}
}

function toolset_setup_common_libs()
{
	// urlmon.lib ole32.lib oleaut32.lib uuid.lib gdi32.lib winspool.lib comdlg32.lib
	DEFINE(&quot;LIBS&quot;, &quot;kernel32.lib ole32.lib user32.lib advapi32.lib shell32.lib ws2_32.lib Dnsapi.lib psapi.lib bcrypt.lib&quot;);
}

function toolset_setup_build_mode()
{
	if (PHP_DEBUG == &quot;yes&quot;) {
		ADD_FLAG(&quot;CFLAGS&quot;, &quot;/LDd /MDd /Od /D _DEBUG /D ZEND_DEBUG=1 &quot; +
			(TARGET_ARCH == &#039;x86&#039;?&quot;/ZI&quot;:&quot;/Zi&quot;));
		ADD_FLAG(&quot;LDFLAGS&quot;, &quot;/debug&quot;);
		// Avoid problems when linking to release libraries that use the release
		// version of the libc
		ADD_FLAG(&quot;PHP_LDFLAGS&quot;, &quot;/nodefaultlib:msvcrt&quot;);
	} else {
		// Generate external debug files when --enable-debug-pack is specified
		if (PHP_DEBUG_PACK == &quot;yes&quot;) {
			ADD_FLAG(&quot;CFLAGS&quot;, &quot;/Zi&quot;);
			ADD_FLAG(&quot;LDFLAGS&quot;, &quot;/incremental:no /debug /opt:ref,icf&quot;);
		}
		ADD_FLAG(&quot;CFLAGS&quot;, &quot;/LD /MD&quot;);
		if (PHP_SANITIZER == &quot;yes&quot; &amp;&amp; CLANG_TOOLSET) {
			ADD_FLAG(&quot;CFLAGS&quot;, &quot;/Od /D NDebug /D NDEBUG /D ZEND_WIN32_NEVER_INLINE /D ZEND_DEBUG=0&quot;);
		} else {
			// Equivalent to Release_TSInline build -&gt; best optimization
			ADD_FLAG(&quot;CFLAGS&quot;, &quot;/Ox /D NDebug /D NDEBUG /GF /D ZEND_DEBUG=0&quot;);
		}

		// if you have VS.Net /GS hardens the binary against buffer overruns
		// ADD_FLAG(&quot;CFLAGS&quot;, &quot;/GS&quot;);
	}
}

function object_out_dir_option_handle()
{
	if (PHP_OBJECT_OUT_DIR.length) {
		PHP_OBJECT_OUT_DIR = FSO.GetAbsolutePathName(PHP_OBJECT_OUT_DIR);
		if (!FSO.FolderExists(PHP_OBJECT_OUT_DIR)) {
			ERROR(&#039;chosen output directory &#039; + PHP_OBJECT_OUT_DIR + &#039; does not exist&#039;);
		}
		PHP_OBJECT_OUT_DIR += &#039;\\&#039;;
	} else {
		PHP_OBJECT_OUT_DIR = FSO.GetAbsolutePathName(&quot;.&quot;) + &#039;\\&#039;;

		if (TARGET_ARCH == &#039;x64&#039;) {
			PHP_OBJECT_OUT_DIR += &#039;x64\\&#039;;
			if (!FSO.FolderExists(PHP_OBJECT_OUT_DIR)) {
				FSO.CreateFolder(PHP_OBJECT_OUT_DIR);
			}
		} else if (TARGET_ARCH == &#039;arm64&#039;) {
			PHP_OBJECT_OUT_DIR += &#039;arm64\\&#039;;
			if (!FSO.FolderExists(PHP_OBJECT_OUT_DIR)) {
				FSO.CreateFolder(PHP_OBJECT_OUT_DIR);
			}
		}
	}
}

function setup_zts_stuff()
{
	if (PHP_ZTS == &quot;yes&quot;) {
		ADD_FLAG(&quot;CFLAGS&quot;, &quot;/D ZTS=1&quot;);
		ADD_FLAG(&quot;ZTS&quot;, &quot;1&quot;);
	} else {
		ADD_FLAG(&quot;ZTS&quot;, &quot;0&quot;);
	}

	DEFINE(&quot;PHP_ZTS_ARCHIVE_POSTFIX&quot;, PHP_ZTS == &quot;yes&quot; ? &#039;&#039; : &quot;-nts&quot;);

	// set up the build dir and DLL name
	if (PHP_DEBUG == &quot;yes&quot; &amp;&amp; PHP_ZTS == &quot;yes&quot;) {
		DEFINE(&quot;BUILD_DIR&quot;, PHP_OBJECT_OUT_DIR + &quot;Debug_TS&quot;);
		if (!MODE_PHPIZE) {
			DEFINE(&quot;PHPDLL&quot;, &quot;php&quot; + PHP_VERSION + &quot;ts_debug.dll&quot;);
			DEFINE(&quot;PHPLIB&quot;, &quot;php&quot; + PHP_VERSION + &quot;ts_debug.lib&quot;);
		}
	} else if (PHP_DEBUG == &quot;yes&quot; &amp;&amp; PHP_ZTS == &quot;no&quot;) {
		DEFINE(&quot;BUILD_DIR&quot;, PHP_OBJECT_OUT_DIR + &quot;Debug&quot;);
		if (!MODE_PHPIZE) {
			DEFINE(&quot;PHPDLL&quot;, &quot;php&quot; + PHP_VERSION + &quot;_debug.dll&quot;);
			DEFINE(&quot;PHPLIB&quot;, &quot;php&quot; + PHP_VERSION + &quot;_debug.lib&quot;);
		}
	} else if (PHP_DEBUG == &quot;no&quot; &amp;&amp; PHP_ZTS == &quot;yes&quot;) {
		DEFINE(&quot;BUILD_DIR&quot;, PHP_OBJECT_OUT_DIR + &quot;Release_TS&quot;);
		if (!MODE_PHPIZE) {
			DEFINE(&quot;PHPDLL&quot;, &quot;php&quot; + PHP_VERSION + &quot;ts.dll&quot;);
			DEFINE(&quot;PHPLIB&quot;, &quot;php&quot; + PHP_VERSION + &quot;ts.lib&quot;);
		}
	} else if (PHP_DEBUG == &quot;no&quot; &amp;&amp; PHP_ZTS == &quot;no&quot;) {
		DEFINE(&quot;BUILD_DIR&quot;, PHP_OBJECT_OUT_DIR + &quot;Release&quot;);
		if (!MODE_PHPIZE) {
			DEFINE(&quot;PHPDLL&quot;, &quot;php&quot; + PHP_VERSION + &quot;.dll&quot;);
			DEFINE(&quot;PHPLIB&quot;, &quot;php&quot; + PHP_VERSION + &quot;.lib&quot;);
		}
	}

	if (!FSO.FolderExists(get_define(&#039;BUILD_DIR&#039;))) {
		FSO.CreateFolder(get_define(&#039;BUILD_DIR&#039;));
	}
}

function php_build_option_handle()
{
	if (PHP_PHP_BUILD == &#039;no&#039;) {
		if (FSO.FolderExists(&quot;..\\deps&quot;)) {
			PHP_PHP_BUILD = &quot;..\\deps&quot;;
		} else {
			if (FSO.FolderExists(&quot;..\\php_build&quot;)) {
				PHP_PHP_BUILD = &quot;..\\php_build&quot;;
			} else {
				if (TARGET_ARCH != &#039;x86&#039;) {
					if (FSO.FolderExists(&quot;..\\win64build&quot;)) {
						PHP_PHP_BUILD = &quot;..\\win64build&quot;;
					} else if (FSO.FolderExists(&quot;..\\php-win64-dev\\php_build&quot;)) {
						PHP_PHP_BUILD = &quot;..\\php-win64-dev\\php_build&quot;;
					}
				} else {
					if (FSO.FolderExists(&quot;..\\win32build&quot;)) {
						PHP_PHP_BUILD = &quot;..\\win32build&quot;;
					} else if (FSO.FolderExists(&quot;..\\php-win32-dev\\php_build&quot;)) {
						PHP_PHP_BUILD = &quot;..\\php-win32-dev\\php_build&quot;;
					}
				}
			}
		}
		PHP_PHP_BUILD = FSO.GetAbsolutePathName(PHP_PHP_BUILD);
	}
	DEFINE(&quot;PHP_BUILD&quot;, PHP_PHP_BUILD);
}

// Poke around for some headers
function probe_basic_headers()
{
	var p;

	if (PHP_PHP_BUILD != &quot;no&quot;) {
		php_usual_include_suspects += &quot;;&quot; + PHP_PHP_BUILD + &quot;\\include&quot;;
		php_usual_lib_suspects += &quot;;&quot; + PHP_PHP_BUILD + &quot;\\lib&quot;;
	}
}

function add_extra_dirs()
{
	var path, i, f;

	if (PHP_EXTRA_INCLUDES.length) {
		path = PHP_EXTRA_INCLUDES.split(&#039;;&#039;);
		for (i = 0; i &lt; path.length; i++) {
			f = FSO.GetAbsolutePathName(path[i]);
			if (FSO.FolderExists(f)) {
				ADD_FLAG(&quot;CFLAGS&quot;, &#039;/I &quot;&#039; + f + &#039;&quot; &#039;);
			}
		}
	}
	if (PHP_EXTRA_LIBS.length) {
		path = PHP_EXTRA_LIBS.split(&#039;;&#039;);
		for (i = 0; i &lt; path.length; i++) {
			f = FSO.GetAbsolutePathName(path[i]);
			if (FSO.FolderExists(f)) {
				ADD_FLAG(&quot;LDFLAGS&quot;, &#039;/libpath:&quot;&#039; + f + &#039;&quot; &#039;);
				ADD_FLAG(&quot;ARFLAGS&quot;, &#039;/libpath:&quot;&#039; + f + &#039;&quot; &#039;);
			}
		}
	}

}

function trim(s)
{
	return s.replace(/^\s+/, &quot;&quot;).replace(/\s+$/, &quot;&quot;);
}

function force_all_shared()
{
	return !!PHP_ALL_SHARED &amp;&amp; &quot;yes&quot; == PHP_ALL_SHARED;
}

function ADD_MAKEFILE_FRAGMENT(src_file)
{
	var fn_in;

	if (&quot;undefined&quot; == typeof(src_file)) {
		fn_in = configure_module_dirname + &quot;\\Makefile.frag.w32&quot;;
	} else {
		fn_in = src_file;
	}

	if (FSO.FileExists(fn_in)) {
		var h_in, h_out;
		var create_out_fl = !FSO.FileExists(PHP_MAKEFILE_FRAGMENTS);
		var open_flags = create_out_fl ? 2 : 8;

		h_in = FSO.OpenTextFile(fn_in, 1);
		h_out = FSO.OpenTextFile(PHP_MAKEFILE_FRAGMENTS, open_flags, create_out_fl);

		if (!h_in.AtEndOfStream) {
			h_out.Write(h_in.ReadAll());
			h_out.WriteBlankLines(1);
		}

		h_in.Close();
		h_out.Close();
	}
}

function SETUP_OPENSSL(target, path_to_check, common_name, use_env, add_dir_part, add_to_flag_only)
{
	var ret = 0;
	var cflags_var = &quot;CFLAGS_&quot; + target.toUpperCase();

	if (CHECK_LIB(&quot;libcrypto.lib&quot;, target, path_to_check) &amp;&amp;
			CHECK_LIB(&quot;libssl.lib&quot;, target, path_to_check) &amp;&amp;
			CHECK_LIB(&quot;crypt32.lib&quot;, target, path_to_check, common_name) &amp;&amp;
			CHECK_HEADER_ADD_INCLUDE(&quot;openssl/ssl.h&quot;, cflags_var, path_to_check, use_env, add_dir_part, add_to_flag_only)) {
		/* Openssl 1.1.x or later */
		return 2;
	}

	return ret;
}

function SETUP_SQLITE3(target, path_to_check, shared) {
	var cflags_var = &quot;CFLAGS_&quot; + target.toUpperCase();
	var libs = (shared ? &quot;libsqlite3.lib;libsqlite3_a.lib&quot; : &quot;libsqlite3_a.lib;libsqlite3.lib&quot;);

	return CHECK_LIB(libs, target, path_to_check) &amp;&amp;
		CHECK_HEADER_ADD_INCLUDE(&quot;sqlite3.h&quot;, cflags_var) &amp;&amp;
		CHECK_HEADER_ADD_INCLUDE(&quot;sqlite3ext.h&quot;, cflags_var);
}

function check_binary_tools_sdk()
{
	var BIN_TOOLS_SDK_VER_MAJOR = 0;
	var BIN_TOOLS_SDK_VER_MINOR = 0;
	var BIN_TOOLS_SDK_VER_PATCH = 0;

	var out = execute(&quot;cmd /c phpsdk_version&quot;);

	if (out.match(/PHP SDK (\d+)\.(\d+)\.(\d+).*/)) {
		BIN_TOOLS_SDK_VER_MAJOR = parseInt(RegExp.$1);
		BIN_TOOLS_SDK_VER_MINOR = parseInt(RegExp.$2);
		BIN_TOOLS_SDK_VER_PATCH = parseInt(RegExp.$3);
	}

	/* Basic test, extend by need. */
	if (BIN_TOOLS_SDK_VER_MAJOR &lt; 2) {
		ERROR(&quot;Incompatible binary tools version. Please consult\r\nhttps://wiki.php.net/internals/windows/stepbystepbuild_sdk_2&quot;);
	}
}

function get_clang_lib_dir()
{
	var ret = null;
	var ver = null;

	if (COMPILER_NAME_LONG.match(/clang version ([\d\.]+) \((.*)\)/)) {
		ver = RegExp.$1;
	} else {
		ERROR(&quot;Failed to determine clang lib path&quot;);
	}

	if (TARGET_ARCH != &#039;x86&#039;) {
		ret = PROGRAM_FILES + &quot;\\LLVM\\lib\\clang\\&quot; + ver + &quot;\\lib&quot;;
		if (!FSO.FolderExists(ret)) {
			ret = null;
		}
	} else {
		ret = PROGRAM_FILESx86 + &quot;\\LLVM\\lib\\clang\\&quot; + ver + &quot;\\lib&quot;;
		if (!FSO.FolderExists(ret)) {
			ret = PROGRAM_FILES + &quot;\\LLVM\\lib\\clang\\&quot; + ver + &quot;\\lib&quot;;
			if (!FSO.FolderExists(ret)) {
				ret = null;
			}
		}
	}

	if (null == ret) {
		ERROR(&quot;Invalid clang lib path encountered&quot;);
	}

	return ret;
}

function add_asan_opts(cflags_name, libs_name, ldflags_name)
{

	var ver = null;

	if (COMPILER_NAME_LONG.match(/clang version ([\d\.]+) \((.*)\)/)) {
		ver = RegExp.$1;
	} else {
		ERROR(&quot;Failed to determine clang lib path&quot;);
	}

	if (!!cflags_name) {
		ADD_FLAG(cflags_name, &quot;-fsanitize=address,undefined&quot;);
	}
	if (!!libs_name) {
		if (TARGET_ARCH == &#039;x64&#039;) {
			ADD_FLAG(libs_name, &quot;clang_rt.asan_dynamic-x86_64.lib clang_rt.asan_dynamic_runtime_thunk-x86_64.lib&quot;);
		} else if (TARGET_ARCH == &#039;x86&#039;) {
			ADD_FLAG(libs_name, &quot;clang_rt.asan_dynamic-i386.lib clang_rt.asan_dynamic_runtime_thunk-i386.lib&quot;);
		} else {
			// TODO: support arm64?
			ERROR(&quot;Failed to determine clang lib path&quot;);
		}
	}

	if (!!ldflags_name) {
		ADD_FLAG(ldflags_name, &quot;/libpath:\&quot;&quot; + get_clang_lib_dir() + &quot;\\windows\&quot;&quot;);
	}
}

function setup_verbosity()
{
	if (&quot;no&quot; != PHP_VERBOSITY) {
		if (&quot;yes&quot; == PHP_VERBOSITY) {
			VERBOSITY = 1;
			if (1 == VERBOSITY) {
				CMD_MOD1 = &quot;&quot;;
			}
		} else {
			var _tmp = parseInt(PHP_VERBOSITY);
			if (0 != _tmp &amp;&amp; 1 != _tmp &amp;&amp; 2 != _tmp) {
				ERROR(&quot;Unsupported verbosity level &#039;&quot; + PHP_VERBOSITY + &quot;&#039;&quot;);
			}
			VERBOSITY = _tmp;

			if (1 == VERBOSITY) {
				CMD_MOD1 = &quot;&quot;;
			}
			if (2 == VERBOSITY) {
				CMD_MOD1 = &quot;&quot;;
				CMD_MOD2 = &quot;&quot;;
			}
		}
	} else {
		VERBOSITY = 0;
		CMD_MOD1 = &quot;@&quot;;
		CMD_MOD2 = &quot;@&quot;;
	}
}

try {
	ARG_ENABLE(&#039;vs-link-compat&#039;, &#039;Allow linking of libraries built with compatible versions of VS toolset&#039;, &#039;yes&#039;);
} catch (e) {
	STDOUT.WriteLine(&quot;problem: &quot; + e);
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fwin32%2Fbuild'>🔙 Back</a></p>