rapid_stack 1.0.0 → 1.0.2

data/lib/rapid_stack/generators/generator-rapid/node_modules/node-gyp/gyp/pylib/gyp/generator/make.py

@@ -50,7 +50,7 @@ generator_default_variables = {
 }
 
 # Make supports multiple toolsets
-generator_supports_multiple_toolsets = gyp.common.CrossCompileRequested()
+generator_supports_multiple_toolsets = True
 
 # Request sorted dependencies in the order from dependents to dependencies.
 generator_wants_sorted_dependencies = False
@@ -99,9 +99,6 @@ def CalculateVariables(default_variables, params):
         default_variables.setdefault("OS", operating_system)
         if flavor == "aix":
             default_variables.setdefault("SHARED_LIB_SUFFIX", ".a")
-        elif flavor == "zos":
-            default_variables.setdefault("SHARED_LIB_SUFFIX", ".x")
-            COMPILABLE_EXTENSIONS.update({".pli": "pli"})
         else:
             default_variables.setdefault("SHARED_LIB_SUFFIX", ".so")
         default_variables.setdefault("SHARED_LIB_DIR", "$(builddir)/lib.$(TOOLSET)")
@@ -157,31 +154,6 @@ cmd_alink_thin = rm -f $@ && $(AR.$(TOOLSET)) crsT $@ $(filter %.o,$^)
 quiet_cmd_link = LINK($(TOOLSET)) $@
 cmd_link = $(LINK.$(TOOLSET)) -o $@ $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,--start-group $(LD_INPUTS) $(LIBS) -Wl,--end-group
 
-# Note: this does not handle spaces in paths
-define xargs
-  $(1) $(word 1,$(2))
-$(if $(word 2,$(2)),$(call xargs,$(1),$(wordlist 2,$(words $(2)),$(2))))
-endef
-
-define write-to-file
-  @: >$(1)
-$(call xargs,@printf "%s\\n" >>$(1),$(2))
-endef
-
-OBJ_FILE_LIST := ar-file-list
-
-define create_archive
-        rm -f $(1) $(1).$(OBJ_FILE_LIST); mkdir -p `dirname $(1)`
-        $(call write-to-file,$(1).$(OBJ_FILE_LIST),$(filter %.o,$(2)))
-        $(AR.$(TOOLSET)) crs $(1) @$(1).$(OBJ_FILE_LIST)
-endef
-
-define create_thin_archive
-        rm -f $(1) $(OBJ_FILE_LIST); mkdir -p `dirname $(1)`
-        $(call write-to-file,$(1).$(OBJ_FILE_LIST),$(filter %.o,$(2)))
-        $(AR.$(TOOLSET)) crsT $(1) @$(1).$(OBJ_FILE_LIST)
-endef
-
 # We support two kinds of shared objects (.so):
 # 1) shared_library, which is just bundling together many dependent libraries
 # into a link line.
@@ -226,31 +198,6 @@ cmd_alink = rm -f $@ && $(AR.$(TOOLSET)) crs $@ $(filter %.o,$^)
 quiet_cmd_alink_thin = AR($(TOOLSET)) $@
 cmd_alink_thin = rm -f $@ && $(AR.$(TOOLSET)) crsT $@ $(filter %.o,$^)
 
-# Note: this does not handle spaces in paths
-define xargs
-  $(1) $(word 1,$(2))
-$(if $(word 2,$(2)),$(call xargs,$(1),$(wordlist 2,$(words $(2)),$(2))))
-endef
-
-define write-to-file
-  @: >$(1)
-$(call xargs,@printf "%s\\n" >>$(1),$(2))
-endef
-
-OBJ_FILE_LIST := ar-file-list
-
-define create_archive
-        rm -f $(1) $(1).$(OBJ_FILE_LIST); mkdir -p `dirname $(1)`
-        $(call write-to-file,$(1).$(OBJ_FILE_LIST),$(filter %.o,$(2)))
-        $(AR.$(TOOLSET)) crs $(1) @$(1).$(OBJ_FILE_LIST)
-endef
-
-define create_thin_archive
-        rm -f $(1) $(OBJ_FILE_LIST); mkdir -p `dirname $(1)`
-        $(call write-to-file,$(1).$(OBJ_FILE_LIST),$(filter %.o,$(2)))
-        $(AR.$(TOOLSET)) crsT $(1) @$(1).$(OBJ_FILE_LIST)
-endef
-
 # Due to circular dependencies between libraries :(, we wrap the
 # special "figure out circular dependencies" flags around the entire
 # input list during linking.
