psx2usb/pico-sdk/lib/tinyusb/tools/uf2/patcher/patcher.js

"use strict";

const configKeys = {
    PIN_ACCELEROMETER_INT: 1,
    PIN_ACCELEROMETER_SCL: 2,
    PIN_ACCELEROMETER_SDA: 3,
    PIN_BTN_A: 4,
    PIN_BTN_B: 5,
    PIN_BTN_SLIDE: 6,
    PIN_DOTSTAR_CLOCK: 7,
    PIN_DOTSTAR_DATA: 8,
    PIN_FLASH_CS: 9,
    PIN_FLASH_MISO: 10,
    PIN_FLASH_MOSI: 11,
    PIN_FLASH_SCK: 12,
    PIN_LED: 13,
    PIN_LIGHT: 14,
    PIN_MICROPHONE: 15,
    PIN_MIC_CLOCK: 16,
    PIN_MIC_DATA: 17,
    PIN_MISO: 18,
    PIN_MOSI: 19,
    PIN_NEOPIXEL: 20,
    PIN_RX: 21,
    PIN_RXLED: 22,
    PIN_SCK: 23,
    PIN_SCL: 24,
    PIN_SDA: 25,
    PIN_SPEAKER_AMP: 26,
    PIN_TEMPERATURE: 27,
    PIN_TX: 28,
    PIN_TXLED: 29,
    PIN_IR_OUT: 30,
    PIN_IR_IN: 31,
    PIN_DISPLAY_SCK: 32,
    PIN_DISPLAY_MISO: 33,
    PIN_DISPLAY_MOSI: 34,
    PIN_DISPLAY_CS: 35,
    PIN_DISPLAY_DC: 36,
    DISPLAY_WIDTH: 37,
    DISPLAY_HEIGHT: 38,
    DISPLAY_CFG0: 39,
    DISPLAY_CFG1: 40,
    DISPLAY_CFG2: 41,
    DISPLAY_CFG3: 42,
    PIN_DISPLAY_RST: 43,
    PIN_DISPLAY_BL: 44,
    PIN_SERVO_1: 45,
    PIN_SERVO_2: 46,
    PIN_BTN_LEFT: 47,
    PIN_BTN_RIGHT: 48,
    PIN_BTN_UP: 49,
    PIN_BTN_DOWN: 50,
    PIN_BTN_MENU: 51,
    PIN_LED_R: 52,
    PIN_LED_G: 53,
    PIN_LED_B: 54,
    PIN_LED1: 55,
    PIN_LED2: 56,
    PIN_LED3: 57,
    PIN_LED4: 58,
    SPEAKER_VOLUME: 59,
    PIN_JACK_TX: 60,
    PIN_JACK_SENSE: 61,
    PIN_JACK_HPEN: 62,
    PIN_JACK_BZEN: 63,
    PIN_JACK_PWREN: 64,
    PIN_JACK_SND: 65,
    PIN_JACK_BUSLED: 66,
    PIN_JACK_COMMLED: 67,
    PIN_BTN_SOFT_RESET: 69,
    ACCELEROMETER_TYPE: 70,
    PIN_BTNMX_LATCH: 71,
    PIN_BTNMX_CLOCK: 72,
    PIN_BTNMX_DATA: 73,
    PIN_BTN_MENU2: 74,
    PIN_BATTSENSE: 75,
    PIN_VIBRATION: 76,
    PIN_PWREN: 77,

    PIN_A0: 100,
    PIN_A1: 101,
    PIN_A2: 102,
    PIN_A3: 103,
    PIN_A4: 104,
    PIN_A5: 105,
    PIN_A6: 106,
    PIN_A7: 107,
    PIN_A8: 108,
    PIN_A9: 109,
    PIN_A10: 110,
    PIN_A11: 111,
    PIN_A12: 112,
    PIN_A13: 113,
    PIN_A14: 114,
    PIN_A15: 115,
    PIN_A16: 116,
    PIN_A17: 117,
    PIN_A18: 118,
    PIN_A19: 119,
    PIN_A20: 120,
    PIN_A21: 121,
    PIN_A22: 122,
    PIN_A23: 123,
    PIN_A24: 124,
    PIN_A25: 125,
    PIN_A26: 126,
    PIN_A27: 127,
    PIN_A28: 128,
    PIN_A29: 129,
    PIN_A30: 130,
    PIN_A31: 131,
    PIN_D0: 150,
    PIN_D1: 151,
    PIN_D2: 152,
    PIN_D3: 153,
    PIN_D4: 154,
    PIN_D5: 155,
    PIN_D6: 156,
    PIN_D7: 157,
    PIN_D8: 158,
    PIN_D9: 159,
    PIN_D10: 160,
    PIN_D11: 161,
    PIN_D12: 162,
    PIN_D13: 163,
    PIN_D14: 164,
    PIN_D15: 165,
    PIN_D16: 166,
    PIN_D17: 167,
    PIN_D18: 168,
    PIN_D19: 169,
    PIN_D20: 170,
    PIN_D21: 171,
    PIN_D22: 172,
    PIN_D23: 173,
    PIN_D24: 174,
    PIN_D25: 175,
    PIN_D26: 176,
    PIN_D27: 177,
    PIN_D28: 178,
    PIN_D29: 179,
    PIN_D30: 180,
    PIN_D31: 181,
    NUM_NEOPIXELS: 200,
    NUM_DOTSTARS: 201,
    DEFAULT_BUTTON_MODE: 202,
    SWD_ENABLED: 203,
    FLASH_BYTES: 204,
    RAM_BYTES: 205,
    SYSTEM_HEAP_BYTES: 206,
    LOW_MEM_SIMULATION_KB: 207,
    BOOTLOADER_BOARD_ID: 208,
    UF2_FAMILY: 209,
    PINS_PORT_SIZE: 210,
    BOOTLOADER_PROTECTION: 211,
    POWER_DEEPSLEEP_TIMEOUT: 212,
    ANALOG_BUTTON_THRESHOLD: 213,
    PIN_B0: 300,
    PIN_B1: 301,
    PIN_B2: 302,
    PIN_B3: 303,
    PIN_B4: 304,
    PIN_B5: 305,
    PIN_B6: 306,
    PIN_B7: 307,
    PIN_B8: 308,
    PIN_B9: 309,
    PIN_B10: 310,
    PIN_B11: 311,
    PIN_B12: 312,
    PIN_B13: 313,
    PIN_B14: 314,
    PIN_B15: 315,
    PIN_B16: 316,
    PIN_B17: 317,
    PIN_B18: 318,
    PIN_B19: 319,
    PIN_B20: 320,
    PIN_B21: 321,
    PIN_B22: 322,
    PIN_B23: 323,
    PIN_B24: 324,
    PIN_B25: 325,
    PIN_B26: 326,
    PIN_B27: 327,
    PIN_B28: 328,
    PIN_B29: 329,
    PIN_B30: 330,
    PIN_B31: 331,
    PIN_C0: 350,
    PIN_C1: 351,
    PIN_C2: 352,
    PIN_C3: 353,
    PIN_C4: 354,
    PIN_C5: 355,
    PIN_C6: 356,
    PIN_C7: 357,
    PIN_C8: 358,
    PIN_C9: 359,
    PIN_C10: 360,
    PIN_C11: 361,
    PIN_C12: 362,
    PIN_C13: 363,
    PIN_C14: 364,
    PIN_C15: 365,
    PIN_C16: 366,
    PIN_C17: 367,
    PIN_C18: 368,
    PIN_C19: 369,
    PIN_C20: 370,
    PIN_C21: 371,
    PIN_C22: 372,
    PIN_C23: 373,
    PIN_C24: 374,
    PIN_C25: 375,
    PIN_C26: 376,
    PIN_C27: 377,
    PIN_C28: 378,
    PIN_C29: 379,
    PIN_C30: 380,
    PIN_C31: 381,
    PIN_P0: 400,
    PIN_P1: 401,
    PIN_P2: 402,
    PIN_P3: 403,
    PIN_P4: 404,
    PIN_P5: 405,
    PIN_P6: 406,
    PIN_P7: 407,
    PIN_P8: 408,
    PIN_P9: 409,
    PIN_P10: 410,
    PIN_P11: 411,
    PIN_P12: 412,
    PIN_P13: 413,
    PIN_P14: 414,
    PIN_P15: 415,
    PIN_P16: 416,
    PIN_P17: 417,
    PIN_P18: 418,
    PIN_P19: 419,
    PIN_P20: 420,
    PIN_LORA_MISO: 1001,
    PIN_LORA_MOSI: 1002,
    PIN_LORA_SCK: 1003,
    PIN_LORA_CS: 1004,
    PIN_LORA_BOOT: 1005,
    PIN_LORA_RESET: 1006,
    PIN_IRRXLED: 1007,
    PIN_IRTXLED: 1008,
    PIN_LCD_RESET: 1009,
    PIN_LCD_ENABLE: 1010,
    PIN_LCD_DATALINE4: 1011,
    PIN_LCD_DATALINE5: 1012,
    PIN_LCD_DATALINE6: 1013,
    PIN_LCD_DATALINE7: 1014,
    NUM_LCD_COLUMNS: 1015,
    NUM_LCD_ROWS: 1016,
}

