TInfoCCProp = enum
  hasSwitchRange, hasComputedGoto, hasCpp, hasAssume, hasGcGuard, hasGnuAsm,
  hasDeclspec, hasAttribute

TInfoCCProps = set[TInfoCCProp]

TInfoCC = tuple[name: string, objExt: string, optSpeed: string, optSize: string,
                compilerExe: string, cppCompiler: string, compileTmpl: string,
                buildGui: string, buildDll: string, buildLib: string,
                linkerExe: string, linkTmpl: string, includeCmd: string,
                linkDirCmd: string, linkLibCmd: string, debug: string,
                pic: string, asmStmtFrmt: string, structStmtFmt: string,
                produceAsm: string, cppXsupport: string, props: TInfoCCProps]

CC: array[succ(low(TSystemCC)) .. high(TSystemCC), TInfoCC] = [("gcc", "o",
    " -O3 -fno-ident", " -Os -fno-ident", "gcc", "g++",
    "-c $options $include -o $objfile $file", " -mwindows", " -shared",
    "ar rcs $libfile $objfiles", "",
    "$buildgui $builddll -o $exefile $objfiles $options", " -I", " -L", " -l$1",
    "", "-fPIC", "asm($1);$n", "$1 $3 $2 ",
    "-Wa,-acdl=$asmfile -g -fverbose-asm -masm=intel",
    "-std=gnu++14 -funsigned-char", {hasSwitchRange, hasComputedGoto, hasCpp,
                                     hasGcGuard, hasGnuAsm, hasAttribute}), (
    "switch_gcc", "o", " -O3 ", " -Os ", "aarch64-none-elf-gcc",
    "aarch64-none-elf-g++",
    "-w -MMD -MP -MF $dfile -c $options $include -o $objfile $file",
    " -mwindows", " -shared", "aarch64-none-elf-gcc-ar rcs $libfile $objfiles",
    "aarch64-none-elf-gcc",
    "$buildgui $builddll -Wl,-Map,$mapfile -o $exefile $objfiles $options",
    " -I", " -L", " -l$1", "", "-fPIE", "asm($1);$n", "$1 $3 $2 ",
    "-Wa,-acdl=$asmfile -g -fverbose-asm -masm=intel",
    "-std=gnu++14 -funsigned-char", {hasSwitchRange, hasComputedGoto, hasCpp,
                                     hasGcGuard, hasGnuAsm, hasAttribute}), (
    "llvm_gcc", "o", " -O3 -fno-ident", " -Os -fno-ident", "llvm-gcc",
    "llvm-g++", "-c $options $include -o $objfile $file", " -mwindows",
    " -shared", "llvm-ar rcs $libfile $objfiles", "",
    "$buildgui $builddll -o $exefile $objfiles $options", " -I", " -L", " -l$1",
    "", "-fPIC", "asm($1);$n", "$1 $3 $2 ",
    "-Wa,-acdl=$asmfile -g -fverbose-asm -masm=intel",
    "-std=gnu++14 -funsigned-char", {hasSwitchRange, hasComputedGoto, hasCpp,
                                     hasGcGuard, hasGnuAsm, hasAttribute}), (
    "clang", "o", " -O3 -fno-ident", " -Os -fno-ident", "clang", "clang++",
    "-c $options $include -o $objfile $file", " -mwindows", " -shared",
    "llvm-ar rcs $libfile $objfiles", "",
    "$buildgui $builddll -o $exefile $objfiles $options", " -I", " -L", " -l$1",
    "", "-fPIC", "asm($1);$n", "$1 $3 $2 ",
    "-Wa,-acdl=$asmfile -g -fverbose-asm -masm=intel",
    "-std=gnu++14 -funsigned-char", {hasSwitchRange, hasComputedGoto, hasCpp,
                                     hasGcGuard, hasGnuAsm, hasAttribute}), (
    "bcc", "obj", " -O3 -6 ", " -O1 -6 ", "bcc32c", "cpp32c",
    "-c $options $include -o$objfile $file", " -tW", " -tWD", "", "bcc32",
    "$options $buildgui $builddll -e$exefile $objfiles", " -I", "", "", "", "",
    "__asm{$n$1$n}$n", "$1 $2", "", "",
    {hasSwitchRange, hasComputedGoto, hasCpp, hasGcGuard, hasAttribute}), (
    "vcc", "obj", " /Ogityb2 ", " /O1 ", "cl", "cl",
    "/c$vccplatform $options $include /nologo /Fo$objfile $file",
    " /SUBSYSTEM:WINDOWS user32.lib ", " /LD", "lib /OUT:$libfile $objfiles",
    "cl",
    "$builddll$vccplatform /Fe$exefile $objfiles $buildgui /nologo $options",
    " /I", " /LIBPATH:", " $1.lib", " /RTC1 /Z7 ", "", "__asm{$n$1$n}$n",
    "$3$n$1 $2", "/Fa$asmfile", "", {hasCpp, hasAssume, hasDeclspec}), ("tcc",
    "o", "", "", "tcc", "", "-c $options $include -o $objfile $file",
    "-Wl,-subsystem=gui", " -shared", "", "tcc",
    "-o $exefile $options $buildgui $builddll $objfiles", " -I", "", "", " -g ",
    "", "asm($1);$n", "$1 $2",
    "-Wa,-acdl=$asmfile -g -fverbose-asm -masm=intel", "",
    {hasSwitchRange, hasComputedGoto, hasGnuAsm}), ("env", "o", " -O3 ",
    " -O1 ", "", "", "-c $ccenvflags $options $include -o $objfile $file", "",
    " -shared ", "", "cc", "-o $exefile $buildgui $builddll $objfiles $options",
    " -I", "", "", "", "", "__asm{$n$1$n}$n", "$1 $2", "", "", {hasGnuAsm}), (
    "icl", "obj", " /Ogityb2 ", " /O1 ", "icl", "cl",
    "/c$vccplatform $options $include /nologo /Fo$objfile $file",
    " /SUBSYSTEM:WINDOWS user32.lib ", " /LD", "lib /OUT:$libfile $objfiles",
    "icl",
    "$builddll$vccplatform /Fe$exefile $objfiles $buildgui /nologo $options",
    " /I", " /LIBPATH:", " $1.lib", " /RTC1 /Z7 ", "", "__asm{$n$1$n}$n",
    "$3$n$1 $2", "/Fa$asmfile", "", {hasCpp, hasAssume, hasDeclspec}), ("icc",
    "o", " -O3 -fno-ident", " -Os -fno-ident", "icc", "g++",
    "-c $options $include -o $objfile $file", " -mwindows", " -shared",
    "ar rcs $libfile $objfiles", "icc",
    "$buildgui $builddll -o $exefile $objfiles $options", " -I", " -L", " -l$1",
    "", "-fPIC", "asm($1);$n", "$1 $3 $2 ",
    "-Wa,-acdl=$asmfile -g -fverbose-asm -masm=intel",
    "-std=gnu++14 -funsigned-char", {hasSwitchRange, hasComputedGoto, hasCpp,
                                     hasGcGuard, hasGnuAsm, hasAttribute}), (
    "clang_cl", "obj", " /Ogityb2 ", " /O1 ", "clang-cl", "clang-cl",
    "/c$vccplatform $options $include /nologo /Fo$objfile $file",
    " /SUBSYSTEM:WINDOWS user32.lib ", " /LD", "lib /OUT:$libfile $objfiles",
    "clang-cl", "-fuse-ld=lld $builddll$vccplatform /Fe$exefile $objfiles $buildgui /nologo $options",
    " /I", " /LIBPATH:", " $1.lib", " /RTC1 /Z7 ", "", "__asm{$n$1$n}$n",
    "$3$n$1 $2", "/Fa$asmfile", "", {hasCpp, hasAssume, hasDeclspec})]

