Root/
Source at commit bc27b094af74a7c6f8b71ceaa63d1ba80d067cbb created 13 years 11 months ago. By werner, With a little help from m8cutils and abyss, we now have regression tests for the topological sort. "make test" or "make tests" invokes the regression tests, "make valgrind" runs them under valgrind's watchful eyes. | |
---|---|
1 | /* |
2 | * dump.c - Dump objects in the native FPD format |
3 | * |
4 | * Written 2009, 2010 by Werner Almesberger |
5 | * Copyright 2009, 2010 by Werner Almesberger |
6 | * |
7 | * This program is free software; you can redistribute it and/or modify |
8 | * it under the terms of the GNU General Public License as published by |
9 | * the Free Software Foundation; either version 2 of the License, or |
10 | * (at your option) any later version. |
11 | */ |
12 | |
13 | |
14 | #include <stdlib.h> |
15 | #include <stdio.h> |
16 | |
17 | #include "util.h" |
18 | #include "unparse.h" |
19 | #include "obj.h" |
20 | #include "gui_status.h" |
21 | #include "dump.h" |
22 | |
23 | |
24 | /* ----- order items ------------------------------------------------------- */ |
25 | |
26 | |
27 | static void add_item(struct order **curr, struct vec *vec, struct obj *obj) |
28 | { |
29 | (*curr)->vec = vec; |
30 | (*curr)->obj = obj; |
31 | (*curr)++; |
32 | } |
33 | |
34 | |
35 | static int n_vec_refs(const struct vec *vec) |
36 | { |
37 | const struct vec *walk; |
38 | int n; |
39 | |
40 | n = 0; |
41 | for (walk = vec->frame->vecs; walk; walk = walk->next) |
42 | if (walk->base == vec) |
43 | n++; |
44 | return n; |
45 | } |
46 | |
47 | |
48 | /* |
49 | * If "prev" is non-NULL, we're looking for objects that need to be put after |
50 | * the current vector (in "prev"). Only those objects need to be put there |
51 | * that have at least one base that isn't the frame's origin. |
52 | * |
53 | * We could also make an exception for manually named vectors, but we get |
54 | * better clustering without. |
55 | */ |
56 | |
57 | static int need(const struct vec *base, const struct vec *prev) |
58 | { |
59 | if (!base) |
60 | return 0; |
61 | #if 0 |
62 | if (base->name && *base->name != '_') |
63 | return 0; |
64 | #endif |
65 | if (prev) |
66 | return base == prev; |
67 | return 1; |
68 | } |
69 | |
70 | |
71 | /* |
72 | * If we need a vector that's defined later, we have to defer dumping the |
73 | * object. |
74 | */ |
75 | |
76 | static int later(const struct vec *base, const struct vec *prev) |
77 | { |
78 | return base && !base->dumped; |
79 | #if 0 |
80 | while (1) { |
81 | prev = prev->next; |
82 | if (!prev) |
83 | break; |
84 | if (base == prev) |
85 | return 1; |
86 | } |
87 | return 0; |
88 | #endif |
89 | } |
90 | |
91 | |
92 | static int may_put_obj_now(const struct obj *obj, const struct vec *prev) |
93 | { |
94 | int n, l; |
95 | |
96 | n = need(obj->base, prev); |
97 | l = later(obj->base, prev); |
98 | |
99 | switch (obj->type) { |
100 | case ot_frame: |
101 | break; |
102 | case ot_line: |
103 | n |= need(obj->u.line.other, prev); |
104 | l |= later(obj->u.line.other, prev); |
105 | break; |
106 | case ot_rect: |
107 | n |= need(obj->u.rect.other, prev); |
108 | l |= later(obj->u.rect.other, prev); |
109 | break; |
110 | case ot_pad: |
111 | n |= need(obj->u.pad.other, prev); |
112 | l |= later(obj->u.pad.other, prev); |
113 | break; |
114 | case ot_hole: |
115 | n |= need(obj->u.hole.other, prev); |
116 | l |= later(obj->u.hole.other, prev); |
117 | break; |
118 | case ot_arc: |
119 | n |= need(obj->u.arc.start, prev); |
120 | n |= need(obj->u.arc.end, prev); |
121 | l |= later(obj->u.arc.start, prev); |
122 | l |= later(obj->u.arc.end, prev); |
123 | break; |
124 | case ot_meas: |
125 | return 0; |
126 | default: |
127 | abort(); |
128 | } |
129 | |
130 | return n && !l; |
131 | } |
132 | |
133 | |
134 | static void put_obj(struct order **curr, struct obj *obj, |
135 | struct vec *prev) |
136 | { |
137 | if (obj->dumped) |
138 | return; |
139 | obj->dumped = 1; |
140 | add_item(curr, prev, obj); |
141 | } |
142 | |
143 | /* |
144 | * Tricky logic ahead: when dumping a vector, we search for a vector that |
145 | * depends on that vector for ".". If we find one, we dump it immediately after |
146 | * this vector. |
147 | */ |
148 | |
149 | static void recurse_vec(struct order **curr, struct vec *vec) |
150 | { |
151 | struct vec *next; |
152 | struct obj *obj; |
153 | |
154 | vec->dumped = 1; |
155 | add_item(curr, vec, NULL); |
156 | for (obj = vec->frame->objs; obj; obj = obj->next) |
157 | if (may_put_obj_now(obj, vec)) |
158 | put_obj(curr, obj, vec); |
159 | if (n_vec_refs(vec) == 1) { |
160 | for (next = vec->next; next->base != vec; next = next->next); |
161 | recurse_vec(curr, next); |
162 | } |
163 | } |
164 | |
165 | |
166 | static void order_vecs(struct order **curr, struct vec *vecs) |
167 | { |
168 | struct vec *vec; |
169 | |
170 | for (vec = vecs; vec; vec = vec->next) |
171 | if (!vec->base || n_vec_refs(vec->base) != 1) |
172 | recurse_vec(curr, vec); |
173 | } |
174 | |
175 | |
176 | struct order *order_frame(const struct frame *frame) |
177 | { |
178 | struct order *order, *curr; |
179 | struct vec *vec; |
180 | struct obj *obj; |
181 | int n = 0; |
182 | |
183 | for (vec = frame->vecs; vec; vec = vec->next) |
184 | n++; |
185 | for (obj = frame->objs; obj; obj = obj->next) |
186 | if (obj->type != ot_meas) |
187 | n++; |
188 | |
189 | for (vec = frame->vecs; vec; vec = vec->next) |
190 | vec->dumped = 0; |
191 | for (obj = frame->objs; obj; obj = obj->next) |
192 | obj->dumped = 0; |
193 | |
194 | order = alloc_size(sizeof(*order)*(n+1)); |
195 | curr = order; |
196 | |
197 | order_vecs(&curr, frame->vecs); |
198 | |
199 | /* frames based on @ (anything else ?) */ |
200 | for (obj = frame->objs; obj; obj = obj->next) |
201 | if (obj->type != ot_meas) |
202 | put_obj(&curr, obj, NULL); |
203 | |
204 | assert(curr == order+n); |
205 | add_item(&curr, NULL, NULL); |
206 | |
207 | return order; |
208 | } |
209 | |
210 | |
211 | /* ----- variables --------------------------------------------------------- */ |
212 | |
213 | |
214 | static void dump_var(FILE *file, const struct table *table, |
215 | const char *indent) |
216 | { |
217 | char *s; |
218 | |
219 | s = unparse(table->rows->values->expr); |
220 | fprintf(file, "%sset %s = %s\n\n", indent, table->vars->name, s); |
221 | free(s); |
222 | } |
223 | |
224 | |
225 | static void dump_table(FILE *file, const struct table *table, |
226 | const char *indent) |
227 | { |
228 | const struct var *var; |
229 | const struct row *row; |
230 | const struct value *value; |
231 | char *s; |
232 | |
233 | if (table->vars && !table->vars->next && |
234 | table->rows && !table->rows->next) { |
235 | dump_var(file, table, indent); |
236 | return; |
237 | } |
238 | fprintf(file, "%stable\n%s {", indent, indent); |
239 | for (var = table->vars; var; var = var->next) |
240 | fprintf(file, "%s %s", var == table->vars ? "" : ",", |
241 | var->name); |
242 | fprintf(file, " }\n"); |
243 | for (row = table->rows; row; row = row->next) { |
244 | fprintf(file, "%s {", indent); |
245 | for (value = row->values; value; value = value->next) { |
246 | s = unparse(value->expr); |
247 | fprintf(file, "%s %s", |
248 | value == row->values? "" : ",", s); |
249 | free(s); |
250 | } |
251 | fprintf(file, " }\n"); |
252 | } |
253 | fprintf(file, "\n"); |
254 | } |
255 | |
256 | |
257 | static void dump_loop(FILE *file, const struct loop *loop, const char *indent) |
258 | { |
259 | char *from, *to; |
260 | |
261 | from = unparse(loop->from.expr); |
262 | to = unparse(loop->to.expr); |
263 | fprintf(file, "%sloop %s = %s, %s\n\n", |
264 | indent, loop->var.name, from, to); |
265 | free(from); |
266 | free(to); |
267 | } |
268 | |
269 | |
270 | /* ----- vectors and objects ----------------------------------------------- */ |
271 | |
272 | |
273 | static void generate_name(struct vec *base) |
274 | { |
275 | char tmp[10]; /* plenty */ |
276 | const char *s; |
277 | struct vec *walk; |
278 | int n = 0; |
279 | |
280 | while (1) { |
281 | sprintf(tmp, "__%d", n); |
282 | s = unique(tmp); |
283 | for (walk = base->frame->vecs; walk; walk = walk->next) |
284 | if (walk->name == s) |
285 | break; |
286 | if (!walk) |
287 | break; |
288 | n++; |
289 | } |
290 | base->name = s; |
291 | } |
292 | |
293 | |
294 | static const char *base_name(struct vec *base, const struct vec *next) |
295 | { |
296 | if (!base) |
297 | return "@"; |
298 | if (next && base->next == next) |
299 | return "."; |
300 | if (!base->name) |
301 | generate_name(base); |
302 | return base->name; |
303 | } |
304 | |
305 | |
306 | static const char *obj_base_name(struct vec *base, const struct vec *prev) |
307 | { |
308 | if (base && base == prev) |
309 | return "."; |
310 | return base_name(base, NULL); |
311 | } |
312 | |
313 | |
314 | char *print_obj(const struct obj *obj, const struct vec *prev) |
315 | { |
316 | const char *base, *s1, *s3; |
317 | char *s, *s2; |
318 | |
319 | base = obj_base_name(obj->base, prev); |
320 | switch (obj->type) { |
321 | case ot_frame: |
322 | s = stralloc_printf("frame %s %s", |
323 | obj->u.frame.ref->name, base); |
324 | break; |
325 | case ot_line: |
326 | s1 = obj_base_name(obj->u.line.other, prev); |
327 | s2 = unparse(obj->u.line.width); |
328 | s = stralloc_printf("line %s %s %s", base, s1, s2); |
329 | free(s2); |
330 | break; |
331 | case ot_rect: |
332 | s1 = obj_base_name(obj->u.rect.other, prev); |
333 | s2 = unparse(obj->u.rect.width); |
334 | s = stralloc_printf("rect %s %s %s", base, s1, s2); |
335 | free(s2); |
336 | break; |
337 | case ot_pad: |
338 | s1 = obj_base_name(obj->u.pad.other, prev); |
339 | switch (obj->u.pad.type) { |
340 | case pt_normal: |
341 | s2 = ""; |
342 | break; |
343 | case pt_bare: |
344 | s2 = " bare"; |
345 | break; |
346 | case pt_paste: |
347 | s2 = " paste"; |
348 | break; |
349 | case pt_mask: |
350 | s2 = " mask"; |
351 | break; |
352 | default: |
353 | abort(); |
354 | } |
355 | s = stralloc_printf("%spad \"%s\" %s %s%s", |
356 | obj->u.pad.rounded ? "r" : "", |
357 | obj->u.pad.name, base, s1, s2); |
358 | break; |
359 | case ot_hole: |
360 | s1 = obj_base_name(obj->u.hole.other, prev); |
361 | s = stralloc_printf("hole %s %s", base, s1); |
362 | break; |
363 | case ot_arc: |
364 | s1 = obj_base_name(obj->u.arc.start, prev); |
365 | s2 = unparse(obj->u.arc.width); |
366 | if (obj->u.arc.start == obj->u.arc.end) { |
367 | s = stralloc_printf("circ %s %s %s", base, s1, s2); |
368 | } else { |
369 | s3 = obj_base_name(obj->u.arc.end, prev); |
370 | s = stralloc_printf("arc %s %s %s %s", |
371 | base, s1, s3, s2); |
372 | } |
373 | free(s2); |
374 | break; |
375 | default: |
376 | abort(); |
377 | } |
378 | return s; |
379 | } |
380 | |
381 | |
382 | /* ----- print measurement ------------------------------------------------- */ |
383 | |
384 | |
385 | static const char *meas_type_name[mt_n] = { |
386 | "meas", "measx", "measy", |
387 | "meas", "measx", "measy", |
388 | }; |
389 | |
390 | |
391 | |
392 | static char *print_meas_base(struct vec *base) |
393 | { |
394 | const char *name; |
395 | |
396 | name = base_name(base, NULL); |
397 | if (base->frame == root_frame) |
398 | return stralloc(name); |
399 | return stralloc_printf("%s.%s", base->frame->name, name); |
400 | } |
401 | |
402 | |
403 | char *print_meas(const struct obj *obj) |
404 | { |
405 | char *s, *t; |
406 | char *s1, *s2, *s3; |
407 | |
408 | assert(obj->type == ot_meas); |
409 | |
410 | s = stralloc_printf("%s ", meas_type_name[obj->u.meas.type]); |
411 | if (obj->u.meas.label) { |
412 | t = stralloc_printf("%s\"%s\" ", s, obj->u.meas.label); |
413 | free(s); |
414 | s = t; |
415 | } |
416 | s1 = print_meas_base(obj->base); |
417 | s2 = stralloc_printf(" %s ", |
418 | obj->u.meas.type < 3 ? obj->u.meas.inverted ? "<-" : "->" : |
419 | obj->u.meas.inverted ? "<<" : ">>"); |
420 | s3 = print_meas_base(obj->u.meas.high); |
421 | t = stralloc_printf("%s%s%s%s", s, s1, s2, s3); |
422 | free(s); |
423 | free(s1); |
424 | free(s2); |
425 | free(s3); |
426 | s = t; |
427 | |
428 | if (!obj->u.meas.offset) |
429 | return s; |
430 | |
431 | s1 = unparse(obj->u.meas.offset); |
432 | t = stralloc_printf("%s %s", s, s1); |
433 | free(s); |
434 | free(s1); |
435 | return t; |
436 | } |
437 | |
438 | |
439 | /* ----- print vector ------------------------------------------------------ */ |
440 | |
441 | |
442 | const char *print_label(struct vec *vec) |
443 | { |
444 | if (!vec->name) |
445 | generate_name(vec); |
446 | return vec->name; |
447 | } |
448 | |
449 | |
450 | char *print_vec(const struct vec *vec) |
451 | { |
452 | const char *base; |
453 | char *x, *y, *s; |
454 | |
455 | base = base_name(vec->base, vec); |
456 | x = unparse(vec->x); |
457 | y = unparse(vec->y); |
458 | if (vec->name) |
459 | s = stralloc_printf("vec %s(%s, %s)", base, x, y); |
460 | else { |
461 | s = stralloc_printf("vec %s(%s, %s)", base, x, y); |
462 | } |
463 | free(x); |
464 | free(y); |
465 | return s; |
466 | } |
467 | |
468 | |
469 | /* ----- frames ------------------------------------------------------------ */ |
470 | |
471 | |
472 | static void dump_frame(FILE *file, struct frame *frame, const char *indent) |
473 | { |
474 | const struct table *table; |
475 | const struct loop *loop; |
476 | struct obj *obj; |
477 | struct order *order; |
478 | const struct order *item; |
479 | char *s; |
480 | const char *s1; |
481 | |
482 | if (frame->dumped) |
483 | return; |
484 | frame->dumped = 1; |
485 | |
486 | for (obj = frame->objs; obj; obj = obj->next) |
487 | if (obj->type == ot_frame) |
488 | dump_frame(file, obj->u.frame.ref, "\t"); |
489 | |
490 | if (frame->name) |
491 | fprintf(file, "frame %s {\n", frame->name); |
492 | |
493 | for (table = frame->tables; table; table = table->next) |
494 | dump_table(file, table, indent); |
495 | for (loop = frame->loops; loop; loop = loop->next) |
496 | dump_loop(file, loop, indent); |
497 | |
498 | order = order_frame(frame); |
499 | for (item = order; item->vec || item->obj; item++) { |
500 | if (item->obj) { |
501 | fprintf(file, "%s", indent); |
502 | if (item->obj->name) |
503 | fprintf(file, "%s: ", item->obj->name); |
504 | s = print_obj(item->obj, item->vec); |
505 | fprintf(file, "%s\n", s); |
506 | } else { |
507 | s1 = print_label(item->vec); |
508 | s = print_vec(item->vec); |
509 | fprintf(file, "%s%s: %s\n", indent, s1, s); |
510 | } |
511 | free(s); |
512 | } |
513 | free(order); |
514 | |
515 | for (obj = frame->objs; obj; obj = obj->next) { |
516 | if (obj->dumped) |
517 | continue; |
518 | s = print_meas(obj); |
519 | fprintf(file, "%s%s\n", indent, s); |
520 | free(s); |
521 | } |
522 | |
523 | if (frame->name) |
524 | fprintf(file, "}\n\n"); |
525 | } |
526 | |
527 | |
528 | /* ----- file -------------------------------------------------------------- */ |
529 | |
530 | |
531 | static void dump_unit(FILE *file) |
532 | { |
533 | switch (curr_unit) { |
534 | case curr_unit_mm: |
535 | fprintf(file, "unit mm\n"); |
536 | break; |
537 | case curr_unit_mil: |
538 | fprintf(file, "unit mil\n"); |
539 | break; |
540 | case curr_unit_auto: |
541 | fprintf(file, "unit auto\n"); |
542 | break; |
543 | default: |
544 | abort(); |
545 | } |
546 | } |
547 | |
548 | |
549 | int dump(FILE *file) |
550 | { |
551 | struct frame *frame; |
552 | |
553 | fprintf(file, "%s\n", MACHINE_GENERATED); |
554 | for (frame = frames; frame; frame = frame->next) |
555 | frame->dumped = 0; |
556 | for (frame = frames; frame; frame = frame->next) { |
557 | if (!frame->name) { |
558 | fprintf(file, "package \"%s\"\n", pkg_name); |
559 | dump_unit(file); |
560 | dump_frame(file, frame, ""); |
561 | } else { |
562 | dump_frame(file, frame, "\t"); |
563 | } |
564 | } |
565 | fflush(file); |
566 | return !ferror(file); |
567 | } |
568 |
Branches:
master