export function parseCompileFlags()

in src/cpptools.ts [148:231]
82 lines of code
40 McCabe index (conditional complexity)

export function parseCompileFlags(cptVersion: cpt.Version, args: string[], lang?: string): CompileFlagInformation {
    const require_standard_target = (cptVersion < cpt.Version.v5);
    const can_use_gnu_std = (cptVersion >= cpt.Version.v4);
    const iter = args[Symbol.iterator]();
    const extraDefinitions: string[] = [];
    let standard: StandardVersion;
    let targetArch: Architecture;
    while (1) {
        const { done, value } = iter.next();
        if (done) {
            break;
        }
        const lower = value.toLowerCase();
        if (require_standard_target && (lower === '-m32' || lower === '-m64')) {
            targetArch = parseTargetArch(lower);
        } else if (require_standard_target && (lower.startsWith('-arch=') || lower.startsWith('/arch:'))) {
            const target = lower.substring(6);
            targetArch = parseTargetArch(target);
        } else if (require_standard_target && lower === '-arch') {
            const { done, value } = iter.next();
            if (done) {
                // TODO: add an allow list of architecture values and add telemetry
                continue;
            }
            targetArch = parseTargetArch(value.toLowerCase());
        } else if (require_standard_target && lower.startsWith('-march=')) {
            const target = lower.substring(7);
            targetArch = parseTargetArch(target);
        } else if (require_standard_target && lower.startsWith('--target=')) {
            const target = lower.substring(9);
            targetArch = parseTargetArch(target);
        } else if (require_standard_target && lower === '-target') {
            const { done, value } = iter.next();
            if (done) {
                // TODO: add an allow list of architecture values and add telemetry
                continue;
            }
            targetArch = parseTargetArch(value.toLowerCase());
        } else if (value === '-D' || value === '/D') {
            const { done, value } = iter.next();
            if (done) {
                rollbar.error(localize('unexpected.end.of.arguments', 'Unexpected end of parsing command line arguments'));
                continue;
            }
            extraDefinitions.push(value);
        } else if (value.startsWith('-D') || value.startsWith('/D')) {
            const def = value.substring(2);
            extraDefinitions.push(def);
        } else if (value.startsWith('-std=') || lower.startsWith('-std:') || lower.startsWith('/std:')) {
            const std = value.substring(5);
            if (lang === 'CXX' || lang === 'OBJCXX' || lang === 'CUDA') {
                const s = parseCppStandard(std, can_use_gnu_std);
                if (!s) {
                    log.warning(localize('unknown.control.gflag.cpp', 'Unknown C++ standard control flag: {0}', value));
                } else {
                    standard = s;
                }
            } else if (lang === 'C' || lang === 'OBJC') {
                const s = parseCStandard(std, can_use_gnu_std);
                if (!s) {
                    log.warning(localize('unknown.control.gflag.c', 'Unknown C standard control flag: {0}', value));
                } else {
                    standard = s;
                }
            } else if (lang === undefined) {
                let s = parseCppStandard(std, can_use_gnu_std);
                if (!s) {
                    s = parseCStandard(std, can_use_gnu_std);
                }
                if (!s) {
                    log.warning(localize('unknown.control.gflag', 'Unknown standard control flag: {0}', value));
                } else {
                    standard = s;
                }
            } else {
                log.warning(localize('unknown language', 'Unknown language: {0}', lang));
            }
        }
    }
    if (!standard && require_standard_target) {
        standard = (lang === 'C') ? 'c11' : 'c++17';
    }
    return { extraDefinitions, standard, targetArch };
}