f1ea6b3965Two generic (manufacturer-agnostic) pcbnew-side subcommands for platform
manufacturing plugins: --ipc356 (IPC-D-356 netlist via IPC356D_WRITER) and
--fab-components (board metrics + per-footprint placement/BOM JSON —
absolute board coords, consumers apply their own conventions). Bumps the
kicad submodule for the diet keep-back of export_d356.cpp.
Also closes a CI cache gap: wasm-cache-hash never hashed wasm/**, so a
pure wasm/cli change would cache-hit stale output — { dir: "wasm" } is
now an input (busts the cache once on landing).
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Mr8PQ34yCfvEtEcwSUvLAV
1266 lines
42 KiB
C++
1266 lines
42 KiB
C++
/*
|
|
* pcb_convert — standalone KiCad board CLI, built as a WebAssembly module.
|
|
* The pcbnew-side sibling of sym_convert (pcbjam-mcp 0001 tier 3a).
|
|
*
|
|
* drc: pcb_convert --drc [--json] [--strict] <file.kicad_pcb> [<out>]
|
|
* Headless DRC. Replicates the scripting LoadBoard() path (the
|
|
* real one is Python-scripting code, stubbed to nullptr in WASM
|
|
* builds): PCB_IO_MGR::Load + DRC_ENGINE::InitEngine(.kicad_dru)
|
|
* + connectivity build, then runs DRC_ENGINE::RunTests the way
|
|
* kicad-cli's JobExportDrc does — no parity (needs the eeschema
|
|
* kiface over kiway), no zone refill (tools/ pruned; existing
|
|
* fills are checked as-is), no footprint-lib preload (the two
|
|
* library-parity tests are force-ignored).
|
|
* Writes a kicad-cli-compatible report (text, or JSON with
|
|
* --json) to <out> (default: <file>-drc.rpt/.json).
|
|
* Exit: 0 clean, 1 violations (--strict: also warnings +
|
|
* unconnected), 2 usage, 4 load/run failure.
|
|
*
|
|
* gerbers: pcb_convert --gerbers <file.kicad_pcb> [<outdir>]
|
|
* One .gbr per enabled layer (stackup plot order) + the .gbrjob
|
|
* file, kicad-cli CLI defaults (no board-plot-params), into
|
|
* <outdir> (default: the input's directory). Zone fills plot as
|
|
* saved (no re-check). Exit: 0 ok, 2 usage, 4 failure.
|
|
*
|
|
* drill: pcb_convert --drill <file.kicad_pcb> [<outdir>]
|
|
* Excellon drill files, kicad-cli defaults (mm, decimal, absolute
|
|
* origin), no map files. Exit: 0 ok, 2 usage, 4 failure.
|
|
*
|
|
* plot: pcb_convert --plot-board [--pdf] [--layers <a,b,...>]
|
|
* <file.kicad_pcb> [<out>]
|
|
* Single SVG (default) or PDF document via PCB_PLOTTER; layers
|
|
* default to the board's enabled set, or a comma-separated list
|
|
* of canonical/user layer names. Exit: 0 ok, 2 usage, 4 failure.
|
|
*
|
|
* ipc356: pcb_convert --ipc356 <file.kicad_pcb> [<out.ipc>]
|
|
* IPC-D-356 netlist via IPC356D_WRITER, default settings (out
|
|
* defaults to <file>-netlist.ipc). Exit: 0 ok, 2 usage, 4 load
|
|
* failure, 5 write failure.
|
|
*
|
|
* fab: pcb_convert --fab-components <file.kicad_pcb> [<out.json>]
|
|
* Manufacturer-agnostic fabrication data JSON (plugins 0002):
|
|
* board metrics (Edge.Cuts bbox mm, aux origin, copper layer
|
|
* count, thickness) + one entry per footprint (ref, fpid, side,
|
|
* absolute position mm in board coords — no Y flip, no
|
|
* aux-origin subtraction; consumers derive their own — rotation
|
|
* deg, smd/exclude/dnp attributes, all non-empty fields).
|
|
* Exit: 0 ok, 2 usage, 4 load failure, 5 write failure.
|
|
*
|
|
* No GUI, no renderer, no embind bindings. Wired into pcbnew/CMakeLists.txt
|
|
* behind the KICAD_PCB_CONVERTER_WASM option (see
|
|
* scripts/kicad/build-pcb_convert.sh).
|
|
*
|
|
* GPL note: this is GPL KiCad code. The artifact is meant to be invoked as a
|
|
* separate process from closed code, never linked into it.
|
|
*/
|
|
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <fstream>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <unistd.h>
|
|
#include <unordered_set>
|
|
|
|
#include <wx/filename.h>
|
|
#include <wx/image.h>
|
|
#include <wx/init.h>
|
|
#include <wx/string.h>
|
|
|
|
#include <base_screen.h>
|
|
#include <base_units.h>
|
|
#include <board.h>
|
|
#include <board_design_settings.h>
|
|
#include <drc/drc_engine.h>
|
|
#include <drc/drc_item.h>
|
|
#include <drc/drc_report.h>
|
|
#include <exporters/export_d356.h>
|
|
#include <exporters/gendrill_excellon_writer.h>
|
|
#include <exporters/gerber_jobfile_writer.h>
|
|
#include <json_common.h>
|
|
#include <jobs/job_export_pcb_drill.h>
|
|
#include <jobs/job_export_pcb_gerbers.h>
|
|
#include <jobs/job_export_pcb_pdf.h>
|
|
#include <jobs/job_export_pcb_svg.h>
|
|
#include <ki_exception.h>
|
|
#include <layer_ids.h>
|
|
#include <lset.h>
|
|
#include <libraries/library_manager.h>
|
|
#include <footprint.h>
|
|
#include <pcb_field.h>
|
|
#include <pcb_io/kicad_sexpr/pcb_io_kicad_sexpr.h>
|
|
#include <pcb_io/pcb_io_mgr.h>
|
|
#include <pcb_marker.h>
|
|
#include <richio.h>
|
|
#include <pcb_plotter.h>
|
|
#include <pcbplot.h>
|
|
#include <pgm_base.h>
|
|
#include <plotters/plotter_gerber.h>
|
|
#include <project.h>
|
|
#include <project/project_file.h>
|
|
#include <properties/property.h>
|
|
#include <properties/property_mgr.h>
|
|
#include <reporter.h>
|
|
#include <settings/settings_manager.h>
|
|
#include <widgets/report_severity.h>
|
|
|
|
// ── minimal KiCad runtime (mirror of sym_convert_main.cpp's LINT_PGM) ─────────
|
|
|
|
namespace
|
|
{
|
|
|
|
/** PCB_CONVERT_TRACE=1: stage prints for diagnosing hangs/traps in the field. */
|
|
void trace( const char* aMsg )
|
|
{
|
|
if( std::getenv( "PCB_CONVERT_TRACE" ) )
|
|
std::fprintf( stderr, "[trace] %s\n", aMsg );
|
|
}
|
|
|
|
|
|
class DRC_PGM : public PGM_BASE
|
|
{
|
|
public:
|
|
void MacOpenFile( const wxString& ) override {}
|
|
|
|
void CreateSettingsManager()
|
|
{
|
|
m_settings_manager = std::make_unique<SETTINGS_MANAGER>();
|
|
}
|
|
|
|
// The full InitPgm() is deliberately not run (kiway/curl plumbing); but
|
|
// the DRC engine parallelizes through GetThreadPool(), which only exists
|
|
// after m_singleton.Init() — without it the pool call wanders on a
|
|
// null-object read (address 0 is readable linear memory under wasm).
|
|
void CreateSingleton()
|
|
{
|
|
m_singleton.Init();
|
|
}
|
|
|
|
// Pgm().GetLibraryManager() returns *m_library_manager unchecked; an empty
|
|
// manager (no tables) is valid and keeps any stray lookup from wandering.
|
|
void CreateLibraryManager()
|
|
{
|
|
m_library_manager = std::make_unique<LIBRARY_MANAGER>();
|
|
}
|
|
};
|
|
|
|
|
|
SETTINGS_MANAGER& kiRuntime()
|
|
{
|
|
static SETTINGS_MANAGER* s_manager = nullptr;
|
|
|
|
if( !s_manager )
|
|
{
|
|
// JSON settings need a writable config dir; keep it away from any real
|
|
// user config (0 = don't overwrite an explicit override).
|
|
setenv( "KICAD_CONFIG_HOME", "/tmp/pcb_convert-config", 0 );
|
|
|
|
// Pin the KiCad thread pool to one worker BEFORE the first
|
|
// ADVANCED_CFG::GetCfg() call latches the value: the link ships only
|
|
// -sPTHREAD_POOL_SIZE=2 preloaded pthread workers, and the default
|
|
// (0 = hardware_concurrency) would spawn a pool the node runtime can
|
|
// only grow after returning to the event loop — which a blocking CLI
|
|
// never does.
|
|
{
|
|
const char* configHome = std::getenv( "KICAD_CONFIG_HOME" );
|
|
wxFileName advCfg( wxString::FromUTF8( configHome ), wxS( "kicad_advanced" ) );
|
|
|
|
if( !advCfg.DirExists() )
|
|
advCfg.Mkdir( wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL );
|
|
|
|
if( !advCfg.FileExists() )
|
|
{
|
|
if( FILE* f = std::fopen( advCfg.GetFullPath().ToUTF8(), "wb" ) )
|
|
{
|
|
std::fputs( "MaximumThreads=1\n", f );
|
|
std::fclose( f );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Deliberately leaked: ~PGM_BASE runs Destroy() (curl/sentry cleanup)
|
|
// from the EXIT_RUNTIME static-dtor pass.
|
|
trace( "kiRuntime: constructing DRC_PGM" );
|
|
DRC_PGM* pgm = new DRC_PGM();
|
|
SetPgm( pgm );
|
|
trace( "kiRuntime: constructing SETTINGS_MANAGER" );
|
|
pgm->CreateSettingsManager();
|
|
trace( "kiRuntime: singleton (thread pool)" );
|
|
pgm->CreateSingleton();
|
|
trace( "kiRuntime: library manager (empty)" );
|
|
pgm->CreateLibraryManager();
|
|
s_manager = &pgm->GetSettingsManager();
|
|
trace( "kiRuntime: ready" );
|
|
}
|
|
|
|
return *s_manager;
|
|
}
|
|
|
|
|
|
// ── headless board load ───────────────────────────────────────────────────────
|
|
// Replica of the scripting LoadBoard() (pcbnew_scripting_helpers.cpp:153),
|
|
// which the WASM build stubs to nullptr (it lives behind KICAD_SCRIPTING and
|
|
// #includes Python.h). Prints diagnostics and returns null on failure.
|
|
|
|
BOARD* loadBoardHeadless( const char* aInPath )
|
|
{
|
|
wxFileName fn( wxString::FromUTF8( aInPath ) );
|
|
fn.MakeAbsolute();
|
|
const wxString absPath = fn.GetFullPath();
|
|
|
|
SETTINGS_MANAGER& manager = kiRuntime();
|
|
|
|
wxFileName pro( fn );
|
|
pro.SetExt( wxS( "kicad_pro" ) );
|
|
|
|
// A board can embed bitmap images in several formats.
|
|
wxInitAllImageHandlers();
|
|
|
|
// aSetActive=false: the set-active tail needs kiway plumbing that doesn't
|
|
// exist headless (mirrors sym_convert's lint loader).
|
|
trace( "loadBoardHeadless: LoadProject" );
|
|
manager.LoadProject( pro.FileExists() ? pro.GetFullPath() : wxString( wxEmptyString ), false );
|
|
PROJECT& project = manager.Prj();
|
|
|
|
BASE_SCREEN::m_DrawingSheetFileName = project.GetProjectFile().m_BoardDrawingSheetFile;
|
|
|
|
trace( "loadBoardHeadless: PCB_IO_MGR::Load" );
|
|
BOARD* brd = nullptr;
|
|
|
|
try
|
|
{
|
|
brd = PCB_IO_MGR::Load( PCB_IO_MGR::KICAD_SEXP, absPath );
|
|
}
|
|
catch( PARSE_ERROR& pe )
|
|
{
|
|
std::fprintf( stderr, "%s:%d:%d: error: %s\n", aInPath, pe.lineNumber, pe.byteIndex,
|
|
(const char*) pe.ParseProblem().ToUTF8() );
|
|
return nullptr;
|
|
}
|
|
catch( const IO_ERROR& ioe )
|
|
{
|
|
std::fprintf( stderr, "%s: error: %s\n", aInPath,
|
|
(const char*) ioe.Problem().ToUTF8() );
|
|
return nullptr;
|
|
}
|
|
|
|
if( !brd )
|
|
{
|
|
std::fprintf( stderr, "%s: error: failed to load board\n", aInPath );
|
|
return nullptr;
|
|
}
|
|
|
|
// Custom DRC rule conditions (A.Layer == 'F.Cu', …) resolve layer names
|
|
// through the property system's PCB_LAYER_ID enum map.
|
|
trace( "loadBoardHeadless: layer enum map" );
|
|
ENUM_MAP<PCB_LAYER_ID>& layerEnum = ENUM_MAP<PCB_LAYER_ID>::Instance();
|
|
|
|
layerEnum.Choices().Clear();
|
|
layerEnum.Undefined( UNDEFINED_LAYER );
|
|
|
|
for( PCB_LAYER_ID layer : LSET::AllLayersMask() )
|
|
{
|
|
layerEnum.Map( layer, LSET::Name( layer ) ); // canonical name
|
|
layerEnum.Map( layer, brd->GetLayerName( layer ) ); // user name
|
|
}
|
|
|
|
brd->SetProject( &project );
|
|
|
|
trace( "loadBoardHeadless: DRC_ENGINE InitEngine" );
|
|
BOARD_DESIGN_SETTINGS& bds = brd->GetDesignSettings();
|
|
bds.m_DRCEngine = std::make_shared<DRC_ENGINE>( brd, &bds );
|
|
|
|
try
|
|
{
|
|
wxFileName rules( pro );
|
|
rules.SetExt( wxS( "kicad_dru" ) );
|
|
bds.m_DRCEngine->InitEngine( rules );
|
|
}
|
|
catch( ... )
|
|
{
|
|
// Best efforts — implicit (board-settings) rules still apply.
|
|
std::fprintf( stderr, "%s: warning: custom DRC rules failed to load\n", aInPath );
|
|
}
|
|
|
|
for( PCB_MARKER* marker : brd->ResolveDRCExclusions( true ) )
|
|
brd->Add( marker );
|
|
|
|
trace( "loadBoardHeadless: BuildConnectivity" );
|
|
brd->BuildConnectivity();
|
|
brd->BuildListOfNets();
|
|
brd->SynchronizeNetsAndNetClasses( true );
|
|
|
|
// Component-class assignment rules from the project; without this,
|
|
// hasComponentClass() conditions in custom rules never match.
|
|
brd->SynchronizeComponentClasses( std::unordered_set<wxString>() );
|
|
|
|
brd->UpdateUserUnits( brd, nullptr );
|
|
|
|
return brd;
|
|
}
|
|
|
|
|
|
// ── headless DRC ──────────────────────────────────────────────────────────────
|
|
// Mirrors PCBNEW_JOBS_HANDLER::JobExportDrc with the headless deltas: no
|
|
// parity (kiway/eeschema kiface), no zone refill (tool framework pruned), no
|
|
// footprint-lib preload (the two library tests are force-ignored), markers
|
|
// added straight to the board instead of through a BOARD_COMMIT.
|
|
|
|
int runDrc( const char* aInPath, bool aJson, bool aStrict, const char* aOutPath )
|
|
{
|
|
wxFileName fn( wxString::FromUTF8( aInPath ) );
|
|
fn.MakeAbsolute();
|
|
|
|
BOARD* brd = loadBoardHeadless( aInPath );
|
|
|
|
if( !brd )
|
|
return 4;
|
|
|
|
BOARD_DESIGN_SETTINGS& bds = brd->GetDesignSettings();
|
|
|
|
// Library-parity tests dereference Pgm().GetLibraryManager() adapters that
|
|
// have no tables headless; parity-with-schematic needs the eeschema kiface.
|
|
bds.m_DRCSeverities[ DRCE_LIB_FOOTPRINT_ISSUES ] = RPT_SEVERITY_IGNORE;
|
|
bds.m_DRCSeverities[ DRCE_LIB_FOOTPRINT_MISMATCH ] = RPT_SEVERITY_IGNORE;
|
|
|
|
std::shared_ptr<DRC_ENGINE> drcEngine = bds.m_DRCEngine;
|
|
|
|
drcEngine->SetViolationHandler(
|
|
[&]( const std::shared_ptr<DRC_ITEM>& aItem, const VECTOR2I& aPos, int aLayer,
|
|
const std::function<void( PCB_MARKER* )>& aPathGenerator )
|
|
{
|
|
PCB_MARKER* marker = new PCB_MARKER( aItem, aPos, aLayer );
|
|
aPathGenerator( marker );
|
|
brd->Add( marker );
|
|
} );
|
|
|
|
trace( "runDrc: RunTests" );
|
|
brd->RecordDRCExclusions();
|
|
brd->DeleteMARKERs( true, true );
|
|
drcEngine->RunTests( EDA_UNITS::MM, false /*aReportAllTrackErrors*/, false /*aTestFootprints*/ );
|
|
drcEngine->ClearViolationHandler();
|
|
|
|
// Update the exclusion status on any excluded markers that still exist.
|
|
brd->ResolveDRCExclusions( false );
|
|
|
|
auto markersProvider = std::make_shared<DRC_ITEMS_PROVIDER>(
|
|
brd, MARKER_BASE::MARKER_DRC, MARKER_BASE::MARKER_DRAWING_SHEET );
|
|
auto ratsnestProvider = std::make_shared<DRC_ITEMS_PROVIDER>( brd, MARKER_BASE::MARKER_RATSNEST );
|
|
auto fpWarningsProvider = std::make_shared<DRC_ITEMS_PROVIDER>( brd, MARKER_BASE::MARKER_PARITY );
|
|
|
|
markersProvider->SetSeverities( RPT_SEVERITY_ERROR | RPT_SEVERITY_WARNING );
|
|
ratsnestProvider->SetSeverities( RPT_SEVERITY_ERROR | RPT_SEVERITY_WARNING );
|
|
fpWarningsProvider->SetSeverities( RPT_SEVERITY_ERROR | RPT_SEVERITY_WARNING );
|
|
|
|
const int errors = markersProvider->GetCount( RPT_SEVERITY_ERROR );
|
|
const int warnings = markersProvider->GetCount( RPT_SEVERITY_WARNING );
|
|
const int unconnected = ratsnestProvider->GetCount();
|
|
|
|
wxString outPath;
|
|
|
|
if( aOutPath )
|
|
{
|
|
outPath = wxString::FromUTF8( aOutPath );
|
|
}
|
|
else
|
|
{
|
|
wxFileName out( fn );
|
|
out.SetName( out.GetName() + wxS( "-drc" ) );
|
|
out.SetExt( aJson ? wxS( "json" ) : wxS( "rpt" ) );
|
|
outPath = out.GetFullPath();
|
|
}
|
|
|
|
trace( "runDrc: writing report" );
|
|
DRC_REPORT reportWriter( brd, EDA_UNITS::MM, markersProvider, ratsnestProvider,
|
|
fpWarningsProvider );
|
|
|
|
const bool wrote = aJson ? reportWriter.WriteJsonReport( outPath )
|
|
: reportWriter.WriteTextReport( outPath );
|
|
|
|
if( !wrote )
|
|
{
|
|
std::fprintf( stderr, "%s: error: unable to save DRC report to %s\n", aInPath,
|
|
(const char*) outPath.ToUTF8() );
|
|
return 4;
|
|
}
|
|
|
|
// Same convention as sym_convert --erc: errors fail; --strict also fails
|
|
// on warnings and unconnected items.
|
|
const bool failed = errors > 0 || ( aStrict && ( warnings > 0 || unconnected > 0 ) );
|
|
|
|
std::fprintf( stderr, "%s: %s (%d errors, %d warnings, %d unconnected) -> %s\n", aInPath,
|
|
failed ? "FAIL" : "OK", errors, warnings, unconnected,
|
|
(const char*) outPath.ToUTF8() );
|
|
|
|
return failed ? 1 : 0;
|
|
}
|
|
|
|
// ── headless gerber export ────────────────────────────────────────────────────
|
|
// Mirrors PCBNEW_JOBS_HANDLER::JobExportGerbers with the headless deltas: no
|
|
// zone re-check (tool framework pruned; fills plot as saved), no progress
|
|
// reporter, kicad-cli CLI defaults via a default-constructed
|
|
// JOB_EXPORT_PCB_GERBERS (board's enabled layers, .gbrjob file on, no protel
|
|
// extensions unless the board plot params say so — we DON'T use board plot
|
|
// params, matching kicad-cli's default).
|
|
|
|
int runGerbers( const char* aInPath, const char* aOutDir )
|
|
{
|
|
wxFileName fn( wxString::FromUTF8( aInPath ) );
|
|
fn.MakeAbsolute();
|
|
|
|
BOARD* brd = loadBoardHeadless( aInPath );
|
|
|
|
if( !brd )
|
|
return 4;
|
|
|
|
wxString outPath = aOutDir ? wxString::FromUTF8( aOutDir ) : fn.GetPath();
|
|
|
|
if( !outPath.EndsWith( wxS( "/" ) ) )
|
|
outPath += wxS( "/" );
|
|
|
|
REPORTER& reporter = CLI_REPORTER::GetInstance();
|
|
|
|
// kicad-cli defaults (m_useBoardPlotParams=false, m_createJobsFile=true);
|
|
// layer selection = the board's enabled layers, stackup plot order.
|
|
JOB_EXPORT_PCB_GERBERS gerberJob;
|
|
PCB_PLOT_PARAMS plotOpts;
|
|
PCB_PLOTTER::PlotJobToPlotOpts( plotOpts, &gerberJob, reporter );
|
|
|
|
GERBER_JOBFILE_WRITER jobfileWriter( brd );
|
|
LSEQ layersToPlot = brd->GetEnabledLayers().SeqStackupForPlotting();
|
|
int plotted = 0;
|
|
bool failed = false;
|
|
|
|
for( PCB_LAYER_ID layer : layersToPlot )
|
|
{
|
|
LSEQ plotSequence;
|
|
plotSequence.push_back( layer );
|
|
|
|
wxFileName gbrFn( brd->GetFileName() );
|
|
wxString layerName = brd->GetLayerName( layer );
|
|
wxString fileExt = plotOpts.GetUseGerberProtelExtensions()
|
|
? GetGerberProtelExtension( layer )
|
|
: wxString( wxS( "gbr" ) );
|
|
|
|
BuildPlotFileName( &gbrFn, outPath, layerName, fileExt );
|
|
wxString gbrName = gbrFn.GetFullName(); // AddGbrFile wants a non-const ref
|
|
jobfileWriter.AddGbrFile( layer, gbrName );
|
|
|
|
trace( "runGerbers: StartPlotBoard" );
|
|
GERBER_PLOTTER* plotter = (GERBER_PLOTTER*) StartPlotBoard(
|
|
brd, &plotOpts, layer, layerName, gbrFn.GetFullPath(), wxEmptyString,
|
|
wxEmptyString );
|
|
|
|
if( plotter )
|
|
{
|
|
PlotBoardLayers( brd, plotter, plotSequence, plotOpts );
|
|
plotter->EndPlot();
|
|
plotted++;
|
|
}
|
|
else
|
|
{
|
|
std::fprintf( stderr, "%s: error: failed to plot %s\n", aInPath,
|
|
(const char*) gbrFn.GetFullPath().ToUTF8() );
|
|
failed = true;
|
|
}
|
|
|
|
delete plotter;
|
|
}
|
|
|
|
wxFileName jobFn( brd->GetFileName() );
|
|
BuildPlotFileName( &jobFn, outPath, wxS( "job" ), wxS( "gbrjob" ) );
|
|
jobfileWriter.CreateJobFile( jobFn.GetFullPath() );
|
|
|
|
std::fprintf( stderr, "%s: %s (%d layers + job file) -> %s\n", aInPath,
|
|
failed ? "FAIL" : "OK", plotted, (const char*) outPath.ToUTF8() );
|
|
|
|
return failed ? 4 : 0;
|
|
}
|
|
|
|
// ── headless board plot (SVG / PDF) ───────────────────────────────────────────
|
|
// Mirrors PCBNEW_JOBS_HANDLER::JobExportSvg/Pdf single-document mode via
|
|
// PCB_PLOTTER (already linked for --gerbers). Default layer set = the board's
|
|
// enabled layers in stackup plot order; --layers takes comma-separated
|
|
// canonical (F.Cu) or user layer names.
|
|
|
|
LSEQ parseLayerList( BOARD* aBrd, const char* aArg, std::string& aError )
|
|
{
|
|
LSEQ seq;
|
|
wxString arg = wxString::FromUTF8( aArg );
|
|
|
|
for( const wxString& token : wxSplit( arg, ',' ) )
|
|
{
|
|
bool found = false;
|
|
|
|
for( PCB_LAYER_ID layer : LSET::AllLayersMask() )
|
|
{
|
|
if( token == LSET::Name( layer ) || token == aBrd->GetLayerName( layer ) )
|
|
{
|
|
seq.push_back( layer );
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( !found )
|
|
{
|
|
aError = "unknown layer '" + std::string( token.ToUTF8() ) + "'";
|
|
return LSEQ();
|
|
}
|
|
}
|
|
|
|
return seq;
|
|
}
|
|
|
|
|
|
int runPlotBoard( const char* aInPath, bool aPdf, const char* aLayersArg, const char* aOutPath )
|
|
{
|
|
wxFileName fn( wxString::FromUTF8( aInPath ) );
|
|
fn.MakeAbsolute();
|
|
|
|
BOARD* brd = loadBoardHeadless( aInPath );
|
|
|
|
if( !brd )
|
|
return 4;
|
|
|
|
LSEQ layers;
|
|
|
|
if( aLayersArg )
|
|
{
|
|
std::string layerError;
|
|
layers = parseLayerList( brd, aLayersArg, layerError );
|
|
|
|
if( layers.empty() )
|
|
{
|
|
std::fprintf( stderr, "%s: error: %s\n", aInPath, layerError.c_str() );
|
|
return 2;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
layers = brd->GetEnabledLayers().SeqStackupForPlotting();
|
|
}
|
|
|
|
wxString outPath;
|
|
|
|
if( aOutPath )
|
|
{
|
|
outPath = wxString::FromUTF8( aOutPath );
|
|
}
|
|
else
|
|
{
|
|
wxFileName out( fn );
|
|
out.SetExt( aPdf ? wxS( "pdf" ) : wxS( "svg" ) );
|
|
outPath = out.GetFullPath();
|
|
}
|
|
|
|
REPORTER& reporter = CLI_REPORTER::GetInstance();
|
|
|
|
// kicad-cli plot defaults (colors, drawing sheet, margins) per format.
|
|
PCB_PLOT_PARAMS plotOpts;
|
|
|
|
if( aPdf )
|
|
{
|
|
JOB_EXPORT_PCB_PDF pdfJob;
|
|
PCB_PLOTTER::PlotJobToPlotOpts( plotOpts, &pdfJob, reporter );
|
|
}
|
|
else
|
|
{
|
|
JOB_EXPORT_PCB_SVG svgJob;
|
|
PCB_PLOTTER::PlotJobToPlotOpts( plotOpts, &svgJob, reporter );
|
|
}
|
|
|
|
trace( "runPlotBoard: PCB_PLOTTER::Plot" );
|
|
PCB_PLOTTER plotter( brd, &reporter, plotOpts );
|
|
|
|
const bool ok = plotter.Plot( outPath, layers, LSEQ(), false /*aUseGerberX2*/,
|
|
true /*single document*/, std::nullopt, std::nullopt,
|
|
std::nullopt );
|
|
|
|
std::fprintf( stderr, "%s: %s (%d layers) -> %s\n", aInPath, ok ? "OK" : "FAIL",
|
|
(int) layers.size(), (const char*) outPath.ToUTF8() );
|
|
|
|
return ok ? 0 : 4;
|
|
}
|
|
|
|
// ── headless drill export (excellon) ──────────────────────────────────────────
|
|
// Mirrors PCBNEW_JOBS_HANDLER::JobExportDrill's excellon branch with the
|
|
// default JOB_EXPORT_PCB_DRILL options (kicad-cli defaults); no map files
|
|
// (the writer would drive a plotter for those — add on demand).
|
|
|
|
int runDrill( const char* aInPath, const char* aOutDir )
|
|
{
|
|
wxFileName fn( wxString::FromUTF8( aInPath ) );
|
|
fn.MakeAbsolute();
|
|
|
|
BOARD* brd = loadBoardHeadless( aInPath );
|
|
|
|
if( !brd )
|
|
return 4;
|
|
|
|
wxString outPath = aOutDir ? wxString::FromUTF8( aOutDir ) : fn.GetPath();
|
|
|
|
if( !outPath.EndsWith( wxS( "/" ) ) )
|
|
outPath += wxS( "/" );
|
|
|
|
JOB_EXPORT_PCB_DRILL drillJob; // kicad-cli defaults
|
|
|
|
VECTOR2I offset;
|
|
|
|
if( drillJob.m_drillOrigin == JOB_EXPORT_PCB_DRILL::DRILL_ORIGIN::ABS )
|
|
offset = VECTOR2I( 0, 0 );
|
|
else
|
|
offset = brd->GetDesignSettings().GetAuxOrigin();
|
|
|
|
EXCELLON_WRITER::ZEROS_FMT zeroFmt;
|
|
|
|
switch( drillJob.m_zeroFormat )
|
|
{
|
|
case JOB_EXPORT_PCB_DRILL::ZEROS_FORMAT::KEEP_ZEROS:
|
|
zeroFmt = EXCELLON_WRITER::KEEP_ZEROS;
|
|
break;
|
|
case JOB_EXPORT_PCB_DRILL::ZEROS_FORMAT::SUPPRESS_LEADING:
|
|
zeroFmt = EXCELLON_WRITER::SUPPRESS_LEADING;
|
|
break;
|
|
case JOB_EXPORT_PCB_DRILL::ZEROS_FORMAT::SUPPRESS_TRAILING:
|
|
zeroFmt = EXCELLON_WRITER::SUPPRESS_TRAILING;
|
|
break;
|
|
case JOB_EXPORT_PCB_DRILL::ZEROS_FORMAT::DECIMAL:
|
|
default:
|
|
zeroFmt = EXCELLON_WRITER::DECIMAL_FORMAT;
|
|
break;
|
|
}
|
|
|
|
// The upstream precision tables are statics in UI/handler TUs; the values
|
|
// are fixed (metric 3.3, inch 2.4).
|
|
const bool metric = drillJob.m_drillUnits == JOB_EXPORT_PCB_DRILL::DRILL_UNITS::MM;
|
|
DRILL_PRECISION precision = metric ? DRILL_PRECISION( 3, 3 ) : DRILL_PRECISION( 2, 4 );
|
|
|
|
trace( "runDrill: CreateDrillandMapFilesSet" );
|
|
EXCELLON_WRITER writer( brd );
|
|
writer.SetFormat( metric, zeroFmt, precision.m_Lhs, precision.m_Rhs );
|
|
writer.SetOptions( drillJob.m_excellonMirrorY, drillJob.m_excellonMinimalHeader, offset,
|
|
drillJob.m_excellonCombinePTHNPTH );
|
|
writer.SetRouteModeForOvalHoles( drillJob.m_excellonOvalDrillRoute );
|
|
writer.SetMapFileFormat( PLOT_FORMAT::PDF ); // unused: maps off
|
|
|
|
REPORTER& reporter = CLI_REPORTER::GetInstance();
|
|
const bool ok = writer.CreateDrillandMapFilesSet( outPath, true /*drill*/, false /*map*/,
|
|
&reporter );
|
|
|
|
std::fprintf( stderr, "%s: %s (excellon) -> %s\n", aInPath, ok ? "OK" : "FAIL",
|
|
(const char*) outPath.ToUTF8() );
|
|
|
|
return ok ? 0 : 4;
|
|
}
|
|
|
|
// ── IPC-D-356 netlist export ──────────────────────────────────────────────────
|
|
// Same IPC356D_WRITER call the pcbnew GUI export makes, default settings; net
|
|
// assignments come from the saved board (no connectivity rebuild needed).
|
|
|
|
int runIpc356( const char* aInPath, const char* aOutPath )
|
|
{
|
|
wxFileName fn( wxString::FromUTF8( aInPath ) );
|
|
fn.MakeAbsolute();
|
|
|
|
BOARD* brd = loadBoardHeadless( aInPath );
|
|
|
|
if( !brd )
|
|
return 4;
|
|
|
|
wxString outPath;
|
|
|
|
if( aOutPath )
|
|
{
|
|
outPath = wxString::FromUTF8( aOutPath );
|
|
}
|
|
else
|
|
{
|
|
wxFileName out( fn );
|
|
out.SetName( out.GetName() + wxS( "-netlist" ) );
|
|
out.SetExt( wxS( "ipc" ) );
|
|
outPath = out.GetFullPath();
|
|
}
|
|
|
|
trace( "runIpc356: IPC356D_WRITER::Write" );
|
|
IPC356D_WRITER writer( brd );
|
|
const bool ok = writer.Write( outPath );
|
|
|
|
std::fprintf( stderr, "%s: %s (ipc-356d) -> %s\n", aInPath, ok ? "OK" : "FAIL",
|
|
(const char*) outPath.ToUTF8() );
|
|
|
|
return ok ? 0 : 5;
|
|
}
|
|
|
|
// ── fabrication components JSON ───────────────────────────────────────────────
|
|
// Manufacturer-agnostic per-footprint placement/BOM data + board metrics
|
|
// (plugins 0002). Coordinates are absolute board coords in mm, as-is: no Y
|
|
// flip, no aux-origin subtraction — manufacturer-specific conventions (e.g.
|
|
// PCBWay's aux-relative negated-Y positions) are applied by the consumer.
|
|
|
|
int runFabComponents( const char* aInPath, const char* aOutPath )
|
|
{
|
|
wxFileName fn( wxString::FromUTF8( aInPath ) );
|
|
fn.MakeAbsolute();
|
|
|
|
BOARD* brd = loadBoardHeadless( aInPath );
|
|
|
|
if( !brd )
|
|
return 4;
|
|
|
|
wxString outPath;
|
|
|
|
if( aOutPath )
|
|
{
|
|
outPath = wxString::FromUTF8( aOutPath );
|
|
}
|
|
else
|
|
{
|
|
wxFileName out( fn );
|
|
out.SetName( out.GetName() + wxS( "-fab-components" ) );
|
|
out.SetExt( wxS( "json" ) );
|
|
outPath = out.GetFullPath();
|
|
}
|
|
|
|
trace( "runFabComponents: collecting" );
|
|
|
|
const BOX2I bbox = brd->GetBoardEdgesBoundingBox();
|
|
const VECTOR2I aux = brd->GetDesignSettings().GetAuxOrigin();
|
|
|
|
nlohmann::json board;
|
|
board["widthMm"] = pcbIUScale.IUTomm( bbox.GetWidth() );
|
|
board["heightMm"] = pcbIUScale.IUTomm( bbox.GetHeight() );
|
|
board["bboxOriginMm"] = { { "x", pcbIUScale.IUTomm( bbox.GetX() ) },
|
|
{ "y", pcbIUScale.IUTomm( bbox.GetY() ) } };
|
|
board["auxOriginMm"] = { { "x", pcbIUScale.IUTomm( aux.x ) },
|
|
{ "y", pcbIUScale.IUTomm( aux.y ) } };
|
|
board["copperLayers"] = brd->GetCopperLayerCount();
|
|
board["thicknessMm"] = pcbIUScale.IUTomm( brd->GetDesignSettings().GetBoardThickness() );
|
|
|
|
nlohmann::json footprints = nlohmann::json::array();
|
|
|
|
for( FOOTPRINT* fp : brd->Footprints() )
|
|
{
|
|
const VECTOR2I pos = fp->GetPosition();
|
|
const int attrs = fp->GetAttributes();
|
|
|
|
nlohmann::json f;
|
|
f["ref"] = std::string( fp->GetReference().ToUTF8() );
|
|
f["fpid"] = std::string( fp->GetFPID().GetUniStringLibId().ToUTF8() );
|
|
f["side"] = fp->GetLayer() == B_Cu ? "bottom" : "top";
|
|
f["posMm"] = { { "x", pcbIUScale.IUTomm( pos.x ) },
|
|
{ "y", pcbIUScale.IUTomm( pos.y ) } };
|
|
f["rotationDeg"] = fp->GetOrientationDegrees();
|
|
f["smd"] = bool( attrs & FP_SMD );
|
|
f["excludeFromPos"] = fp->IsExcludedFromPosFiles();
|
|
f["excludeFromBom"] = fp->IsExcludedFromBOM();
|
|
f["dnp"] = fp->IsDNP();
|
|
|
|
nlohmann::json fields = nlohmann::json::object();
|
|
|
|
std::vector<PCB_FIELD*> fieldList;
|
|
fp->GetFields( fieldList, false );
|
|
|
|
for( PCB_FIELD* field : fieldList )
|
|
{
|
|
const wxString text = field->GetShownText( false );
|
|
|
|
if( !text.IsEmpty() )
|
|
fields[std::string( field->GetName().ToUTF8() )] = std::string( text.ToUTF8() );
|
|
}
|
|
|
|
f["fields"] = fields;
|
|
footprints.push_back( f );
|
|
}
|
|
|
|
nlohmann::json j;
|
|
j["board"] = board;
|
|
j["footprints"] = footprints;
|
|
|
|
trace( "runFabComponents: writing" );
|
|
std::ofstream out( outPath.fn_str() );
|
|
out << j.dump( 2 ) << "\n";
|
|
out.close();
|
|
|
|
if( !out )
|
|
{
|
|
std::fprintf( stderr, "%s: error: unable to write %s\n", aInPath,
|
|
(const char*) outPath.ToUTF8() );
|
|
return 5;
|
|
}
|
|
|
|
std::fprintf( stderr, "%s: OK (%d footprints) -> %s\n", aInPath,
|
|
(int) brd->Footprints().size(), (const char*) outPath.ToUTF8() );
|
|
|
|
return 0;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
|
|
#ifdef KICAD_TOOLS_COMBINED
|
|
// Full-parse board lint for the merged image's --lint driver (which lives on
|
|
// the eeschema side, sym_convert_main.cpp): a bare PCB_IO_MGR::Load parse —
|
|
// no project, no DRC engine, no connectivity. Returns the footprint count, or
|
|
// -1 with aError filled ("path:line:col: error: ..." on parse errors).
|
|
int pcbToolsLintBoard( const char* aInPath, std::string& aError )
|
|
{
|
|
wxFileName fn( wxString::FromUTF8( aInPath ) );
|
|
fn.MakeAbsolute();
|
|
|
|
kiRuntime();
|
|
|
|
try
|
|
{
|
|
std::unique_ptr<BOARD> brd( PCB_IO_MGR::Load( PCB_IO_MGR::KICAD_SEXP, fn.GetFullPath() ) );
|
|
|
|
if( !brd )
|
|
{
|
|
aError = std::string( aInPath ) + ": error: failed to load board";
|
|
return -1;
|
|
}
|
|
|
|
return (int) brd->Footprints().size();
|
|
}
|
|
catch( PARSE_ERROR& pe )
|
|
{
|
|
char buf[1024];
|
|
std::snprintf( buf, sizeof( buf ), "%s:%d:%d: error: %s", aInPath, pe.lineNumber,
|
|
pe.byteIndex, (const char*) pe.ParseProblem().ToUTF8() );
|
|
aError = buf;
|
|
return -1;
|
|
}
|
|
catch( const IO_ERROR& ioe )
|
|
{
|
|
aError = std::string( aInPath ) + ": error: " + std::string( ioe.Problem().ToUTF8() );
|
|
return -1;
|
|
}
|
|
catch( const std::exception& e )
|
|
{
|
|
aError = std::string( aInPath ) + ": error: " + e.what();
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
|
|
// Full-parse footprint lint for the merged image's --lint driver
|
|
// (kicad-validity 0001 S): parse one .kicad_mod via the s-expr plugin's
|
|
// ImportFootprint. Returns the pad count, or -1 with aError filled.
|
|
int pcbToolsLintFootprint( const char* aInPath, std::string& aError )
|
|
{
|
|
wxFileName fn( wxString::FromUTF8( aInPath ) );
|
|
fn.MakeAbsolute();
|
|
|
|
kiRuntime();
|
|
|
|
try
|
|
{
|
|
PCB_IO_KICAD_SEXPR plugin;
|
|
wxString name;
|
|
std::unique_ptr<FOOTPRINT> fp( plugin.ImportFootprint( fn.GetFullPath(), name ) );
|
|
|
|
if( !fp )
|
|
{
|
|
aError = std::string( aInPath ) + ": error: not a footprint file";
|
|
return -1;
|
|
}
|
|
|
|
return (int) fp->Pads().size();
|
|
}
|
|
catch( PARSE_ERROR& pe )
|
|
{
|
|
char buf[1024];
|
|
std::snprintf( buf, sizeof( buf ), "%s:%d:%d: error: %s", aInPath, pe.lineNumber,
|
|
pe.byteIndex, (const char*) pe.ParseProblem().ToUTF8() );
|
|
aError = buf;
|
|
return -1;
|
|
}
|
|
catch( const IO_ERROR& ioe )
|
|
{
|
|
aError = std::string( aInPath ) + ": error: " + std::string( ioe.Problem().ToUTF8() );
|
|
return -1;
|
|
}
|
|
catch( const std::exception& e )
|
|
{
|
|
aError = std::string( aInPath ) + ": error: " + e.what();
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
|
|
// Footprint resave for --resave (kicad-validity 0001 S): parse + rewrite one
|
|
// .kicad_mod in the current format, the exact FP_CACHE::Save incantation
|
|
// (PRETTIFIED formatter + plugin Format). 0 / 4 load failed / 5 write failed.
|
|
int pcbToolsResaveFootprint( const char* aInPath, const char* aOutPath, std::string& aError )
|
|
{
|
|
wxFileName fn( wxString::FromUTF8( aInPath ) );
|
|
fn.MakeAbsolute();
|
|
|
|
kiRuntime();
|
|
|
|
std::unique_ptr<FOOTPRINT> fp;
|
|
|
|
try
|
|
{
|
|
PCB_IO_KICAD_SEXPR plugin;
|
|
wxString name;
|
|
fp.reset( plugin.ImportFootprint( fn.GetFullPath(), name ) );
|
|
|
|
if( !fp )
|
|
{
|
|
aError = std::string( aInPath ) + ": error: not a footprint file";
|
|
return 4;
|
|
}
|
|
}
|
|
catch( PARSE_ERROR& pe )
|
|
{
|
|
char buf[1024];
|
|
std::snprintf( buf, sizeof( buf ), "%s:%d:%d: error: %s", aInPath, pe.lineNumber,
|
|
pe.byteIndex, (const char*) pe.ParseProblem().ToUTF8() );
|
|
aError = buf;
|
|
return 4;
|
|
}
|
|
catch( const IO_ERROR& ioe )
|
|
{
|
|
aError = std::string( aInPath ) + ": error: " + std::string( ioe.Problem().ToUTF8() );
|
|
return 4;
|
|
}
|
|
catch( const std::exception& e )
|
|
{
|
|
aError = std::string( aInPath ) + ": error: " + e.what();
|
|
return 4;
|
|
}
|
|
|
|
try
|
|
{
|
|
// CTL_FOR_LIBRARY, NOT the default CTL_FOR_BOARD — the board flags
|
|
// include CTL_OMIT_FOOTPRINT_VERSION, which would strip the (version)
|
|
// header a standalone .kicad_mod must carry (FootprintSave sets the
|
|
// same flags before formatting).
|
|
PCB_IO_KICAD_SEXPR writer( CTL_FOR_LIBRARY );
|
|
PRETTIFIED_FILE_OUTPUTFORMATTER formatter( wxString::FromUTF8( aOutPath ) );
|
|
writer.SetOutputFormatter( &formatter );
|
|
writer.Format( fp.get() );
|
|
}
|
|
catch( const IO_ERROR& ioe )
|
|
{
|
|
aError = std::string( aOutPath ) + ": error: " + std::string( ioe.Problem().ToUTF8() );
|
|
return 5;
|
|
}
|
|
catch( const std::exception& e )
|
|
{
|
|
aError = std::string( aOutPath ) + ": error: " + e.what();
|
|
return 5;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
// Full-parse board resave for the merged image's --resave driver (also on the
|
|
// eeschema side): a bare load like pcbToolsLintBoard, then the s-expr writer
|
|
// rewrites the board in the current format version. Zones are written
|
|
// as-saved (no refill) — a format upgrade must not change geometry. Returns
|
|
// 0 resaved / 4 load or parse failed / 5 write failed, with aError filled.
|
|
int pcbToolsResaveBoard( const char* aInPath, const char* aOutPath, std::string& aError )
|
|
{
|
|
wxFileName fn( wxString::FromUTF8( aInPath ) );
|
|
fn.MakeAbsolute();
|
|
|
|
kiRuntime();
|
|
|
|
std::unique_ptr<BOARD> brd;
|
|
|
|
try
|
|
{
|
|
brd.reset( PCB_IO_MGR::Load( PCB_IO_MGR::KICAD_SEXP, fn.GetFullPath() ) );
|
|
|
|
if( !brd )
|
|
{
|
|
aError = std::string( aInPath ) + ": error: failed to load board";
|
|
return 4;
|
|
}
|
|
}
|
|
catch( PARSE_ERROR& pe )
|
|
{
|
|
char buf[1024];
|
|
std::snprintf( buf, sizeof( buf ), "%s:%d:%d: error: %s", aInPath, pe.lineNumber,
|
|
pe.byteIndex, (const char*) pe.ParseProblem().ToUTF8() );
|
|
aError = buf;
|
|
return 4;
|
|
}
|
|
catch( const IO_ERROR& ioe )
|
|
{
|
|
aError = std::string( aInPath ) + ": error: " + std::string( ioe.Problem().ToUTF8() );
|
|
return 4;
|
|
}
|
|
catch( const std::exception& e )
|
|
{
|
|
aError = std::string( aInPath ) + ": error: " + e.what();
|
|
return 4;
|
|
}
|
|
|
|
try
|
|
{
|
|
PCB_IO_MGR::Save( PCB_IO_MGR::KICAD_SEXP, wxString::FromUTF8( aOutPath ), brd.get() );
|
|
}
|
|
catch( const IO_ERROR& ioe )
|
|
{
|
|
aError = std::string( aOutPath ) + ": error: " + std::string( ioe.Problem().ToUTF8() );
|
|
return 5;
|
|
}
|
|
catch( const std::exception& e )
|
|
{
|
|
aError = std::string( aOutPath ) + ": error: " + e.what();
|
|
return 5;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#endif // KICAD_TOOLS_COMBINED
|
|
|
|
|
|
// Under KICAD_TOOLS_COMBINED (the merged kicad_tools image) this TU compiles
|
|
// as a library: the entry point keeps its name and kicad_tools_main.cpp
|
|
// dispatches to it; the standalone pcb_convert build wraps it in main() below.
|
|
int pcbConvertMain( int argc, char** argv )
|
|
{
|
|
// Non-tty stderr is fully buffered under emscripten/musl; a CLI's stderr
|
|
// must be unbuffered — losing the error report is worse than the syscall
|
|
// cost.
|
|
setvbuf( stderr, nullptr, _IONBF, 0 );
|
|
|
|
wxInitializer initializer( argc, argv );
|
|
|
|
if( !initializer.IsOk() )
|
|
{
|
|
std::fprintf( stderr, "pcb_convert: wxWidgets initialisation failed\n" );
|
|
return 3;
|
|
}
|
|
|
|
if( argc >= 2 && std::strcmp( argv[1], "--drc" ) == 0 )
|
|
{
|
|
// The minimal headless runtime never registers app settings;
|
|
// GetAppSettings fails SOFT to defaults but wxFAIL_MSGs on every call.
|
|
// Report output must stay parseable — drop the asserts.
|
|
wxDisableAsserts();
|
|
|
|
bool json = false;
|
|
bool strict = false;
|
|
int arg = 2;
|
|
|
|
while( arg < argc && std::strncmp( argv[arg], "--", 2 ) == 0 )
|
|
{
|
|
if( std::strcmp( argv[arg], "--json" ) == 0 )
|
|
json = true;
|
|
else if( std::strcmp( argv[arg], "--strict" ) == 0 )
|
|
strict = true;
|
|
else
|
|
break;
|
|
|
|
arg++;
|
|
}
|
|
|
|
if( arg >= argc )
|
|
{
|
|
std::fprintf( stderr,
|
|
"usage: pcb_convert --drc [--json] [--strict] <file.kicad_pcb> [<out>]\n" );
|
|
return 2;
|
|
}
|
|
|
|
const char* inPath = argv[arg++];
|
|
const char* outPath = arg < argc ? argv[arg] : nullptr;
|
|
|
|
int rc = 4;
|
|
|
|
try
|
|
{
|
|
rc = runDrc( inPath, json, strict, outPath );
|
|
}
|
|
catch( const std::exception& e )
|
|
{
|
|
std::fprintf( stderr, "%s: error: %s\n", inPath, e.what() );
|
|
}
|
|
|
|
// Skip the EXIT_RUNTIME static-dtor pass: some dieted-out editor
|
|
// teardown is still reachable through vtable slots from static dtors
|
|
// and traps ("table index is out of bounds") AFTER the report is
|
|
// written, clobbering the exit code. A CLI has nothing to tear down —
|
|
// flush and leave.
|
|
std::fflush( nullptr );
|
|
_exit( rc );
|
|
}
|
|
|
|
if( argc >= 2 && std::strcmp( argv[1], "--gerbers" ) == 0 )
|
|
{
|
|
wxDisableAsserts();
|
|
|
|
if( argc < 3 )
|
|
{
|
|
std::fprintf( stderr, "usage: kicad_tools --gerbers <file.kicad_pcb> [<outdir>]\n" );
|
|
return 2;
|
|
}
|
|
|
|
int rc = 4;
|
|
|
|
try
|
|
{
|
|
rc = runGerbers( argv[2], argc >= 4 ? argv[3] : nullptr );
|
|
}
|
|
catch( const std::exception& e )
|
|
{
|
|
std::fprintf( stderr, "%s: error: %s\n", argv[2], e.what() );
|
|
}
|
|
|
|
// Same static-dtor rationale as --drc above.
|
|
std::fflush( nullptr );
|
|
_exit( rc );
|
|
}
|
|
|
|
if( argc >= 2 && std::strcmp( argv[1], "--drill" ) == 0 )
|
|
{
|
|
wxDisableAsserts();
|
|
|
|
if( argc < 3 )
|
|
{
|
|
std::fprintf( stderr, "usage: kicad_tools --drill <file.kicad_pcb> [<outdir>]\n" );
|
|
return 2;
|
|
}
|
|
|
|
int rc = 4;
|
|
|
|
try
|
|
{
|
|
rc = runDrill( argv[2], argc >= 4 ? argv[3] : nullptr );
|
|
}
|
|
catch( const std::exception& e )
|
|
{
|
|
std::fprintf( stderr, "%s: error: %s\n", argv[2], e.what() );
|
|
}
|
|
|
|
// Same static-dtor rationale as --drc above.
|
|
std::fflush( nullptr );
|
|
_exit( rc );
|
|
}
|
|
|
|
if( argc >= 2 && std::strcmp( argv[1], "--plot-board" ) == 0 )
|
|
{
|
|
wxDisableAsserts();
|
|
|
|
bool pdf = false;
|
|
const char* layersArg = nullptr;
|
|
int arg = 2;
|
|
|
|
while( arg < argc && std::strncmp( argv[arg], "--", 2 ) == 0 )
|
|
{
|
|
if( std::strcmp( argv[arg], "--pdf" ) == 0 )
|
|
{
|
|
pdf = true;
|
|
}
|
|
else if( std::strcmp( argv[arg], "--layers" ) == 0 && arg + 1 < argc )
|
|
{
|
|
layersArg = argv[++arg];
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
|
|
arg++;
|
|
}
|
|
|
|
if( arg >= argc )
|
|
{
|
|
std::fprintf( stderr, "usage: kicad_tools --plot-board [--pdf] [--layers <a,b,...>] "
|
|
"<file.kicad_pcb> [<out>]\n" );
|
|
return 2;
|
|
}
|
|
|
|
const char* inPath = argv[arg++];
|
|
const char* outPath = arg < argc ? argv[arg] : nullptr;
|
|
int rc = 4;
|
|
|
|
try
|
|
{
|
|
rc = runPlotBoard( inPath, pdf, layersArg, outPath );
|
|
}
|
|
catch( const std::exception& e )
|
|
{
|
|
std::fprintf( stderr, "%s: error: %s\n", inPath, e.what() );
|
|
}
|
|
|
|
// Same static-dtor rationale as --drc above.
|
|
std::fflush( nullptr );
|
|
_exit( rc );
|
|
}
|
|
|
|
if( argc >= 2 && std::strcmp( argv[1], "--ipc356" ) == 0 )
|
|
{
|
|
wxDisableAsserts();
|
|
|
|
if( argc < 3 )
|
|
{
|
|
std::fprintf( stderr, "usage: kicad_tools --ipc356 <file.kicad_pcb> [<out.ipc>]\n" );
|
|
return 2;
|
|
}
|
|
|
|
int rc = 4;
|
|
|
|
try
|
|
{
|
|
rc = runIpc356( argv[2], argc >= 4 ? argv[3] : nullptr );
|
|
}
|
|
catch( const std::exception& e )
|
|
{
|
|
std::fprintf( stderr, "%s: error: %s\n", argv[2], e.what() );
|
|
}
|
|
|
|
// Same static-dtor rationale as --drc above.
|
|
std::fflush( nullptr );
|
|
_exit( rc );
|
|
}
|
|
|
|
if( argc >= 2 && std::strcmp( argv[1], "--fab-components" ) == 0 )
|
|
{
|
|
wxDisableAsserts();
|
|
|
|
if( argc < 3 )
|
|
{
|
|
std::fprintf( stderr,
|
|
"usage: kicad_tools --fab-components <file.kicad_pcb> [<out.json>]\n" );
|
|
return 2;
|
|
}
|
|
|
|
int rc = 4;
|
|
|
|
try
|
|
{
|
|
rc = runFabComponents( argv[2], argc >= 4 ? argv[3] : nullptr );
|
|
}
|
|
catch( const std::exception& e )
|
|
{
|
|
std::fprintf( stderr, "%s: error: %s\n", argv[2], e.what() );
|
|
}
|
|
|
|
// Same static-dtor rationale as --drc above.
|
|
std::fflush( nullptr );
|
|
_exit( rc );
|
|
}
|
|
|
|
std::fprintf( stderr, "usage: kicad_tools --drc [--json] [--strict] <file.kicad_pcb> [<out>]\n"
|
|
" kicad_tools --gerbers <file.kicad_pcb> [<outdir>]\n"
|
|
" kicad_tools --drill <file.kicad_pcb> [<outdir>]\n"
|
|
" kicad_tools --plot-board [--pdf] [--layers <a,b,...>] <file.kicad_pcb> [<out>]\n"
|
|
" kicad_tools --ipc356 <file.kicad_pcb> [<out.ipc>]\n"
|
|
" kicad_tools --fab-components <file.kicad_pcb> [<out.json>]\n" );
|
|
return 2;
|
|
}
|
|
|
|
|
|
#ifndef KICAD_TOOLS_COMBINED
|
|
int main( int argc, char** argv )
|
|
{
|
|
return pcbConvertMain( argc, argv );
|
|
}
|
|
#endif
|