eda-tools/sch2fig/sch.c

/*
 * sch.c - Parse Eeschema .sch file
 *
 * Written 2016 by Werner Almesberger
 * Copyright 2016 by Werner Almesberger
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */


#define	_GNU_SOURCE	/* for asprintf */
#include <stddef.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>

#include "util.h"
#include "misc.h"
#include "style.h"
#include "gfx.h"
#include "dwg.h"
#include "lib.h"
#include "sch.h"


/* ----- Rendering --------------------------------------------------------- */


static void dump_field(const struct comp_field *field, const int m[6])
{
	struct text txt = field->txt;
	int dx, dy;

	dx = txt.x - m[0];
	dy = txt.y - m[3];
	txt.x = mx(dx, dy, m);
	txt.y = my(dx, dy, m);

	text_rot(&txt, matrix_to_angle(m));

	switch (txt.rot) {
	case 180:
		text_rot(&txt, 180);
		txt.hor = text_flip(txt.hor);
		txt.vert = text_flip(txt.vert);
		break;
	case 270:
		text_rot(&txt, 180);
		txt.vert = text_flip(txt.vert);
		txt.hor = text_flip(txt.hor);
		break;
	default:
		break;
	}

	if (matrix_is_mirrored(m)) {
		if ((txt.rot % 180) == 0)
			txt.hor = text_flip(txt.hor);
		else
			txt.vert = text_flip(txt.vert);
	}

	text_fig(&txt, COLOR_FIELD, LAYER_FIELD);
}


static void do_hsheet_text(const struct sch_obj *obj,
    const struct sch_sheet *sheet)
{
	char *s;

	assert(sheet->sheet && sheet->file);

	struct text sheet_txt = {
		.size = sheet->sheet_dim,
		.x = obj->x,
		.y = obj->y,
		.rot = 0,
		.hor = text_min,
		.vert = text_min,
	};
	if (asprintf(&s, "Sheet: %s", sheet->sheet)) {}
	sheet_txt.s = s; /* work around "const" mismatch */

	struct text file_txt = {
		.size = sheet->file_dim,
		.x = obj->x,
		.y = obj->y,
		.rot = 0,
		.hor = text_min,
		.vert = text_max,
	};
	if (asprintf(&s, "File: %s", sheet->file)) {}
	file_txt.s = s; /* work around "const" mismatch */

	if (sheet->rotated) {
		sheet_txt.rot = file_txt.rot = 90;
		sheet_txt.x -= HSHEET_FIELD_OFFSET;
		sheet_txt.y += sheet->h;
		file_txt.x += sheet->w + HSHEET_FIELD_OFFSET;
		file_txt.y += sheet->h;
	} else {
		sheet_txt.y -= HSHEET_FIELD_OFFSET;
		file_txt.y += sheet->h + HSHEET_FIELD_OFFSET;
	}

	text_fig(&sheet_txt, COLOR_HSHEET_SHEET, LAYER_HSHEET_FIELD);
	text_fig(&file_txt, COLOR_HSHEET_FILE, LAYER_HSHEET_FIELD);

//	free((void *) ctx->sheet);
//	free((void *) ctx->file);
}


static void render_sheet(const struct sch_obj *obj,
    const struct sch_sheet *sheet)
{
	const struct sheet_field *field;

	gfx_rect(obj->x, obj->y, obj->x + sheet->w, obj->y + sheet->h,
	    COLOR_HSHEET_BOX, COLOR_NONE, LAYER_HSHEET_BOX);
	do_hsheet_text(obj, sheet);

	for (field = sheet->fields; field; field = field->next)
		dwg_hlabel(obj->x, obj->y, field->s,
		    field->side, field->dim,
		    field->shape);
	// free(field->s)
}


void sch_render(const struct sch_ctx *ctx)
{
	const struct sch_obj *obj;

	for (obj = ctx->objs; obj; obj = obj->next)
		switch (obj->type) {
		case sch_obj_wire:
			{
				const struct sch_wire *wire = &obj->u.wire;

				wire->fn(obj->x, obj->y, wire->ex, wire->ey);
			}
			break;
		case sch_obj_junction:
			dwg_junction(obj->x, obj->y);
			break;
		case sch_obj_noconn:
			dwg_noconn(obj->x, obj->y);
			break;
		case sch_obj_text:
			{
				const struct sch_text *text = &obj->u.text;

				text->fn(obj->x, obj->y, text->s, text->dir,
				    text->dim, text->shape);
			}
			break;
		case sch_obj_comp:
			{
				const struct sch_comp *comp = &obj->u.comp;
				const struct comp_field *field;

				lib_exec(comp->comp, comp->unit, comp->m);
				for (field = comp->fields; field;
				    field = field->next)
					dump_field(field, comp->m);
			}
			break;
		case sch_obj_sheet:
			render_sheet(obj, &obj->u.sheet);
			break;
		}
}