@@ -290,24 +237,6 @@ cmd_solink_module = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSE
 """  # noqa: E501
 
 
-LINK_COMMANDS_OS400 = """\
-quiet_cmd_alink = AR($(TOOLSET)) $@
-cmd_alink = rm -f $@ && $(AR.$(TOOLSET)) -X64 crs $@ $(filter %.o,$^)
-
-quiet_cmd_alink_thin = AR($(TOOLSET)) $@
-cmd_alink_thin = rm -f $@ && $(AR.$(TOOLSET)) -X64 crs $@ $(filter %.o,$^)
-
-quiet_cmd_link = LINK($(TOOLSET)) $@
-cmd_link = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(LD_INPUTS) $(LIBS)
-
-quiet_cmd_solink = SOLINK($(TOOLSET)) $@
-cmd_solink = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(LD_INPUTS) $(LIBS)
-
-quiet_cmd_solink_module = SOLINK_MODULE($(TOOLSET)) $@
-cmd_solink_module = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(filter-out FORCE_DO_CMD, $^) $(LIBS)
-"""  # noqa: E501
-
-
 LINK_COMMANDS_OS390 = """\
 quiet_cmd_alink = AR($(TOOLSET)) $@
 cmd_alink = rm -f $@ && $(AR.$(TOOLSET)) crs $@ $(filter %.o,$^)
@@ -319,10 +248,10 @@ quiet_cmd_link = LINK($(TOOLSET)) $@
 cmd_link = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(LD_INPUTS) $(LIBS)
 
 quiet_cmd_solink = SOLINK($(TOOLSET)) $@
-cmd_solink = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(LD_INPUTS) $(LIBS)
+cmd_solink = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(LD_INPUTS) $(LIBS) -Wl,DLL
 
 quiet_cmd_solink_module = SOLINK_MODULE($(TOOLSET)) $@