const enums = {
    // these are the same as the default I2C ID
    ACCELEROMETER_TYPE: {
        LIS3DH: 0x32,
        MMA8453: 0x38,
        FXOS8700: 0x3C,
        MMA8653: 0x3A,
        MSA300: 0x4C,
        MPU6050: 0x68,
    },
    UF2_FAMILY: {
        ATSAMD21: 0x68ed2b88,
        ATSAMD51: 0x55114460,
        NRF52840: 0x1b57745f,
        STM32F103: 0x5ee21072,
        STM32F401: 0x57755a57,
        ATMEGA32: 0x16573617,
        CYPRESS_FX2: 0x5a18069b,
    },
    PINS_PORT_SIZE: {
        PA_16: 0x10, // PA00-PA15, PB00-PB15, ... - STM32
        PA_32: 0x20, // PA00-PA31, ... - ATSAMD
        P0_16: 0x1010, // P0_0-P0_15, P1_0-P1_15, ...
        P0_32: 0x1020, // P0_0-P0_32, ... - NRF
    },
    DEFAULT_BUTTON_MODE: {
        ACTIVE_HIGH_PULL_DOWN: 0x11,
        ACTIVE_HIGH_PULL_UP: 0x21,
        ACTIVE_HIGH_PULL_NONE: 0x31,
        ACTIVE_LOW_PULL_DOWN: 0x10,
        ACTIVE_LOW_PULL_UP: 0x20,
        ACTIVE_LOW_PULL_NONE: 0x30,
    },
    ".": {
        BTN_FLAG_ACTIVE_HIGH: 0x110000,
        BTN_FLAG_ACTIVE_LOW: 0x200000,
        BTN_OFFSET_ANALOG_PLUS: 1100,
        BTN_OFFSET_ANALOG_MINUS: 1200,
    }
}


