class_docstr: A modified MingW32 compiler compatible with an MSVC built Python.
  
      
class_docstr_tok: ["A","modified","MingW32","compiler","compatible","with","an","MSVC","built","Python","."]
code: def __init__(self, verbose=0, dry_run=0, force=0):
      distutils.cygwinccompiler.CygwinCCompiler.__init__(
          self, verbose, dry_run, force
      )
  
      # we need to support 3.2 which doesn't match the standard
      # get_versions methods regex
      if self.gcc_version is None:
          p = subprocess.Popen(
              ["gcc", "-dumpversion"],
              shell=True,
              stdout=subprocess.PIPE,
          )
          out_string = p.stdout.read()
          p.stdout.close()
          result = re.search(r"(\d+\.\d+)", out_string)
          if result:
              self.gcc_version = StrictVersion(result.group(1))
  
      # A real mingw32 doesn't need to specify a different entry point,
      # but cygwin 2.91.57 in no-cygwin-mode needs it.
      if self.gcc_version <= "2.91.57":
          entry_point = "--entry _DllMain@12"
      else:
          entry_point = ""
  
      if self.linker_dll == "dllwrap":
          # Commented out '--driver-name g++' part that fixes weird
          #   g++.exe: g++: No such file or directory
          # error (mingw 1.0 in Enthon24 tree, gcc-3.4.5).
          # If the --driver-name part is required for some environment
          # then make the inclusion of this part specific to that
          # environment.
          self.linker = "dllwrap"  #  --driver-name g++'
      elif self.linker_dll == "gcc":
          self.linker = "g++"
  
      # **changes: eric jones 4/11/01
      # 1. Check for import library on Windows.  Build if it doesn't exist.
  
      build_import_library()
  
      # Check for custom msvc runtime library on Windows. Build if it doesn't exist.
      msvcr_success = build_msvcr_library()
      msvcr_dbg_success = build_msvcr_library(debug=True)
      if msvcr_success or msvcr_dbg_success:
          # add preprocessor statement for using customized msvcr lib
          self.define_macro("NPY_MINGW_USE_CUSTOM_MSVCR")
  
      # Define the MSVC version as hint for MinGW
      msvcr_version = msvc_runtime_version()
      if msvcr_version:
          self.define_macro(
              "__MSVCRT_VERSION__", "0x%04i" % msvcr_version
          )
  
      # MS_WIN64 should be defined when building for amd64 on windows,
      # but python headers define it only for MS compilers, which has all
      # kind of bad consequences, like using Py_ModuleInit4 instead of
      # Py_ModuleInit4_64, etc... So we add it here
      if get_build_architecture() == "AMD64":
          if self.gcc_version < "4.0":
              self.set_executables(
                  compiler="gcc -g -DDEBUG -DMS_WIN64 -mno-cygwin -O0 -Wall",
                  compiler_so="gcc -g -DDEBUG -DMS_WIN64 -mno-cygwin -O0"
                  " -Wall -Wstrict-prototypes",
                  linker_exe="gcc -g -mno-cygwin",
                  linker_so="gcc -g -mno-cygwin -shared",
              )
          else:
              # gcc-4 series releases do not support -mno-cygwin option
              self.set_executables(
                  compiler="gcc -g -DDEBUG -DMS_WIN64 -O0 -Wall",
                  compiler_so="gcc -g -DDEBUG -DMS_WIN64 -O0 -Wall -Wstrict-prototypes",
                  linker_exe="gcc -g",
                  linker_so="gcc -g -shared",
              )
      else:
          if self.gcc_version <= "3.0.0":
              self.set_executables(
                  compiler="gcc -mno-cygwin -O2 -w",
                  compiler_so="gcc -mno-cygwin -mdll -O2 -w"
                  " -Wstrict-prototypes",
                  linker_exe="g++ -mno-cygwin",
                  linker_so="%s -mno-cygwin -mdll -static %s"
                  % (self.linker, entry_point),
              )
          elif self.gcc_version < "4.0":
              self.set_executables(
                  compiler="gcc -mno-cygwin -O2 -Wall",
                  compiler_so="gcc -mno-cygwin -O2 -Wall"
                  " -Wstrict-prototypes",
                  linker_exe="g++ -mno-cygwin",
                  linker_so="g++ -mno-cygwin -shared",
              )
          else:
              # gcc-4 series releases do not support -mno-cygwin option
              self.set_executables(
                  compiler="gcc -O2 -Wall",
                  compiler_so="gcc -O2 -Wall -Wstrict-prototypes",
                  linker_exe="g++ ",
                  linker_so="g++ -shared",
              )
      # added for python2.3 support
      # we can't pass it through set_executables because pre 2.2 would fail
      self.compiler_cxx = ["g++"]
  
      # Maybe we should also append -mthreads, but then the finished dlls
      # need another dll (mingwm10.dll see Mingw32 docs) (-mthreads: Support
      # thread-safe exception handling on `Mingw32')
  
      # no additional libraries needed
      # self.dll_libraries=[]
      return
  
imports: from __future__ import division, absolute_import, print_function
  import os
  import sys
  import subprocess
  import re
  import numpy.distutils.ccompiler
  import distutils.cygwinccompiler
  from distutils.version import StrictVersion
  from numpy.distutils.ccompiler import gen_preprocess_options, gen_lib_options
  from distutils.unixccompiler import UnixCCompiler
  from distutils.msvccompiler import get_build_version
  from distutils.errors import DistutilsExecError, CompileError, UnknownFileError
  from numpy.distutils.misc_util import msvc_runtime_library, msvc_runtime_version, msvc_runtime_major, get_build_architecture
label_desc: Use image node_id 1 to create a new Mingw32CCompiler object from inherited base classes: distutils.cygwinccompiler with example: obj = Mingw32CCompiler(verbose, dry_run, force)