-cmd_solink_module = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(filter-out FORCE_DO_CMD, $^) $(LIBS)
+cmd_solink_module = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(filter-out FORCE_DO_CMD, $^) $(LIBS) -Wl,DLL
 """  # noqa: E501
 
 
@@ -379,7 +308,6 @@ CXXFLAGS.target ?= $(CPPFLAGS) $(CXXFLAGS)
 LINK.target ?= %(LINK.target)s
 LDFLAGS.target ?= $(LDFLAGS)
 AR.target ?= $(AR)
-PLI.target ?= %(PLI.target)s
 
 # C++ apps need to be linked with g++.
 LINK ?= $(CXX.target)
@@ -393,7 +321,6 @@ CXXFLAGS.host ?= $(CPPFLAGS_host) $(CXXFLAGS_host)
 LINK.host ?= %(LINK.host)s
 LDFLAGS.host ?= $(LDFLAGS_host)
 AR.host ?= %(AR.host)s
-PLI.host ?= %(PLI.host)s
 
 # Define a dir function that can handle spaces.
 # http://www.gnu.org/software/make/manual/make.html#Syntax-of-Functions
@@ -473,9 +400,6 @@ quiet_cmd_copy = COPY $@
 # send stderr to /dev/null to ignore messages when linking directories.
 cmd_copy = ln -f "$<" "$@" 2>/dev/null || (rm -rf "$@" && cp %(copy_archive_args)s "$<" "$@")
 
-quiet_cmd_symlink = SYMLINK $@
-cmd_symlink = ln -sf "$<" "$@"
-
 %(link_commands)s
 """  # noqa: E501
     r"""
@@ -631,15 +555,6 @@ def WriteRootHeaderSuffixRules(writer):
     writer.write("\n")
 
 
-SHARED_HEADER_OS390_COMMANDS = """
-PLIFLAGS.target ?= -qlp=64 -qlimits=extname=31  $(PLIFLAGS)
-PLIFLAGS.host ?= -qlp=64 -qlimits=extname=31 $(PLIFLAGS)
-
-quiet_cmd_pli = PLI($(TOOLSET)) $@
-cmd_pli = $(PLI.$(TOOLSET)) $(GYP_PLIFLAGS) $(PLIFLAGS.$(TOOLSET)) -c $< && \
-          if [ -f $(notdir $@) ]; then /bin/cp $(notdir $@) $@; else true; fi
-"""
-
 SHARED_HEADER_SUFFIX_RULES_COMMENT1 = """\
 # Suffix rules, putting all outputs into $(obj).
 """
@@ -1066,20 +981,12 @@ $(obj).$(TOOLSET)/$(TARGET)/%%.o: $(obj)/%%%s FORCE_DO_CMD
             # libraries, but until everything is made cross-compile safe, also use
             # target libraries.
             # TODO(piman): when everything is cross-compile safe, remove lib.target
-            if self.flavor == "zos" or self.flavor == "aix":
-                self.WriteLn(
-                    "cmd_%s = LIBPATH=$(builddir)/lib.host:"
-                    "$(builddir)/lib.target:$$LIBPATH; "
-                    "export LIBPATH; "
-                    "%s%s" % (name, cd_action, command)
-                )
-            else:
-                self.WriteLn(
-                    "cmd_%s = LD_LIBRARY_PATH=$(builddir)/lib.host:"
-                    "$(builddir)/lib.target:$$LD_LIBRARY_PATH; "
-                    "export LD_LIBRARY_PATH; "
-                    "%s%s" % (name, cd_action, command)
-                )
+            self.WriteLn(
+                "cmd_%s = LD_LIBRARY_PATH=$(builddir)/lib.host:"
+                "$(builddir)/lib.target:$$LD_LIBRARY_PATH; "
+                "export LD_LIBRARY_PATH; "
+                "%s%s" % (name, cd_action, command)
+            )
             self.WriteLn()
             outputs = [self.Absolutify(o) for o in outputs]
             # The makefile rules are all relative to the top dir, but the gyp actions
@@ -1573,8 +1480,6 @@ $(obj).$(TOOLSET)/$(TARGET)/%%.o: $(obj)/%%%s FORCE_DO_CMD
             target_prefix = "lib"
             if self.flavor == "aix":
                 target_ext = ".a"
-            elif self.flavor == "zos":
-                target_ext = ".x"
             else:
                 target_ext = ".so"
         elif self.type == "none":
@@ -1655,14 +1560,6 @@ $(obj).$(TOOLSET)/$(TARGET)/%%.o: $(obj)/%%%s FORCE_DO_CMD
             # link_deps.extend(spec.get('libraries', []))
         return (gyp.common.uniquer(deps), gyp.common.uniquer(link_deps))
 
-    def GetSharedObjectFromSidedeck(self, sidedeck):
-        """Return the shared object files based on sidedeck"""
-        return re.sub(r"\.x$", ".so", sidedeck)
-
-    def GetUnversionedSidedeckFromSidedeck(self, sidedeck):
-        """Return the shared object files based on sidedeck"""
-        return re.sub(r"\.\d+\.x$", ".x", sidedeck)
-
     def WriteDependencyOnExtraOutputs(self, target, extra_outputs):
         self.WriteMakeRule(
             [self.output_binary],
@@ -1871,35 +1768,21 @@ $(obj).$(TOOLSET)/$(TARGET)/%%.o: $(obj)/%%%s FORCE_DO_CMD
                 self.flavor not in ("mac", "openbsd", "netbsd", "win")
                 and not self.is_standalone_static_library
             ):
-                if self.flavor in ("linux", "android"):
-                    self.WriteMakeRule(
-                        [self.output_binary],
-                        link_deps,
-                        actions=["$(call create_thin_archive,$@,$^)"],
-                    )
-                else:
-                    self.WriteDoCmd(
-                        [self.output_binary],
-                        link_deps,
-                        "alink_thin",
-                        part_of_all,
-                        postbuilds=postbuilds,
-                    )
+                self.WriteDoCmd(
+                    [self.output_binary],
+                    link_deps,
+                    "alink_thin",
+                    part_of_all,
+                    postbuilds=postbuilds,
+                )
             else:
-                if self.flavor in ("linux", "android"):
-                    self.WriteMakeRule(
-                        [self.output_binary],
-                        link_deps,
-                        actions=["$(call create_archive,$@,$^)"],
-                    )
-                else:
-                    self.WriteDoCmd(
-                        [self.output_binary],
-                        link_deps,
-                        "alink",
-                        part_of_all,
-                        postbuilds=postbuilds,
-                    )
+                self.WriteDoCmd(
+                    [self.output_binary],
+                    link_deps,
+                    "alink",
+                    part_of_all,
+                    postbuilds=postbuilds,
+                )
         elif self.type == "shared_library":
             self.WriteLn(
                 "%s: LD_INPUTS := %s"
@@ -1915,17 +1798,6 @@ $(obj).$(TOOLSET)/$(TARGET)/%%.o: $(obj)/%%%s FORCE_DO_CMD
                 part_of_all,
                 postbuilds=postbuilds,
             )
-            # z/OS has a .so target as well as a sidedeck .x target
-            if self.flavor == "zos":
-                self.WriteLn(
-                    "%s: %s"
-                    % (
-                        QuoteSpaces(
-                            self.GetSharedObjectFromSidedeck(self.output_binary)
-                        ),
-                        QuoteSpaces(self.output_binary),
-                    )
-                )
         elif self.type == "loadable_module":
             for link_dep in link_deps:
                 assert " " not in link_dep, (
@@ -1983,16 +1855,17 @@ $(obj).$(TOOLSET)/$(TARGET)/%%.o: $(obj)/%%%s FORCE_DO_CMD
             else:
                 file_desc = "executable"
             install_path = self._InstallableTargetInstallPath()
-            installable_deps = []
-            if self.flavor != "zos":
-                installable_deps.append(self.output)
+            installable_deps = [self.output]
             if (
                 self.flavor == "mac"
                 and "product_dir" not in spec
                 and self.toolset == "target"
             ):
-                # On macOS, products are created in install_path immediately.
-                assert install_path == self.output, f"{install_path} != {self.output}"
+                # On mac, products are created in install_path immediately.
+                assert install_path == self.output, "{} != {}".format(
+                    install_path,
+                    self.output,
+                )
 
             # Point the target alias to the final binary output.
             self.WriteMakeRule(
@@ -2007,30 +1880,7 @@ $(obj).$(TOOLSET)/$(TARGET)/%%.o: $(obj)/%%%s FORCE_DO_CMD
                     comment="Copy this to the %s output path." % file_desc,
                     part_of_all=part_of_all,
                 )
-                if self.flavor != "zos":
-                    installable_deps.append(install_path)
-            if self.flavor == "zos" and self.type == "shared_library":
-                # lib.target/libnode.so has a dependency on $(obj).target/libnode.so
-                self.WriteDoCmd(
-                    [self.GetSharedObjectFromSidedeck(install_path)],
-                    [self.GetSharedObjectFromSidedeck(self.output)],
-                    "copy",
-                    comment="Copy this to the %s output path." % file_desc,
-                    part_of_all=part_of_all,
-                )
-                # Create a symlink of libnode.x to libnode.version.x
-                self.WriteDoCmd(
-                    [self.GetUnversionedSidedeckFromSidedeck(install_path)],
-                    [install_path],
-                    "symlink",
-                    comment="Symlnk this to the %s output path." % file_desc,
-                    part_of_all=part_of_all,
-                )
-                # Place libnode.version.so and libnode.x symlink in lib.target dir
-                installable_deps.append(self.GetSharedObjectFromSidedeck(install_path))
-                installable_deps.append(
-                    self.GetUnversionedSidedeckFromSidedeck(install_path)
-                )
+                installable_deps.append(install_path)
             if self.output != self.alias and self.alias != self.target:
                 self.WriteMakeRule(
                     [self.alias],
@@ -2038,18 +1888,7 @@ $(obj).$(TOOLSET)/$(TARGET)/%%.o: $(obj)/%%%s FORCE_DO_CMD
                     comment="Short alias for building this %s." % file_desc,
                     phony=True,
                 )
-            if self.flavor == "zos" and self.type == "shared_library":
-                # Make sure that .x symlink target is run
-                self.WriteMakeRule(
-                    ["all"],
-                    [
-                        self.GetUnversionedSidedeckFromSidedeck(install_path),
-                        self.GetSharedObjectFromSidedeck(install_path),
-                    ],
-                    comment='Add %s to "all" target.' % file_desc,
-                    phony=True,
-                )
-            elif part_of_all:
+            if part_of_all:
                 self.WriteMakeRule(
                     ["all"],
                     [install_path],
@@ -2345,9 +2184,6 @@ $(obj).$(TOOLSET)/$(TARGET)/%%.o: $(obj)/%%%s FORCE_DO_CMD
         #    # Install all shared libs into a common directory (per toolset) for
         #    # convenient access with LD_LIBRARY_PATH.
         #    return "$(builddir)/lib.%s/%s" % (self.toolset, self.alias)
-        if self.flavor == "zos" and self.type == "shared_library":
-            return "$(builddir)/lib.%s/%s" % (self.toolset, self.alias)
-
         return "$(builddir)/" + self.alias
 
 
@@ -2459,12 +2295,10 @@ def GenerateOutput(target_list, target_dicts, data, params):
         "AR.target": GetEnvironFallback(("AR_target", "AR"), "$(AR)"),
         "CXX.target": GetEnvironFallback(("CXX_target", "CXX"), "$(CXX)"),
         "LINK.target": GetEnvironFallback(("LINK_target", "LINK"), "$(LINK)"),
-        "PLI.target": GetEnvironFallback(("PLI_target", "PLI"), "pli"),
         "CC.host": GetEnvironFallback(("CC_host", "CC"), "gcc"),
         "AR.host": GetEnvironFallback(("AR_host", "AR"), "ar"),
         "CXX.host": GetEnvironFallback(("CXX_host", "CXX"), "g++"),
         "LINK.host": GetEnvironFallback(("LINK_host", "LINK"), "$(CXX.host)"),
-        "PLI.host": GetEnvironFallback(("PLI_host", "PLI"), "pli"),
     }
     if flavor == "mac":
         flock_command = "./gyp-mac-tool flock"
@@ -2480,36 +2314,16 @@ def GenerateOutput(target_list, target_dicts, data, params):
         header_params.update({"link_commands": LINK_COMMANDS_ANDROID})
     elif flavor == "zos":
         copy_archive_arguments = "-fPR"
-        CC_target = GetEnvironFallback(("CC_target", "CC"), "njsc")
-        makedep_arguments = "-MMD"
-        if CC_target == "clang":
-            CC_host = GetEnvironFallback(("CC_host", "CC"), "clang")
-            CXX_target = GetEnvironFallback(("CXX_target", "CXX"), "clang++")
-            CXX_host = GetEnvironFallback(("CXX_host", "CXX"), "clang++")
-        elif CC_target == "ibm-clang64":
-            CC_host = GetEnvironFallback(("CC_host", "CC"), "ibm-clang64")
-            CXX_target = GetEnvironFallback(("CXX_target", "CXX"), "ibm-clang++64")
-            CXX_host = GetEnvironFallback(("CXX_host", "CXX"), "ibm-clang++64")
-        elif CC_target == "ibm-clang":
-            CC_host = GetEnvironFallback(("CC_host", "CC"), "ibm-clang")
-            CXX_target = GetEnvironFallback(("CXX_target", "CXX"), "ibm-clang++")
-            CXX_host = GetEnvironFallback(("CXX_host", "CXX"), "ibm-clang++")
-        else:
-            # Node.js versions prior to v18:
-            makedep_arguments = "-qmakedep=gcc"
-            CC_host = GetEnvironFallback(("CC_host", "CC"), "njsc")
-            CXX_target = GetEnvironFallback(("CXX_target", "CXX"), "njsc++")
-            CXX_host = GetEnvironFallback(("CXX_host", "CXX"), "njsc++")
+        makedep_arguments = "-qmakedep=gcc"
         header_params.update(
             {
                 "copy_archive_args": copy_archive_arguments,
                 "makedep_args": makedep_arguments,
                 "link_commands": LINK_COMMANDS_OS390,
-                "extra_commands": SHARED_HEADER_OS390_COMMANDS,
-                "CC.target": CC_target,
-                "CXX.target": CXX_target,
-                "CC.host": CC_host,
-                "CXX.host": CXX_host,
+                "CC.target": GetEnvironFallback(("CC_target", "CC"), "njsc"),
+                "CXX.target": GetEnvironFallback(("CXX_target", "CXX"), "njsc++"),
+                "CC.host": GetEnvironFallback(("CC_host", "CC"), "njsc"),
+                "CXX.host": GetEnvironFallback(("CXX_host", "CXX"), "njsc++"),
             }
         )
     elif flavor == "solaris":
@@ -2537,16 +2351,6 @@ def GenerateOutput(target_list, target_dicts, data, params):
                 "flock_index": 2,
             }
         )
-    elif flavor == "os400":
-        copy_archive_arguments = "-pPRf"
-        header_params.update(
-            {
-                "copy_archive_args": copy_archive_arguments,
-                "link_commands": LINK_COMMANDS_OS400,
-                "flock": "./gyp-flock-tool flock",
-                "flock_index": 2,
-            }
-        )
 
     build_file, _, _ = gyp.common.ParseQualifiedTarget(target_list[0])
     make_global_settings_array = data[build_file].get("make_global_settings", [])

data/lib/rapid_stack/generators/generator-rapid/node_modules/node-gyp/gyp/pylib/gyp/generator/msvs.py

@@ -423,15 +423,12 @@ def _BuildCommandLineForRuleRaw(
         command.insert(0, "call")
         # Fix the paths
         # TODO(quote): This is a really ugly heuristic, and will miss path fixing
-        #              for arguments like "--arg=path", arg=path, or "/opt:path".
-        # If the argument starts with a slash or dash, or contains an equal sign,
-        # it's probably a command line switch.
+        #              for arguments like "--arg=path" or "/opt:path".
+        # If the argument starts with a slash or dash, it's probably a command line
+        # switch
         # Return the path with forward slashes because the command using it might
         # not support backslashes.
-        arguments = [
-            i if (i[:1] in "/-" or "=" in i) else _FixPath(i, "/")
-            for i in cmd[1:]
-        ]
+        arguments = [i if (i[:1] in "/-") else _FixPath(i, "/") for i in cmd[1:]]
         arguments = [i.replace("$(InputDir)", "%INPUTDIR%") for i in arguments]
         arguments = [MSVSSettings.FixVCMacroSlashes(i) for i in arguments]
         if quote_cmd:

data/lib/rapid_stack/generators/generator-rapid/node_modules/node-gyp/gyp/pylib/gyp/generator/ninja.py

@@ -1583,7 +1583,7 @@ class NinjaWriter:
         elif spec["type"] == "static_library":
             self.target.binary = self.ComputeOutput(spec)
             if (
-                self.flavor not in ("ios", "mac", "netbsd", "openbsd", "win")
+                self.flavor not in ("mac", "openbsd", "netbsd", "win")
                 and not self.is_standalone_static_library
             ):
                 self.ninja.build(
@@ -2112,8 +2112,8 @@ def GetDefaultConcurrentLinks():
         ctypes.windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(stat))
 
         # VS 2015 uses 20% more working set than VS 2013 and can consume all RAM
-        # on a 64 GiB machine.
-        mem_limit = max(1, stat.ullTotalPhys // (5 * (2 ** 30)))  # total / 5GiB
+        # on a 64 GB machine.
+        mem_limit = max(1, stat.ullTotalPhys // (5 * (2 ** 30)))  # total / 5GB
         hard_cap = max(1, int(os.environ.get("GYP_LINK_CONCURRENCY_MAX", 2 ** 32)))
         return min(mem_limit, hard_cap)
     elif sys.platform.startswith("linux"):
@@ -2496,7 +2496,7 @@ def GenerateOutputForConfig(target_list, target_dicts, data, params, config_name
             ),
         )
 
-    if flavor not in ("ios", "mac", "win"):
+    if flavor != "mac" and flavor != "win":
         master_ninja.rule(
             "alink",
             description="AR $out",

data/lib/rapid_stack/generators/generator-rapid/node_modules/node-gyp/gyp/pylib/gyp/input.py

@@ -961,13 +961,13 @@ def ExpandVariables(input, phase, variables, build_file):
                     # Fix up command with platform specific workarounds.
                     contents = FixupPlatformCommand(contents)
                     try:
-                        # stderr will be printed no matter what
-                        result = subprocess.run(
+                        p = subprocess.Popen(
                             contents,
-                            stdout=subprocess.PIPE,
                             shell=use_shell,
+                            stdout=subprocess.PIPE,
+                            stderr=subprocess.PIPE,
+                            stdin=subprocess.PIPE,
                             cwd=build_file_dir,
-                            check=False
                         )
                     except Exception as e:
                         raise GypError(
@@ -975,12 +975,19 @@ def ExpandVariables(input, phase, variables, build_file):
                             % (e, contents, build_file)
                         )
 
-                    if result.returncode > 0:
+                    p_stdout, p_stderr = p.communicate("")
+                    p_stdout = p_stdout.decode("utf-8")
+                    p_stderr = p_stderr.decode("utf-8")
+
+                    if p.wait() != 0 or p_stderr:
+                        sys.stderr.write(p_stderr)
+                        # Simulate check_call behavior, since check_call only exists
+                        # in python 2.5 and later.
                         raise GypError(
                             "Call to '%s' returned exit status %d while in %s."
-                            % (contents, result.returncode, build_file)
+                            % (contents, p.returncode, build_file)
                         )
-                    replacement = result.stdout.decode("utf-8").rstrip()
+                    replacement = p_stdout.rstrip()
 
                 cached_command_results[cache_key] = replacement
             else:

data/lib/rapid_stack/generators/generator-rapid/node_modules/node-gyp/gyp/pylib/gyp/xcodeproj_file.py

@@ -2770,7 +2770,7 @@ class PBXProject(XCContainerPortal):
         self.path = path
         self._other_pbxprojects = {}
         # super
-        XCContainerPortal.__init__(self, properties, id, parent)
+        return XCContainerPortal.__init__(self, properties, id, parent)
 
     def Name(self):
         name = self.path
@@ -2990,7 +2990,7 @@ class PBXProject(XCContainerPortal):
             # Xcode seems to sort this list case-insensitively
             self._properties["projectReferences"] = sorted(
                 self._properties["projectReferences"],
-                key=lambda x: x["ProjectRef"].Name().lower()
+                key=lambda x: x["ProjectRef"].Name().lower
             )
         else:
             # The link already exists.  Pull out the relevnt data.

data/lib/rapid_stack/generators/generator-rapid/node_modules/node-gyp/gyp/test_gyp.py

@@ -116,7 +116,6 @@ def main(argv=None):
     else:
         format_list = {
             "aix5": ["make"],
-            "os400": ["make"],
             "freebsd7": ["make"],
             "freebsd8": ["make"],
             "openbsd5": ["make"],

data/lib/rapid_stack/generators/generator-rapid/node_modules/node-gyp/gyp/tools/pretty_gyp.py

@@ -90,7 +90,7 @@ def count_braces(line):
   """
     open_braces = ["[", "(", "{"]
     close_braces = ["]", ")", "}"]