let infoMsg = ""

function log(msg) {
    msg = "# " + msg
    infoMsg += msg + "\n"
    console.log(msg)
}

function help() {
    console.log(`
USAGE: node patch-cfg.js file.uf2 [patch.cf2]

Without .cf2 file, it will parse config in the UF2 file and print it out
(in .cf2 format).

With .cf2 file, it will patch in-place the UF2 file with specified config.
`)
    process.exit(1)
}

function readBin(fn) {
    const fs = require("fs")

    if (!fn) {
        console.log("Required argument missing.")
        help()
    }

    try {
        return fs.readFileSync(fn)
    } catch (e) {
        console.log("Cannot read file '" + fn + "': " + e.message)
        help()
    }
}
const configInvKeys = {}

const UF2_MAGIC_START0 = 0x0A324655 // "UF2\n"
const UF2_MAGIC_START1 = 0x9E5D5157 // Randomly selected
const UF2_MAGIC_END = 0x0AB16F30 // Ditto

const CFG_MAGIC0 = 0x1e9e10f1
const CFG_MAGIC1 = 0x20227a79

let all_defines = {}

function configkeysH() {
    let r = "#ifndef __CONFIGKEYS_H\n#define __CONFIGKEYS_H 1\n\n"

    const add = (k, v) => {
        all_defines[k] = v
        if (v > 1000 || !/^CFG_/.test(k))
            v = "0x" + v.toString(16)
        else
            v += ""
        r += "#define " + k + " " + v + "\n"
    }

    add("CFG_MAGIC0", CFG_MAGIC0)
    add("CFG_MAGIC1", CFG_MAGIC1)
    r += "\n"

    for (let k of Object.keys(configKeys)) {
        add("CFG_" + k, configKeys[k])
    }
    for (let k of Object.keys(enums)) {
        r += "\n"
        for (let kk of Object.keys(enums[k])) {
            let n = k == "." ? kk : `${k}_${kk}`
            add(n, enums[k][kk])
        }
    }
    r += "\n#endif // __CONFIGKEYS_H\n"
    return r
}

