Root/
Source at commit 190bcaf982869388b508a0a4c97cff62fbb73038 created 13 years 11 months ago. By werner, Added a topological sort algorithm, for use when dumping. | |
---|---|
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