hExt = ".h"

proc nameToCC(name: string): TSystemCC {...}{.raises: [], tags: [].}

proc isVSCompatible(conf: ConfigRef): bool {...}{.raises: [], tags: [].}

proc setCC(conf: ConfigRef; ccname: string; info: TLineInfo) {...}{.
    raises: [Exception, ValueError, IOError, ERecoverableError],
    tags: [RootEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

proc addLinkOption(conf: ConfigRef; option: string) {...}{.raises: [], tags: [].}

proc addCompileOption(conf: ConfigRef; option: string) {...}{.raises: [], tags: [].}

proc addLinkOptionCmd(conf: ConfigRef; option: string) {...}{.raises: [], tags: [].}

proc addCompileOptionCmd(conf: ConfigRef; option: string) {...}{.raises: [], tags: [].}

proc initVars(conf: ConfigRef) {...}{.raises: [], tags: [].}

proc completeCfilePath(conf: ConfigRef; cfile: AbsoluteFile;
                       createSubDir: bool = true): AbsoluteFile {...}{.
    raises: [OSError, IOError], tags: [ReadEnvEffect, ReadIOEffect,
                                       WriteDirEffect, ReadDirEffect,
                                       WriteIOEffect].}

proc toObjFile(conf: ConfigRef; filename: AbsoluteFile): AbsoluteFile {...}{.
    raises: [], tags: [].}

proc addFileToCompile(conf: ConfigRef; cf: Cfile) {...}{.raises: [], tags: [].}

proc addLocalCompileOption(conf: ConfigRef; option: string;
                           nimfile: AbsoluteFile) {...}{.
    raises: [OSError, IOError, KeyError, Exception], tags: [ReadEnvEffect,
    ReadIOEffect, WriteDirEffect, ReadDirEffect, WriteIOEffect, RootEffect].}

proc resetCompilationLists(conf: ConfigRef) {...}{.raises: [], tags: [].}

proc addExternalFileToLink(conf: ConfigRef; filename: AbsoluteFile) {...}{.
    raises: [], tags: [].}

proc execExternalProgram(conf: ConfigRef; cmd: string; msg = hintExecuting) {...}{.
    raises: [Exception, ValueError, IOError, ERecoverableError, OSError], tags: [
    RootEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect, ExecIOEffect].}

proc ccHasSaneOverflow(conf: ConfigRef): bool {...}{.raises: [],
    tags: [ExecIOEffect, ReadIOEffect, RootEffect].}

proc getCompileCFileCmd(conf: ConfigRef; cfile: Cfile; isMainFile = false;
                        produceOutput = false): string {...}{.
    raises: [Exception, ValueError, IOError, ERecoverableError, OSError], tags: [
    ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect, WriteDirEffect,
    ReadDirEffect].}

proc addExternalFileToCompile(conf: ConfigRef; c: var Cfile) {...}{.raises: [OSError,
    KeyError, Exception, IOError, ValueError, ERecoverableError, EOFError], tags: [
    ReadEnvEffect, ReadIOEffect, ReadDirEffect, RootEffect, WriteIOEffect,
    WriteDirEffect].}

proc addExternalFileToCompile(conf: ConfigRef; filename: AbsoluteFile) {...}{.raises: [
    OSError, IOError, KeyError, Exception, ValueError, ERecoverableError,
    EOFError], tags: [ReadEnvEffect, ReadIOEffect, WriteDirEffect,
                      ReadDirEffect, WriteIOEffect, RootEffect].}

proc callCCompiler(conf: ConfigRef) {...}{.raises: [Exception, ValueError, IOError,
    ERecoverableError, OSError], tags: [ReadEnvEffect, RootEffect,
                                        WriteIOEffect, ReadIOEffect,
                                        WriteDirEffect, ReadDirEffect,
                                        ExecIOEffect, TimeEffect].}

proc writeJsonBuildInstructions(conf: ConfigRef) {...}{.
    raises: [OSError, IOError, Exception, ValueError, ERecoverableError], tags: [
    ReadEnvEffect, ReadIOEffect, WriteIOEffect, RootEffect, WriteDirEffect,
    ReadDirEffect, TimeEffect].}

proc changeDetectedViaJsonBuildInstructions(conf: ConfigRef;
    projectfile: AbsoluteFile): bool {...}{.raises: [OSError, Exception], tags: [
    ReadEnvEffect, ReadIOEffect, WriteIOEffect].}

proc runJsonBuildInstructions(conf: ConfigRef; projectfile: AbsoluteFile) {...}{.
    raises: [OSError], tags: [ReadEnvEffect, ReadIOEffect, WriteIOEffect,
                              WriteDirEffect, ReadDirEffect, RootEffect,
                              ExecIOEffect, TimeEffect].}

proc writeMapping(conf: ConfigRef; symbolMapping: Rope) {...}{.
    raises: [ValueError, OSError, IOError, Exception, ERecoverableError],
    tags: [WriteIOEffect, RootEffect, ReadIOEffect, ReadEnvEffect].}