function err(msg) {
    log("Fatal error: " + msg)
    if (typeof window == "undefined") {
        process.exit(1)
    } else {
        throw new Error(msg)
    }
}

function read32(buf, off) {
    return (buf[off + 0] | (buf[off + 1] << 8) | (buf[off + 2] << 16) | (buf[off + 3] << 24)) >>> 0
}

function write32(buf, off, v) {
    buf[off + 0] = v & 0xff
    buf[off + 1] = (v >> 8) & 0xff
    buf[off + 2] = (v >> 16) & 0xff
    buf[off + 3] = (v >> 24) & 0xff
}

function patchHFile(file, patch) {
    configkeysH()
    let resFile = ""
    let inZone = false
    let flags = {}
    let lineNo = 0
    let nums = []
    for (let line0 of file.split(/\n/)) {
        lineNo++
        let append = line0 + "\n"
        let line = line0.trim().replace(/\/\/.*/, "")
        if (inZone) {
            if (line.indexOf("/* CF2 END */") >= 0) {
                inZone = false
                if (patch) {
                    let portSize = lookupCfg(patch, configKeys.PINS_PORT_SIZE)
                    let s = ""
                    let size = flags["size"] || 100
                    let numentries = patch.length >> 1
                    size = Math.max(size, numentries + 4)
                    s += `    ${CFG_MAGIC0}, ${CFG_MAGIC1}, // magic\n`
                    s += `    ${numentries}, ${size},  // used entries, total entries\n`
                    for (let i = 0; i < numentries; ++i) {
                        let k = patch[i * 2]
                        let v = patch[i * 2 + 1]
                        s += `    ${k}, 0x${v.toString(16)}, // ${showKV(k, v, portSize, patch)}\n`
                    }
                    s += "   "
                    for (let i = 0; i < size - numentries; ++i) {
                        if (i && i % 16 == 0)
                            s += "\n   "
                        s += " 0, 0,"
                    }
                    s += "\n"
                    append = s + line0 + "\n"
                }
            } else {
                append = ""
                let toks = line.split(/,\s*/).map(s => s.trim()).filter(s => !!s)
                for (let tok of toks) {
                    let n = parseInt(tok)
                    if (isNaN(n)) {
                        n = all_defines[tok]
                        if (n === undefined) {
                            let portSize = lookupCfg(nums, configKeys.PINS_PORT_SIZE)
                            if (portSize) portSize &= 0xfff;
                            let pp = parsePinName(tok.replace(/^PIN_/, ""), portSize)
                            if (pp !== undefined) {
                                n = pp
                            } else {
                                err(`unknown value ${tok} at line ${lineNo}`)
                            }
                        }
                    }
                    nums.push(n)
                }
            }
        } else {
            let m = /\/\* CF2 START (.*)/.exec(line)
            if (m) {
                inZone = true
                for (let k of m[1].split(/\s+/)) {
                    let mm = /^(\w+)=(\d+)$/.exec(k)
                    if (mm)
                        flags[mm[1]] = parseInt(mm[2])
                    else
                        flags[k] = true
                }
            }
        }
        resFile += append
    }

    if (nums.length) {
        if (nums[0] != CFG_MAGIC0 || nums[1] != CFG_MAGIC1)
            err("no magic in H file")
        nums = nums.slice(4)
        for (let i = 0; i < nums.length; i += 2) {
            if (nums[i] == 0) {
                if (nums.slice(i).some(x => x != 0))
                    err("config keys follow zero terminator")
                else
                    nums = nums.slice(0, i)
                break
            }
        }
    }

    return {
        patched: resFile,
        data: nums
    }
}