/* ----- (Global) Labels --------------------------------------------------- */


static enum dwg_shape do_decode_shape(const char *s)
{
	if (!strcmp(s, "UnSpc"))
		return dwg_unspec;
	if (!strcmp(s, "Input"))
		return dwg_in;
	if (!strcmp(s, "Output"))
		return dwg_out;
	if (!strcmp(s, "3State"))
		return dwg_tri;
	if (!strcmp(s, "BiDi"))
		return dwg_bidir;
	fprintf(stderr, "unknown shape: \"%s\"\n", s);
	exit(1);
}


static enum dwg_shape decode_shape(const char *s)
{
	enum dwg_shape res;

	res = do_decode_shape(s);
	free((void *) s);
	return res;
}


/* ----- Text -------------------------------------------------------------- */


static void draw_text(int x, int y, const char *s, int dir, int dim,
    enum dwg_shape shape)
{
	struct text txt = {
		.s = s,
		.size = dim,
		.x = x,
		.y = y,
		.rot = 0,
		.hor = text_min,
		.vert = text_min,
	};

	switch (dir) {
	case 0:	/* right */
		break;
	case 1:	/* up */
		text_rot(&txt, 90);
		break;
	case 2:	/* left */
		txt.hor = text_max;
		break;
	case 3:	/* down */
		text_rot(&txt, 90);
		txt.hor = text_max;
		break;
	default:
		assert(2 + 2 == 5);
	}

	text_fig(&txt, COLOR_TEXT, LAYER_TEXT);
}


/* ----- Component fields -------------------------------------------------- */


void decode_alignment(struct text *txt, char hor, char vert)
{
	switch (hor) {
	case 'L':
		txt->hor = text_min;
		break;
	case 'C':
		txt->hor = text_mid;
		break;
	case 'R':
		txt->hor = text_max;
		break;
	default:
		assert(0);
	}

	switch (vert) {
	case 'B':
		txt->vert = text_min;
		break;
	case 'C':
		txt->vert = text_mid;
		break;
	case 'T':
		txt->vert = text_max;
		break;
	default:
		assert(0);
	}
}


static bool parse_field(struct sch_ctx *ctx, const char *line)
{
	struct sch_comp *comp = &ctx->obj.u.comp;
	int n;
	unsigned flags;
	char hv, hor, vert, italic, bold;
	struct comp_field *field;
	struct text *txt;

	field = alloc_type(struct comp_field);
	txt = &field->txt;

	if (sscanf(line, "F %d \"\" %c %d %d %u %u %c %c%c%c",
	    &n, &hv, &txt->x, &txt->y, &txt->size, &flags, &hor, &vert,
	    &italic, &bold) == 10) {
		free(field);
		return 1;
	}
	if (sscanf(line, "F %d \"%m[^\"]\" %c %d %d %u %u %c %c%c%c",
	    &n, &txt->s, &hv, &txt->x, &txt->y, &txt->size, &flags,
	    &hor, &vert, &italic, &bold) != 11)
		return 0;

	if (flags || !lib_field_visible(comp->comp, n)) {
		free(field);
		return 1;
	}

	if (n == 0 && comp->comp->units > 1) {
		int len = strlen(txt->s);
		char *s;

		s = realloc((void *) txt->s, len + 3);
		if (!s) {
			perror("realloc");
			exit(1);
		}
		if (comp->unit <= 26)
			sprintf(s + len, "%c", 'A' + comp->unit - 1);
		else
			sprintf(s + len, "%c%c",
			    'A' + (comp->unit - 1) / 26 - 1,
			    'A' + (comp->unit - 1) % 26);
	}

	field->next = comp->fields;
	comp->fields = field;

	switch (hv) {
	case 'H':
		txt->rot = 0;
		break;
	case 'V':
		txt->rot = 90;
		break;
	default:
		assert(0);
	}

	decode_alignment(txt, hor, vert);

	// @@@ decode font

	return 1;
}


/* ----- Sheet field ------------------------------------------------------- */


static enum dwg_shape decode_form(char form)
{
	switch (form) {
	case 'O':
		return dwg_in;
	case 'I':
		return dwg_out;
	case 'B':
		/* fall through */
	case 'T':
		return dwg_bidir;
	case 'U':
		return dwg_unspec;
	default:
		fprintf(stderr, "unknown form: \"%c\"\n", form);
		exit(1);
	}
}


