Something went wrong. Try again.
Completely reimplimented in zig (eventually)
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586//! Engine-backed programming commands: parse modern options here, translate//! to the legacy ipecmd argument vector, and run the bundled JVM engine.const std = @import("std");const cli = @import("cli");const engine = @import("engine.zig");const style = @import("style.zig");
const mem = std.mem;const process = std.process;const Init = process.Init;const File = Io.File;const Io = std.Io;const Allocator = mem.Allocator;const ArrayList = std.ArrayList;
const Region = enum { program, eeprom, id, configuration, boot, auxiliary };
fn regionLetter(r: Region) u8 { return switch (r) { .program => 'P', .eeprom => 'E', .id => 'I', .configuration => 'C', .boot => 'B', .auxiliary => 'A', };}
/// The engine expects prefix-less part numbers and re-adds family prefixes/// itself ("PIC"/"dsPIC"/...); undo whatever prefix the caller included.pub fn stripDevicePrefix(dev: []const u8) []const u8 { const prefixes = [_]struct { name: []const u8, len: usize }{ .{ .name = "dspic3", .len = 5 }, .{ .name = "DSPIC3", .len = 5 }, .{ .name = "rfpic", .len = 5 }, .{ .name = "RFPIC", .len = 5 }, .{ .name = "pic", .len = 3 }, .{ .name = "PIC", .len = 3 }, }; // dsPIC/rfPIC must be tested before PIC; longest first is handled above. for (prefixes) |p| { if (dev.len > p.len and mem.startsWith(u8, dev, p.name)) return dev[p.len..]; } return dev;}
fn normalizeTool(raw: []const u8) []const u8 { const map = [_]struct { alias: []const u8, short: []const u8 }{ .{ .alias = "pk5", .short = "PK5" }, .{ .alias = "pickit5", .short = "PK5" }, .{ .alias = "pk4", .short = "PK4" }, .{ .alias = "pickit4", .short = "PK4" }, .{ .alias = "icd4", .short = "ICD4" }, .{ .alias = "icd5", .short = "ICD5" }, .{ .alias = "ice4", .short = "ICE4" }, .{ .alias = "snap", .short = "SNAP" }, .{ .alias = "pkob", .short = "PKOB" }, .{ .alias = "pkob3", .short = "PKOB" }, .{ .alias = "pkob4", .short = "PKOB4" }, .{ .alias = "pkbasic", .short = "PKBASIC" }, .{ .alias = "pickitbasic", .short = "PKBASIC" }, .{ .alias = "nedbg", .short = "NEDBG" }, .{ .alias = "j32", .short = "J32" }, }; var buf: [32]u8 = undefined; if (raw.len < buf.len) { const lower = std.ascii.lowerString(buf[0..raw.len], raw); for (map) |m| { if (mem.eql(u8, lower, m.alias)) return m.short; } } return raw;}
const Args = struct { arena: Allocator, legacy: ArrayList([]const u8) = .empty,
fn add(self: *Args, comptime fmt: []const u8, args: anytype) !void { const s = try std.fmt.allocPrint(self.arena, fmt, args); try self.legacy.append(self.arena, s); }};
fn die(init: Init, comptime fmt: []const u8, args: anytype) noreturn { var buf: [512]u8 = undefined; var w = File.stderr().writer(init.io, &buf); style.errPrefix(init.io, &w.interface) catch {}; w.interface.print(fmt, args) catch {}; w.interface.flush() catch {}; process.exit(2);}
/// Validate NAME,VERSION[,VENDOR] against installed packs; returns the/// canonical triple for the engine-side override property.fn validateDfp( init: Init, spec: []const u8, user_repo: []const u8, system_repo: []const u8,) ![]const u8 { const allocator = init.arena.allocator(); var it = mem.splitScalar(u8, spec, ','); const name = it.next() orelse ""; const version = it.next() orelse ""; const vendor_in = it.next();
if (name.len == 0 or version.len == 0 or it.next() != null) { die(init, "--dfp expects NAME,VERSION or NAME,VERSION,VENDOR\n", .{}); }
const packs_list = try engine.scanInstalledPacks(init.io, allocator, user_repo, system_repo); for (packs_list.items) |p| { if (!mem.eql(u8, p.name, name)) continue; for (p.releases.items) |rel| { if (!rel.installed) continue; if (!mem.eql(u8, rel.version, version)) continue; if (vendor_in) |v| if (!mem.eql(u8, p.vendor, v)) continue; return std.fmt.allocPrint(allocator, "{s},{s},{s}", .{ p.name, rel.version, p.vendor }); } } die(init, "pack not installed: {s} version {s} (see `mplabx packs list`)\n", .{ name, version });}
pub fn run( init: Init, device: cli.Param( "device", []const u8, .required, "Target device (e.g. pic16f1779, dspic33ep128gp502, atmega328p)", ), tool: cli.Param( "tool", ?[]const u8, .optional(null), "Tool family: pk5, pk4, icd4, icd5, snap, ice4, nedbg, pkob4, pkbasic, ...", ), serial: cli.Param( "serial", ?[]const u8, .optional(null), "Select tool by serial number", ), file: cli.Param( "file", ?[]const u8, .optional(null), "Hex file to program/verify/checksum", ), do_program: cli.Param( "program", bool, .optional(false), "Program device from hex file", ), program_regions: cli.Param( "program-regions", ?[]Region, .optional(null), "Memory regions to program (default: all)", ), do_verify: cli.Param( "verify", bool, .optional(false), "Verify device against hex file (implied by --program)", ), verify_regions: cli.Param( "verify-regions", ?[]Region, .optional(null), "Memory regions to verify (default: all)", ), do_erase: cli.Param( "erase", bool, .optional(false), "Erase device", ), blank_check: cli.Param( "blank-check", bool, .optional(false), "Blank check device", ), read_file: cli.Param( "read", ?[]const u8, .optional(null), "Read device into this hex file", ), read_region: cli.Param( "read-region", ?[]const u8, .optional(null), "Dump memory region to screen (e.g. p:600-6ff, c)", ), connect_only: cli.Param( "connect", bool, .optional(false), "Connect only, no operation", ), show_id: cli.Param( "id", bool, .optional(false), "Display device id", ), checksum: cli.Param( "checksum", bool, .optional(false), "Display hex file checksum", ), crc32: cli.Param( "crc32", bool, .optional(false), "Display hex file CRC32", ), cp_checksum: cli.Param( "cp-checksum", bool, .optional(false), "Display code-protect-off checksum", ), power: cli.Param( "power", bool, .optional(false), "Power target from the tool", ), release: cli.Param( "release", bool, .optional(false), "Release target from reset when done", ), vdd_first: cli.Param( "vdd-first", bool, .optional(false), "Power target via VDD first where supported", ), verify_id: cli.Param( "verify-id", bool, .optional(false), "Verify device id before programming", ), no_erase: cli.Param( "no-erase", bool, .optional(false), "Do not erase all before programming", ), no_verify_flag: cli.Param( "no-verify", bool, .optional(false), "Do not verify after programming", ), preserve: cli.Param( "preserve", ?[]const u8, .optional(null), "Preserve program memory range (e.g. 0-1ff)", ), preserve_eeprom: cli.Param( "preserve-eeprom", bool, .optional(false), "Preserve EEPROM on program", ), preserve_userid: cli.Param( "preserve-userid", bool, .optional(false), "Preserve user id memory on program", ), interface: cli.Param( "interface", ?[]const u8, .optional(null), "AVR/SAM interface: jtag swd updi isp tpi pdi hvpp hvsp", ), speed: cli.Param( "speed", ?[]const u8, .optional(null), "AVR/SAM interface clock speed in MHz", ), jtag_wires: cli.Param( "jtag", ?[]const u8, .optional(null), "JTAG wires: 2 or 4", ), dfp: cli.Param( "dfp", ?[]const u8, .optional(null), "Force device pack NAME,VERSION[,VENDOR]", ),) !void { const allocator = init.arena.allocator();
var do_verify_v = do_verify.value; const has_hex = file.value != null;
// --- validation ------------------------------------------------------- const needs_hex = do_program.value or do_verify_v or checksum.value or cp_checksum.value; if (needs_hex and !has_hex) { die(init, "this operation needs a hex file (--file <path>)\n", .{}); } if (do_program.value and !do_verify_v and !no_verify_flag.value) { // Match IDE/IPE behaviour: programming verifies by default. do_verify_v = true; } if (read_region.value) |spec| validateReadRegion(init, spec); if (interface.value) |iface| { const valid = [_][]const u8{ "JTAG", "SWD", "UPDI", "ISP", "TPI", "PDI", "HVPP", "HVSP" }; var buf: [16]u8 = undefined; if (iface.len == 0 or iface.len > buf.len) die(init, "invalid --interface\n", .{}); const upper = std.ascii.upperString(buf[0..iface.len], iface); var ok = false; for (valid) |v| { if (mem.eql(u8, upper, v)) ok = true; } if (!ok) die(init, "invalid interface '{s}'\n", .{iface}); }
// --- translation ------------------------------------------------------ var args: Args = .{ .arena = allocator };
if (tool.value) |t| try args.add("-TP{s}", .{normalizeTool(t)}); if (serial.value) |s| try args.add("-TS{s}", .{s}); if (file.value) |f| try args.add("-F{s}", .{f}); if (read_file.value) |f| try args.add("-GF{s}", .{f}); if (read_region.value) |spec| { // Validated form: [PEICBAD] followed by optional ":range" for P/E. var buf: [64]u8 = undefined; const legacy = formatReadRegion(spec, &buf); try args.add("-G{s}", .{legacy}); } if (show_id.value) try args.add("-I", .{}); if (checksum.value) try args.add("-K", .{}); if (crc32.value) try args.add("-OZ", .{}); if (cp_checksum.value) try args.add("-OSC", .{}); if (do_erase.value) try args.add("-E", .{}); if (blank_check.value) try args.add("-C", .{}); if (do_program.value) { if (program_regions.value) |regions| { try args.add("-M{s}", .{try regionLetters(allocator, regions)}); } else try args.add("-M", .{}); } if (do_verify_v) { if (verify_regions.value) |regions| { try args.add("-Y{s}", .{try regionLetters(allocator, regions)}); } else try args.add("-Y", .{}); } if (connect_only.value) try args.add("-OK", .{}); if (power.value) try args.add("-W", .{}); if (release.value) try args.add("-OL", .{}); if (vdd_first.value) try args.add("-OD", .{}); if (verify_id.value) try args.add("-OV", .{}); if (no_erase.value) try args.add("-OH", .{}); if (preserve.value) |r| try args.add("-OP{s}", .{r}); if (preserve_eeprom.value) try args.add("-Z", .{}); if (preserve_userid.value) try args.add("-OID", .{}); if (interface.value) |iface| try args.add("-ORI{s}", .{iface}); if (speed.value) |s| try args.add("-ORS{s}", .{s}); if (jtag_wires.value) |w| try args.add("-OJ{s}", .{w});
try args.add("-P{s}", .{stripDevicePrefix(device.value)});
// --- locate engine & runtime ------------------------------------------ const home = resolveEngineHome(init);
var java_path_buf: [512]u8 = undefined; const java = resolveJava(init, &java_path_buf);
var cp: ArrayList(u8) = .empty; try buildClasspath(init, allocator, home, &cp);
var child_argv: ArrayList([]const u8) = .empty; try child_argv.append(allocator, java); try child_argv.append(allocator, "-Djava.awt.headless=true"); if (dfp.value) |spec| { const user_repo = resolveUserRepo(allocator, init.environ_map); const system_repo = init.environ_map.get("packslib.packsfolder") orelse ""; const triple = try validateDfp(init, spec, user_repo, system_repo); const prop = try std.fmt.allocPrint(allocator, "-Dprogcli.dfp={s}", .{triple}); try child_argv.append(allocator, prop); } try child_argv.append(allocator, "-cp"); try child_argv.append(allocator, cp.items); try child_argv.append(allocator, "com.microchip.mplab.ipecmd.IPECMD"); try child_argv.appendSlice(allocator, args.legacy.items);
var child = process.spawn(init.io, .{ .argv = child_argv.items }) catch |err| { die(init, "cannot launch java ({s}): make sure a JRE is available (JAVA_HOME or PATH)\n", .{@errorName(err)}); }; const term = child.wait(init.io) catch |err| { die(init, "waiting for engine failed: {s}\n", .{@errorName(err)}); }; switch (term) { .exited => |code| process.exit(code), .signal => |sig| { var buf: [128]u8 = undefined; var w = File.stderr().writer(init.io, &buf); style.errPrefix(init.io, &w.interface) catch {}; w.interface.print("engine killed by signal {d}\n", .{sig}) catch {}; w.interface.flush() catch {}; process.exit(1); }, else => process.exit(1), }}
fn regionLetters(allocator: Allocator, regions: []const Region) ![]const u8 { var out: ArrayList(u8) = .empty; for (regions) |r| try out.append(allocator, regionLetter(r)); return out.items;}
fn validateReadRegion(init: Init, spec: []const u8) void { if (spec.len == 0) die(init, "invalid read region (use e.g. p:600-6ff or c)\n", .{}); const types = "PEICBAD"; const t = std.ascii.toUpper(spec[0]); if (mem.findScalar(u8, types, t) == null) { die(init, "invalid read region type '{c}' (valid: p e i c b a d)\n", .{spec[0]}); } const wants_range = t == 'P' or t == 'E'; const rest = spec[1..]; const body = if (rest.len > 0 and (rest[0] == ':' or rest[0] == '=')) rest[1..] else rest;
if (wants_range) { // hex-hex with optional whitespace around '-' const trimmed = mem.trim(u8, body, " "); const dash = mem.findScalar(u8, trimmed, '-') orelse die(init, "read region '{c}' requires an address range like 600-6ff\n", .{t}); const lo = mem.trim(u8, trimmed[0..dash], " "); const hi = mem.trim(u8, trimmed[dash + 1 ..], " "); if (lo.len == 0 or hi.len == 0 or !isHex(lo) or !isHex(hi)) { die(init, "bad address range '{s}'\n", .{body}); } } else if (body.len != 0) { die(init, "read region '{c}' does not take a range\n", .{t}); }}
/// Build the -G payload from a validated spec: type letter + optional range.fn formatReadRegion(spec: []const u8, buf: *[64]u8) []const u8 { const t = std.ascii.toUpper(spec[0]); buf[0] = t; var n: usize = 1; const rest = spec[1..]; const body = if (rest.len > 0 and (rest[0] == ':' or rest[0] == '=')) rest[1..] else rest; for (body) |c| { if (c == ' ') continue; buf[n] = c; n += 1; } return buf[0..n];}
fn isHex(s: []const u8) bool { for (s) |c| { switch (c) { '0'...'9', 'a'...'f', 'A'...'F' => {}, else => return false, } } return true;}
test "formatReadRegion builds -G payloads" { var buf: [64]u8 = undefined;
try std.testing.expectEqualStrings("P600-6ff", formatReadRegion("p:600-6ff", &buf)); try std.testing.expectEqualStrings("C", formatReadRegion("c", &buf)); try std.testing.expectEqualStrings("E1ff", formatReadRegion("E=1ff", &buf)); try std.testing.expectEqualStrings("I", formatReadRegion("i", &buf)); // spaces around the dash are tolerated and stripped try std.testing.expectEqualStrings("B600-6FF", formatReadRegion("b 600 - 6FF", &buf));}
test "isHex" { try std.testing.expect(isHex("600")); try std.testing.expect(isHex("0xFF")); try std.testing.expect(isHex("DeAdBeEf")); try std.testing.expect(!isHex("")); try std.testing.expect(!isHex("12g4")); try std.testing.expect(!isHex("-600"));}
test "normalizeTool aliases" { try std.testing.expectEqualStrings("PK5", normalizeTool("pk5")); try std.testing.expectEqualStrings("PK5", normalizeTool("PICkit5")); try std.testing.expectEqualStrings("SNAP", normalizeTool("Snap")); try std.testing.expectEqualStrings("NEDBG", normalizeTool("nedbg")); // unknown families pass through untouched try std.testing.expectEqualStrings("custom", normalizeTool("custom"));}
fn resolveUserRepo(allocator: Allocator, env: *process.Environ.Map) []const u8 { if (env.get("packslib.userpacksfolder")) |p| return p; if (env.get("MPLABX_PACKS_DIR")) |p| return p; const home = env.get("HOME") orelse return ""; return std.fmt.allocPrint(allocator, "{s}/.mchp_packs", .{home}) catch "";}
/// Engine root containing build/engine.jar (+ lib/, or dev layout with/// build/classes and resources). Resolution order: MPLABX_ENGINE_HOME, then/// ./java_src relative to the working directory (dev layout).fn resolveEngineHome(init: Init) []const u8 { if (init.environ_map.get("MPLABX_ENGINE_HOME")) |h| return h;
var path_buf: [std.fs.max_path_bytes]u8 = undefined; const dev_jar = std.fmt.bufPrint(&path_buf, "java_src/build/engine.jar", .{}) catch unreachable; if (std.Io.Dir.cwd().access(init.io, dev_jar, .{})) |_| { return "java_src"; } else |_| {}
die(init, \\cannot locate the programming engine \\ set MPLABX_ENGINE_HOME to the directory containing build/engine.jar and lib/ \\ , .{});}
fn resolveJava(init: Init, buf: *[512]u8) []const u8 { if (init.environ_map.get("MPLABX_JAVA")) |j| return j; if (init.environ_map.get("JAVA_HOME")) |jh| { if (std.fmt.bufPrint(buf, "{s}/bin/java", .{jh})) |p| { if (std.Io.Dir.cwd().access(init.io, p, .{})) |_| { return p; } else |_| {} } else |_| {} } return "java";}
fn buildClasspath(init: Init, allocator: Allocator, home: []const u8, out: *ArrayList(u8)) !void { const io = init.io; const cwd = std.Io.Dir.cwd();
// Prefer the packaged jar; fall back to the dev layout. const jar = try std.fmt.allocPrint(allocator, "{s}/build/engine.jar", .{home}); if (cwd.access(io, jar, .{})) |_| { try out.appendSlice(allocator, jar); } else |_| {}
const classes = try std.fmt.allocPrint(allocator, "{s}/build/classes", .{home}); const resources = try std.fmt.allocPrint(allocator, "{s}/resources", .{home}); const dev_mode = cwd.access(io, classes, .{}) != error.FileNotFound;
if (dev_mode) { if (out.items.len != 0) try out.append(allocator, ':'); try out.appendSlice(allocator, classes); try out.append(allocator, ':'); try out.appendSlice(allocator, resources); }
const lib_root = try std.fmt.allocPrint(allocator, "{s}/lib", .{home}); var dir = cwd.openDir(io, lib_root, .{ .iterate = true }) catch { if (out.items.len == 0) { die(init, "no engine jars found under {s}/lib\n", .{home}); } return; }; defer dir.close(io); var walker = try dir.walk(allocator); defer walker.deinit(); while (try walker.next(io)) |entry| { if (entry.kind != .file) continue; if (!mem.endsWith(u8, entry.basename, ".jar")) continue; if (out.items.len != 0) try out.append(allocator, ':'); try out.print(allocator, "{s}/lib/{s}", .{ home, entry.path }); }}