function bufToString(buf) {
    let s = ""
    for (let i = 0; i < buf.length; ++i)
        s += String.fromCharCode(buf[i])
    return s
}

function stringToBuf(str) {
    let buf = new Uint8Array(str.length)
    for (let i = 0; i < buf.length; ++i)
        buf[i] = str.charCodeAt(i)
    return buf
}

function readWriteConfig(buf, patch) {
    let patchPtr = null
    let origData = []
    let cfgLen = 0
    let isUF2 = false
    if (read32(buf, 0) == UF2_MAGIC_START0) {
        isUF2 = true
        log("detected UF2 file")
    } else {
        let stackBase = read32(buf, 0)
        if ((stackBase & 0xff000003) == 0x20000000 &&
            (read32(buf, 4) & 1) == 1) {
            log("detected BIN file")
        } else {
            let str = bufToString(buf)
            if (str.indexOf("/* CF2 START") >= 0) {
                log("detected CF2 header file")
                let rr = patchHFile(str, patch)
                console.log(rr.data)
                return patch ? stringToBuf(rr.patched) : rr.data
            } else {
                err("unknown file format")
            }
        }
    }
    if (patch)
        patch.push(0, 0)
    for (let off = 0; off < buf.length; off += 512) {
        let start = 0
        let payloadLen = 512
        let addr = off

        if (isUF2) {
            start = 32
            if (read32(buf, off) != UF2_MAGIC_START0 ||
                read32(buf, off + 4) != UF2_MAGIC_START1) {
                err("invalid data at " + off)
            }
            payloadLen = read32(buf, off + 16)
            addr = read32(buf, off + 12) - 32
        }

        for (let i = start; i < start + payloadLen; i += 4) {
            if (read32(buf, off + i) == CFG_MAGIC0 &&
                read32(buf, off + i + 4) == CFG_MAGIC1) {
                let addrS = "0x" + (addr + i).toString(16)
                if (patchPtr === null) {
                    log(`Found CFG DATA at ${addrS}`)
                    patchPtr = -4
                } else {
                    log(`Skipping second CFG DATA at ${addrS}`)
                }
            }

            if (patchPtr !== null) {
                if (patchPtr == -2) {
                    cfgLen = read32(buf, off + i)
                    if (patch)
                        write32(buf, off + i, (patch.length >> 1) - 1)
                }

                if (patchPtr >= 0) {
                    if (origData.length < cfgLen * 2 + 40)
                        origData.push(read32(buf, off + i))
                    if (patch) {
                        if (patchPtr < patch.length) {
                            write32(buf, off + i, patch[patchPtr])
                        }
                    }
                }
                patchPtr++
            }
        }
    }

    let len0 = cfgLen * 2
    origData.push(0, 0)
    while (origData[len0])
        len0 += 2
    origData = origData.slice(0, len0 + 2)
    if (len0 != cfgLen * 2)
        log("size information incorrect; continuing anyway")

    if (origData.length == 0)
        err("config data not found")
    if (patch && patchPtr < patch.length)
        err("no space for config data")
    let tail = origData.slice(origData.length - 2)
    if (tail.some(x => x != 0))
        err("config data not zero terminated: " + tail.join(","))
    origData = origData.slice(0, origData.length - 2)
    return patch ? buf : origData
}

function lookupCfg(cfgdata, key) {
    for (let i = 0; i < cfgdata.length; i += 2)
        if (cfgdata[i] == key)
            return cfgdata[i + 1]
    return null
}

function pinToString(pinNo, portSize) {
    if (!portSize || pinNo >= 1000)
        return "P_" + pinNo

    let useLetters = true
    let theSize = portSize & 0xfff
    if (portSize & 0x1000) {
        useLetters = true
    }
    let port = (pinNo / theSize) | 0
    let pin = pinNo % theSize
    if (useLetters) {
        return "P" + String.fromCharCode(65 + port) + ("0" + pin.toString()).slice(-2)
    } else {
        return "P" + port + "_" + pin
    }
}