static int decode_side(char side)
{
	switch (side) {
	case 'L':
		return 2;	/* left */
	case 'B':
		return 1;	/* up */
	case 'R':
		return 0;	/* right */
	case 'T':
		return 3;	/* down */
	default:
		fprintf(stderr, "unknown side: \"%c\"\n", side);
		exit(1);
	}
}


static bool parse_hsheet_field(struct sch_ctx *ctx, const char *line)
{
	struct sch_sheet *sheet = &ctx->obj.u.sheet;
	char *s;
	char form, side;
	unsigned n, dim;
	struct sheet_field *field;

	if (sscanf(line, "F%d \"%m[^\"]\" %u", &n, &s, &dim) == 3) {
		switch (n) {
		case 0:
			sheet->sheet = s;
			sheet->sheet_dim = dim;
			return 1;
		case 1:
			sheet->file = s;
			sheet->file_dim = dim;
			return 1;
		default:
			assert(0);
		}
	}

	field = alloc_type(struct sheet_field);
	if (sscanf(line, "F%d \"%m[^\"]\" %c %c %d %d %u",
	    &n, &field->s, &form, &side, &field->x, &field->y, &field->dim)
	    != 7) {
		free(field);
		return 0;
	}
	assert(n >= 2);

	if (side == 'B' || side == 'T') {
		/*
		 * This is beautiful: since there is no indication for rotation
		 * on the hsheet, or the sheet or file fields, we need to look
		 * at whether the imported sheet pins go left or right (no
		 * rotation) or whether they go top or bottom (rotation).
		 *
		 * A sheet with no imported pins lacks these hints, and is
		 * therefore always assumed to be without rotation.
		 *
		 * Eeschema is careful to be consistent, and does not allow
		 * sheets with no imported pins to be rotated. Even better, it
		 * flips rotated sheets where the last imported pin is deleted
		 * back.
		 */
		sheet->rotated = 1;
	}
	field->shape = decode_form(form);
	field->side = decode_side(side);

	field->next = sheet->fields;
	sheet->fields = field;

	return 1;
}


/* ----- Schematics parser ------------------------------------------------- */


static void submit_obj(struct sch_ctx *ctx, enum sch_obj_type type)
{
	struct sch_obj *obj;

	obj = alloc_type(struct sch_obj);
	*obj = ctx->obj;
	obj->type = type;
	obj->next = ctx->objs;
	ctx->objs = obj;
}


