qi-hardware/fped
1
0
Fork 0
mirror of git://projects.qi-hardware.com/fped.git synced 2024-09-30 13:26:01 +03:00
Code
b6807a7c0d
fped/obj.c
werner e6b2658a65 Added relaxation of pad overlap checking. Not GUI-settable yet. 
- README, fpd.l, fpd.y: added directives "allow touch" and "allow overlap" to
  make overlap checking more permissive
- dump.c (dump_allow, dump): generate "allow" directive
- obj.h, obj.c (allow_overlap): added global variable for strictness of overlap
  checking
- overlap.h, overlap.c (overlap, ...), layer.h, layer.c (refine_layers):
  strictness of overlap checking is passed as an argument
- hole.c (check_through_hole), layer.h, layer.c (refine_copper), obj.c
  (instantiate): updated callers of "overlap" to provide "allow" argument



git-svn-id: http://svn.openmoko.org/trunk/eda/fped@5974 99fdad57-331a-0410-800a-d7fa5415bdb3
2010-08-09 04:16:37 +00:00

526 lines
11 KiB
C
Raw Blame History

/*
* obj.c - Object definition model
*
* Written 2009, 2010 by Werner Almesberger
* Copyright 2009, 2010 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.
*/
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "util.h"
#include "error.h"
#include "expr.h"
#include "bitset.h"
#include "meas.h"
#include "inst.h"
#include "hole.h"
#include "overlap.h"
#include "layer.h"
#include "delete.h"
#include "obj.h"
#define DEFAULT_SILK_WIDTH make_mil(15) /* @@@ */
#define DEFAULT_OFFSET make_mil(0) /* @@@ */
#define MAX_ITERATIONS 1000 /* abort "loop"s at this limit */
char *pkg_name = NULL;
struct frame *frames = NULL;
struct frame *active_frame = NULL;
void *instantiation_error = NULL;
enum allow_overlap allow_overlap = ao_none;
static struct bitset *frame_set; /* frames visited in "call chain" */
/* ----- Searching --------------------------------------------------------- */
/*
* @@@ Known bug: we should compare all parameters of an instance, not just the
* object's base or the vectors end.
*/
static int found = 0;
static int search_suspended = 0;
static const struct vec *find_vec = NULL;
static const struct obj *find_obj = NULL;
static struct coord find_pos;
static void suspend_search(void)
{
search_suspended++;
}
static void resume_search(void)
{
assert(search_suspended > 0);
search_suspended--;
}
static struct coord get_pos(const struct inst *inst)
{
return inst->obj ? inst->base : inst->u.vec.end;
}
void find_inst(const struct inst *inst)
{
struct coord pos;
if (search_suspended)
return;
if (find_vec != inst->vec)
return;
if (find_obj != inst->obj)
return;
pos = get_pos(inst);
if (pos.x != find_pos.x || pos.y != find_pos.y)
return;
found++;
}
void search_inst(const struct inst *inst)
{
find_vec = inst->vec;
find_obj = inst->obj;
find_pos = get_pos(inst);
}
/* ----- Get the list of anchors of an object ------------------------------ */
int obj_anchors(struct obj *obj, struct vec ***anchors)
{
anchors[0] = &obj->base;
switch (obj->type) {
case ot_frame:
return 1;
case ot_rect:
case ot_line:
anchors[1] = &obj->u.rect.other;
return 2;
case ot_pad:
anchors[1] = &obj->u.pad.other;
return 2;
case ot_hole:
anchors[1] = &obj->u.hole.other;
return 2;
case ot_meas:
anchors[1] = &obj->u.meas.high;
return 2;
case ot_arc:
/*
* Put end point first so that this is what we grab if dragging
* a circle (thereby turning it into an arc).
*/
anchors[1] = &obj->u.arc.end;
anchors[2] = &obj->u.arc.start;
return 3;
default:
abort();
}
}
/* ----- Instantiation ----------------------------------------------------- */
static int generate_frame(struct frame *frame, struct coord base,
const struct frame *parent, struct obj *frame_ref, int active);
struct num eval_unit(const struct expr *expr, const struct frame *frame);
/*static*/ struct num eval_unit(const struct expr *expr, const struct frame *frame)
{
struct num d;
d = eval_num(expr, frame);
if (!is_undef(d) && to_unit(&d))
return d;
fail_expr(expr);
return undef;
}
static struct num eval_unit_default(const struct expr *expr,
const struct frame *frame, struct num def)
{
if (expr)
return eval_unit(expr, frame);
to_unit(&def);
return def;
}
static int generate_vecs(struct frame *frame, struct coord base)
{
struct coord vec_base;
struct vec *vec;
struct num x, y;
for (vec = frame->vecs; vec; vec = vec->next) {
x = eval_unit(vec->x, frame);
if (is_undef(x))
goto error;
y = eval_unit(vec->y, frame);
if (is_undef(y))
goto error;
vec_base = vec->base ? vec->base->pos : base;
vec->pos = vec_base;
vec->pos.x += x.n;
vec->pos.y += y.n;
if (!inst_vec(vec, vec_base))
goto error;
meas_post(vec, vec->pos, frame_set);
}
return 1;
error:
instantiation_error = vec;
return 0;
}
static int generate_objs(struct frame *frame, struct coord base, int active)
{
struct obj *obj;
char *name;
int ok;
struct num width, offset;
for (obj = frame->objs; obj; obj = obj->next)
switch (obj->type) {
case ot_frame:
if (!generate_frame(obj->u.frame.ref,
obj->base ? obj->base->pos : base, frame, obj,
active && obj->u.frame.ref->active_ref == obj))
return 0;
break;
case ot_line:
width = eval_unit_default(obj->u.line.width, frame,
DEFAULT_SILK_WIDTH);
if (is_undef(width))
goto error;
if (!inst_line(obj, obj->base ? obj->base->pos : base,
obj->u.line.other ? obj->u.line.other->pos : base,
width.n))
goto error;
break;
case ot_rect:
width = eval_unit_default(obj->u.rect.width, frame,
DEFAULT_SILK_WIDTH);
if (is_undef(width))
goto error;
if (!inst_rect(obj, obj->base ? obj->base->pos : base,
obj->u.rect.other ? obj->u.rect.other->pos : base,
width.n))
goto error;
break;
case ot_pad:
name = expand(obj->u.pad.name, frame);
if (!name)
goto error;
ok = inst_pad(obj, name,
obj->base ? obj->base->pos : base,
obj->u.pad.other ? obj->u.pad.other->pos : base);
free(name);
if (!ok)
goto error;
break;
case ot_hole:
if (!inst_hole(obj, obj->base ? obj->base->pos : base,
obj->u.hole.other ? obj->u.hole.other->pos : base))
goto error;
break;
case ot_arc:
width = eval_unit_default(obj->u.arc.width, frame,
DEFAULT_SILK_WIDTH);
if (is_undef(width))
goto error;
if (!inst_arc(obj, obj->base ? obj->base->pos : base,
obj->u.arc.start ? obj->u.arc.start->pos : base,
obj->u.arc.end ? obj->u.arc.end->pos : base,
width.n))
goto error;
break;
case ot_meas:
assert(frame == frames);
offset = eval_unit_default(obj->u.meas.offset, frame,
DEFAULT_OFFSET);
if (is_undef(offset))
goto error;
inst_meas_hint(obj, offset.n);
break;
default:
abort();
}
return 1;
error:
instantiation_error = obj;
return 0;
}
static int generate_items(struct frame *frame, struct coord base, int active)
{
char *s;
int ok;
if (frame == frames) {
s = expand(pkg_name, frame);
inst_select_pkg(s);
free(s);
}
inst_begin_active(active && frame == active_frame);
ok = generate_vecs(frame, base) && generate_objs(frame, base, active);
inst_end_active();
return ok;
}
static int run_loops(struct frame *frame, struct loop *loop,
struct coord base, int active)
{
struct num from, to;
int n;
int found_before, ok;
if (!loop)
return generate_items(frame, base, active);
from = eval_num(loop->from.expr, frame);
if (is_undef(from)) {
fail_expr(loop->from.expr);
instantiation_error = loop;
return 0;
}
if (!is_dimensionless(from)) {
fail("incompatible type for start value");
fail_expr(loop->from.expr);
instantiation_error = loop;
return 0;
}
to = eval_num(loop->to.expr, frame);
if (is_undef(to)) {
fail_expr(loop->to.expr);
instantiation_error = loop;
return 0;
}
if (!is_dimensionless(to)) {
fail("incompatible type for end value");
fail_expr(loop->to.expr);
instantiation_error = loop;
return 0;
}
assert(!loop->initialized);
loop->curr_value = from.n;
loop->initialized = 1;
n = 0;
for (; loop->curr_value <= to.n; loop->curr_value += 1) {
if (n >= MAX_ITERATIONS) {
fail("%s: too many iterations (%d)", loop->var.name,
MAX_ITERATIONS);
instantiation_error = loop;
goto fail;
}
found_before = found;
if (loop->found == loop->active)
suspend_search();
ok = run_loops(frame, loop->next, base,
active && loop->active == n);
if (loop->found == loop->active)
resume_search();
if (!ok)
goto fail;
if (found_before != found)
loop->found = n;
n++;
}
loop->initialized = 0;
loop->curr_value = UNDEF;
if (active) {
loop->n = from.n;
loop->iterations = n;
}
return 1;
fail:
loop->initialized = 0;
return 0;
}
static int iterate_tables(struct frame *frame, struct table *table,
struct coord base, int active)
{
int found_before, ok;
if (!table)
return run_loops(frame, frame->loops, base, active);
for (table->curr_row = table->rows; table->curr_row;
table->curr_row = table->curr_row->next) {
found_before = found;
if (table->found_row == table->active_row)
suspend_search();
ok = iterate_tables(frame, table->next, base,
active && table->active_row == table->curr_row);
if (table->found_row == table->active_row)
resume_search();
if (!ok)
return 0;
if (found_before != found)
table->found_row = table->curr_row;
}
return 1;
}
static int generate_frame(struct frame *frame, struct coord base,
const struct frame *parent, struct obj *frame_ref, int active)
{
int ok;
/*
* We ensure during construction that frames can never recurse.
*/
inst_begin_frame(frame_ref, frame, base,
active && parent == active_frame,
active && frame == active_frame);
bitset_set(frame_set, frame->n);
frame->curr_parent = parent;
ok = iterate_tables(frame, frame->tables, base, active);
inst_end_frame(frame);
bitset_clear(frame_set, frame->n);
frame->curr_parent = NULL;
return ok;
}
static void reset_all_loops(void)
{
const struct frame *frame;
struct loop *loop;
for (frame = frames; frame; frame = frame->next)
for (loop = frame->loops; loop; loop = loop->next)
loop->iterations = 0;
}
static void reset_found(void)
{
struct frame *frame;
struct table *table;
struct loop *loop;
for (frame = frames; frame; frame = frame->next) {
for (table = frame->tables; table; table = table->next)
table->found_row = NULL;
for (loop = frame->loops; loop; loop = loop->next)
loop->found = -1;
frame->found_ref = NULL;
}
}
/*
* Note: we don't use frame->found_ref yet. Instead, we adjust the frame
* references with activate_item in inst.c
*/
static void activate_found(void)
{
struct frame *frame;
struct table *table;
struct loop *loop;
for (frame = frames; frame; frame = frame->next) {
for (table = frame->tables; table; table = table->next)
if (table->found_row)
table->active_row = table->found_row;
for (loop = frame->loops; loop; loop = loop->next)
if (loop->found != -1)
loop->active = loop->found;
if (frame->found_ref)
frame->active_ref = frame->found_ref;
}
}
static int enumerate_frames(void)
{
struct frame *frame;
int n = 0;
for (frame = frames; frame; frame = frame->next)
frame->n = n++;
return n;
}
int instantiate(void)
{
struct coord zero = { 0, 0 };
int n_frames;
int ok;
meas_start();
inst_start();
n_frames = enumerate_frames();
frame_set = bitset_new(n_frames);
instantiation_error = NULL;
reset_all_loops();
reset_found();
found = 0;
search_suspended = 0;
ok = generate_frame(frames, zero, NULL, NULL, 1);
if (ok && (find_vec || find_obj) && found)
activate_found();
find_vec = NULL;
find_obj = NULL;
if (ok)
ok = link_holes();
if (ok)
ok = refine_layers(allow_overlap);
if (ok)
ok = instantiate_meas(n_frames);
if (ok)
inst_commit();
else
inst_revert();
bitset_free(frame_set);
return ok;
}
/* ----- deallocation ------------------------------------------------------ */
void obj_cleanup(void)
{
free(pkg_name);
while (frames) {
delete_frame(frames);
destroy();
}
}
View Git Blame Copy Permalink