function isHeaderPin(n) {
    return /^PIN_(MOSI|MISO|SCK|SDA|SCL|RX|TX|[AD]\d+)$/.test(n)
}

function keyWeight(k) {
    if (k == "PINS_PORT_SIZE")
        return 10
    if (isHeaderPin(k))
        return 20
    if (/^PIN_/.test(k))
        return 30
    return 40
}

function expandNum(k) {
    return k.replace(/\d+/g, f => {
        if (f.length > 4)
            return f
        return ("0000" + f).slice(-4)
    })
}

function cmpKeys(a, b) {
    a = a.replace(/ =.*/, "")
    b = b.replace(/ =.*/, "")
    if (a == b)
        return 0
    let d = keyWeight(a) - keyWeight(b)
    if (d) return d
    let aa = expandNum(a)
    let bb = expandNum(b)
    if (aa < bb) return -1
    else if (bb < aa) return 1
    else if (a < b) return -1
    else return 1
}

function showKV(k, v, portSize, data) {
    let vn = ""

    let kn = configInvKeys[k + ""] || ""

    if (enums[kn]) {
        for (let en of Object.keys(enums[kn])) {
            if (enums[kn][en] == v) {
                vn = en
                break
            }
        }
    }

    if (vn == "") {
        if (/_CFG/.test(kn) || v > 10000)
            vn = "0x" + v.toString(16)
        else if (/^PIN_/.test(kn)) {
            if (data && !isHeaderPin(kn)) {
                for (let pn of Object.keys(configKeys)) {
                    if (isHeaderPin(pn) && lookupCfg(data, configKeys[pn]) === v) {
                        vn = pn
                        break
                    }
                }
            }
            if (!vn)
                vn = pinToString(v, portSize)
        } else
            vn = v + ""
    }

    if (kn == "")
        kn = "_" + k

    return `${kn} = ${vn}`
}

function readConfig(buf) {
    init()
    let cfgdata = readWriteConfig(buf, null)
    let portSize = lookupCfg(cfgdata, configKeys.PINS_PORT_SIZE)
    let numentries = cfgdata.length >> 1
    let lines = []
    for (let i = 0; i < numentries; ++i) {
        lines.push(showKV(cfgdata[i * 2], cfgdata[i * 2 + 1], portSize, cfgdata))
    }
    lines.sort(cmpKeys)
    return lines.length ? lines.join("\n") : "Empty config."
}

function parsePinName(v, portSize) {
    let thePort = -1
    let pin = -1

    v = v.trim()

    const env = enums["."][v]
    if (env !== undefined)
        return env

    let m = /(.*)([\|+])(.*)/.exec(v)
    if (m) {
        let v0 = parsePinName(m[1], portSize)
        let v1 = parsePinName(m[3], portSize)
        if (v0 === undefined || v1 === undefined)
            return undefined
        v0 = parseInt(v0)
        v1 = parseInt(v1)
        return "" + (m[2] == "|" ? v0 | v1 : v0 + v1)
    }

    m = /^P([A-Z])_?(\d+)$/.exec(v)
    if (m) {
        pin = parseInt(m[2])
        thePort = m[1].charCodeAt(0) - 65
    }

    m = /^P(\d+)_(\d+)$/.exec(v)
    if (m) {
        pin = parseInt(m[2])
        thePort = parseInt(m[1])
    }

    if (thePort >= 0) {
        if (!portSize) err("PINS_PORT_SIZE not specified, while trying to parse PIN " + v)
        if (pin >= portSize) err("Pin name invalid: " + v)
        return (thePort * portSize + pin) + ""
    }

    m = /^P_?(\d+)$/.exec(v)
    if (m)
        return m[1]

    return undefined
}