bool sch_parse(struct sch_ctx *ctx, const char *line)
{
	struct sch_obj *obj = &ctx->obj;
	int n = 0;
	char *s;

	ctx->lineno++;

	switch (ctx->state) {
	case sch_basic:
		if (sscanf(line, "$Comp%n", &n) == 0 && n) {
			ctx->state = sch_comp;
			obj->u.comp.fields = NULL;
			return 1;
		}
		if (sscanf(line, "$Sheet%n", &n) == 0 && n) {
			ctx->state = sch_sheet;
			obj->u.sheet.sheet = NULL;
			obj->u.sheet.file = NULL;
			obj->u.sheet.rotated = 0;
			obj->u.sheet.fields = NULL;
			return 1;
		}

		/* Text */

		struct sch_text *text = &obj->u.text;

		if (sscanf(line, "Text Notes %d %d %d %d",
		    &obj->x, &obj->y, &text->dir, &text->dim) == 4) {
			ctx->state = sch_text;
			obj->u.text.fn = draw_text;
			return 1;
		}
		if (sscanf(line, "Text GLabel %d %d %d %d %ms",
		    &obj->x, &obj->y, &text->dir, &text->dim, &s) == 5) {
			ctx->state = sch_text;
			obj->u.text.fn = dwg_glabel;
			obj->u.text.shape = decode_shape(s);
			return 1;
		}
		if (sscanf(line, "Text HLabel %d %d %d %d %ms",
		    &obj->x, &obj->y, &text->dir, &text->dim, &s) == 5) {
			ctx->state = sch_text;
			obj->u.text.fn = dwg_hlabel;
			obj->u.text.shape = decode_shape(s);
			return 1;
		}
		if (sscanf(line, "Text Label %d %d %d %d",
		    &obj->x, &obj->y, &text->dir, &text->dim) == 4) {
			ctx->state = sch_text;
			obj->u.text.fn = dwg_label;
			return 1;
		}

		/* Connection */

		if (sscanf(line, "Connection ~ %d %d", &obj->x, &obj->y) == 2) {
			submit_obj(ctx, sch_obj_junction);
			return 1;
		}

		/* NoConn */

		if (sscanf(line, "NoConn ~ %d %d", &obj->x, &obj->y) == 2) {
			submit_obj(ctx, sch_obj_noconn);
			return 1;
		}

		/* Wire */

		if (sscanf(line, "Wire Wire Line%n", &n) == 0 && n) {
			ctx->state = sch_wire;
			obj->u.wire.fn = dwg_wire;
			return 1;
		}
		if (sscanf(line, "Wire Bus Line%n", &n) == 0 && n) {
			ctx->state = sch_wire;
			obj->u.wire.fn = dwg_bus;
			return 1;
		}
		if (sscanf(line, "Wire Notes Line%n", &n) == 0 && n) {
			ctx->state = sch_wire;
			obj->u.wire.fn = dwg_line;
			return 1;
		}

		/* Entry */

		/*
		 * Documentation mentions the following additional variants:
		 *
		 * - Entry Wire Line equivalent:
		 *   Wire Wire Bus
		 *   Entry Wire Bus
		 *
		 * - Entry Bus Bus equivalent:
		 *   Wire Bus Bus
		 */
		if (sscanf(line, "Entry Wire Line%n", &n) == 0 && n) {
			ctx->state = sch_wire;
			obj->u.wire.fn = dwg_wire;
			return 1;
		}
		if (sscanf(line, "Entry Bus Bus%n", &n) == 0 && n) {
			ctx->state = sch_wire;
			obj->u.wire.fn = dwg_bus;
			return 1;
		}

		/* EndSCHEMATC */

		if (sscanf(line, "$EndSCHEMATC%n", &n) == 0 && n)
			return 0;
		break;
	case sch_descr:
		if (sscanf(line, "$EndDescr%n", &n) || !n)
			return 1;
		ctx->state = sch_basic;
		return 1;
	case sch_comp:
		if (sscanf(line, "$EndComp%n", &n) == 0 && n) {
			ctx->state = sch_basic;
			submit_obj(ctx, sch_obj_comp);
			return 1;
		}
		if (sscanf(line, "L %ms", &s) == 1) {
			obj->u.comp.comp = lib_find(s);
			free(s);
			return 1;
		}
		if (sscanf(line, "U %u", &obj->u.comp.unit) == 1)
			return 1;
		if (sscanf(line, "P %d %d", &obj->x, &obj->y) == 2)
			return 1;
		if (parse_field(ctx, line))
			return 1;
		if (sscanf(line, "AR %n", &n) == 0 && n)
			return 1; /* @@@ what is "AR" ? */
		n = sscanf(line, " %d %d %d %d",
		    obj->u.comp.m + 1, obj->u.comp.m + 2,
		    obj->u.comp.m + 4, obj->u.comp.m + 5);
		if (n == 3)
			return 1;
		if (n == 4) {
			obj->u.comp.m[0] = obj->x;
			obj->u.comp.m[3] = obj->y;
			return 1;
		}
		break;
	case sch_sheet:
		if (sscanf(line, "$EndSheet%n", &n) == 0 && n) {
			ctx->state = sch_basic;
			submit_obj(ctx, sch_obj_sheet);
			return 1;
		}
		if (sscanf(line, "S %d %d %u %u",
		    &obj->x, &obj->y, &obj->u.sheet.w, &obj->u.sheet.h) == 4)
			return 1;
		if (sscanf(line, "U %*x%n", &n) == 0 && n)
			return 1;
		if (parse_hsheet_field(ctx, line))
			return 1;
		break;
	case sch_text:
		ctx->state = sch_basic;
		{
			const char *from;
			char *to;

			s = alloc_size(strlen(line) + 1);
			from = line;
			to = s;
			while (*from) {
				if (from[0] != '\\' || from[1] != 'n') {
					*to++ = *from++;
					continue;
				}
				*to++ = '\n';
				from += 2;
			}
			*to = 0;
			obj->u.text.s = s;
			submit_obj(ctx, sch_obj_text);
		}
		return 1;
	case sch_wire:
		if (sscanf(line, "%d %d %d %d", &obj->x, &obj->y,
		    &obj->u.wire.ex, &obj->u.wire.ey) != 4)
			break;
		submit_obj(ctx, sch_obj_wire);
		ctx->state = sch_basic;
		return 1;
	default:
		abort();
	}
	fprintf(stderr, "%u: cannot parse\n\"%s\"\n", ctx->lineno, line);
	exit(1);
}


void sch_init(struct sch_ctx *ctx)
{
	ctx->state = sch_descr;
	ctx->objs = NULL;
	ctx->lineno = 0;
}