-    closing_prefix_re = re.compile(r"[^\s\]\}\)]\s*[\]\}\)]+,?\s*$")
+    closing_prefix_re = re.compile(r"(.*?[^\s\]\}\)]+.*?)([\]\}\)],?)\s*$")
     cnt = 0
     stripline = COMMENT_RE.sub(r"", line)
     stripline = QUOTE_RE.sub(r"''", stripline)

data/lib/rapid_stack/generators/generator-rapid/node_modules/node-gyp/lib/build.js

@@ -11,8 +11,6 @@ function build (gyp, argv, callback) {
   var platformMake = 'make'
   if (process.platform === 'aix') {
     platformMake = 'gmake'
-  } else if (process.platform === 'os400') {
-    platformMake = 'gmake'
   } else if (process.platform.indexOf('bsd') !== -1) {
     platformMake = 'gmake'
   } else if (win && argv.length > 0) {
@@ -187,13 +185,6 @@ function build (gyp, argv, callback) {
       }
     }
 
-    if (!win) {
-      // Add build-time dependency symlinks (such as Python) to PATH
-      const buildBinsDir = path.resolve('build', 'node_gyp_bins')
-      process.env.PATH = `${buildBinsDir}:${process.env.PATH}`
-      log.verbose('bin symlinks', `adding symlinks (such as Python), at "${buildBinsDir}", to PATH`)
-    }
-
     var proc = gyp.spawn(command, argv)
     proc.on('exit', onExit)
   }