function patchConfig(buf, cfg) {
    init()
    const cfgMap = {}
    let lineNo = 0
    for (let line of cfg.split(/\n/)) {
        lineNo++
        line = line.replace(/(#|\/\/).*/, "")
        line = line.trim()
        if (!line)
            continue
        let m = /(\w+)\s*=\s*([^#]+)/.exec(line)
        if (!m)
            err("syntax error at config line " + lineNo)
        let kn = m[1].toUpperCase()
        let k = configKeys[kn]
        if (!k && /^_\d+$/.test(kn))
            k = parseInt(kn.slice(1))
        if (!k)
            err("Unrecognized key name: " + kn)
        cfgMap[k + ""] = m[2]
    }

    let cfgdata = readWriteConfig(buf, null)

    for (let i = 0; i < cfgdata.length; i += 2) {
        let k = cfgdata[i] + ""
        if (!cfgMap.hasOwnProperty(k))
            cfgMap[k] = cfgdata[i + 1] + ""
    }

    const forAll = f => {
        for (let k of Object.keys(cfgMap)) {
            let kn = configInvKeys[k]
            f(kn, k, cfgMap[k])
        }
    }

    // expand enums
    forAll((kn, k, v) => {
        let e = enums[kn]
        if (e && e[v.toUpperCase()])
            cfgMap[k] = e[v] + ""
    })

    let portSize = cfgMap[configKeys.PINS_PORT_SIZE]
    if (portSize) portSize = parseInt(portSize)
    let portSize0 = portSize
    if (portSize)
        portSize &= 0xfff;

    // expand pin names
    forAll((kn, k, v) => {
        let p = parsePinName(v, portSize)
        if (p)
            cfgMap[k] = p
    })

    // expand existing keys
    for (let i = 0; i < 10; ++i)
        forAll((kn, k, v) => {
            if (configKeys[v]) {
                let curr = cfgMap[configKeys[v] + ""]
                if (curr == null)
                    err("Value not specified, but referenced: " + v)
                cfgMap[k] = curr
            }
        })

    let changes = ""
    forAll((kn, k, v) => {
        v = v.toUpperCase()
        if (v == "NULL" || v == "UNDEFINED") {
            let old = lookupCfg(cfgdata, k)
            changes += "remove " + showKV(k, old, portSize0) + "\n"
            delete cfgMap[k]
        }
    })

    forAll((kn, k, v) => {
        if (isNaN(parseInt(v)))
            err("Value not understood: " + v)
    })

    let sorted = Object.keys(cfgMap)
    sorted.sort((a, b) => parseInt(a) - parseInt(b))
    let patch = []
    for (let k of sorted) {
        patch.push(parseInt(k))
        patch.push(parseInt(cfgMap[k]))
    }

    for (let i = 0; i < patch.length; i += 2) {
        let k = patch[i]
        let v = patch[i + 1]
        let old = lookupCfg(cfgdata, k)
        if (old != v) {
            let newOne = showKV(k, v, portSize0)
            if (old !== null) {
                let oldOne = showKV(k, old, portSize0)
                newOne += " (was: " + oldOne.replace(/.* = /, "") + ")"
            }
            changes += newOne + "\n"
        }
    }

    let patched = readWriteConfig(buf, patch)

    return {
        changes,
        patched
    }
}

function parseHFile(hFile) {
    if (!hFile) return
    for (let line of hFile.split(/\n/)) {
        line = line.trim()
        let m = /#define\s+CFG_(\w+)\s+(\d+)/.exec(line)
        if (m) {
            let k = m[1]
            let v = parseInt(m[2])
            configKeys[k] = parseInt(v)
            configInvKeys[v + ""] = k
            console.log(`  ${k}: ${v},`)
        }
    }
}

function init() {
    for (let k of Object.keys(configKeys)) {
        let v = configKeys[k]
        configInvKeys[v + ""] = k
    }
}

function main() {
    let uf2 = readBin(process.argv[2])

    if (process.argv[3]) {
        let cfg = readBin(process.argv[3]).toString("utf8")
        let r = patchConfig(uf2, cfg)
        if (!r.changes)
            console.log("No changes.")
        else
            console.log("\nChanges:\n" + r.changes)
        console.log("# Writing config...")
        fs.writeFileSync(process.argv[2], r.patched)
    } else {
        console.log(readConfig(uf2))
    }
}


if (typeof window == "undefined")
    main()