← Back to branch summary

~ubuntu-branches/ubuntu/precise/pcb/precise

« back to all changes in this revision

Viewing changes to src/macro.h

  • Committer: Bazaar Package Importer
  • Author(s): Hamish Moffatt
  • Date: 2005-02-20 13:14:00 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20050220131400-pfz66g5vhx0azl8f
Tags: 1.99j+20050127-2
http://bugs.debian.org/295405
http://bugs.debian.org/295404
http://bugs.debian.org/269578
http://bugs.debian.org/294319
* Improved package description: (closes: #295405)
* Fixed dependency: tk84 -> tk8.4 (closes: #295404)
* Updated README.debian (closes: #269578)
* Applied patch to src/djopt.c to allow compilation with gcc-4.0
  (closes: #294319), thanks to Andreas Jochens for the patch.
* Prevent example files from being compressed

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/macro.h
22
22
 *  Thomas Nau, Schlehenweg 15, 88471 Baustetten, Germany
23
23
 *  Thomas.Nau@rz.uni-ulm.de
24
24
 *
25
 
 *  RCS: $Id: macro.h,v 1.6 1998/02/24 22:54:47 cad Exp $
 
25
 *  RCS: $Id: macro.h,v 1.16 2005/01/03 12:56:59 danmc Exp $
26
26
 */
27
27
 
28
28
/* some commonly used macros not related to a special C-file
51
51
#define SWAP_DELTA(d)           (-(d))
52
52
#define SWAP_X(x)               (SWAP_SIGN_X(x))
53
53
#define SWAP_Y(y)               (PCB->MaxHeight +SWAP_SIGN_Y(y))
 
54
#define SATURATE(x)             ((x) > 32767 ? 32767 : ((x) < -32767 ? -32767 : (x)))
54
55
 
55
56
#ifndef TO_SCREEN
56
 
#define TO_SCREEN(x)            ((PCB->Zoom < 0) ? (x) << -PCB->Zoom : (x) >> PCB->Zoom)
 
57
#define TO_SCREEN(x)            ((Position)((x)*Zoom_Multiplier))
57
58
#endif
58
59
 
59
 
#define TO_SCREEN_X(x)          (TO_SCREEN(SWAP_IDENT ? SWAP_X(x) : (x)) + Xorig)
60
 
#define TO_SCREEN_Y(y)          (TO_SCREEN(SWAP_IDENT ? SWAP_Y(y) : (y)) + Yorig)
61
 
#define TO_DRAW_X(x)            (TO_SCREEN(SWAP_IDENT ? SWAP_X(x) : (x)) + XORIG)
62
 
#define TO_DRAWABS_X(x)         (TO_SCREEN((x)) + XORIG)
63
 
#define TO_DRAW_Y(y)            (TO_SCREEN(SWAP_IDENT ? SWAP_Y(y) : (y)) + YORIG)
64
 
#define TO_DRAWABS_Y(y)         (TO_SCREEN((y)) + YORIG)
65
 
#define TO_MASK_X(x)            TO_SCREEN_X((x))
66
 
#define TO_MASK_Y(y)            TO_SCREEN_Y((y))
 
60
#define TO_SCREEN_X(x)          TO_SCREEN((SWAP_IDENT ? SWAP_X(x) : (x)) - Xorig)
 
61
#define TO_SCREEN_Y(y)          TO_SCREEN((SWAP_IDENT ? SWAP_Y(y)  : (y)) - Yorig)
 
62
#define TO_DRAW_X(x)            TO_SCREEN((SWAP_IDENT ? SWAP_X(x) : (x)) - XORIG)
 
63
#define TO_DRAWABS_X(x)         (TO_SCREEN((x) - XORIG))
 
64
#define TO_DRAW_Y(y)            TO_SCREEN((SWAP_IDENT ? SWAP_Y(y) : (y)) - YORIG)
 
65
#define TO_DRAWABS_Y(y)         (TO_SCREEN((y) - YORIG))
 
66
#define TO_LIMIT_X(x)           ((Position)(SATURATE(Local_Zoom * ((x) - XORIG))))
 
67
#define TO_LIMIT_Y(y)           ((Position)(SATURATE(Local_Zoom * \
 
68
                                ((SWAP_IDENT ? SWAP_Y(y) : (y)) - YORIG))))
67
69
#define TO_SCREEN_ANGLE(a)      (SWAP_IDENT ? SWAP_ANGLE((a)) : (a))
68
70
#define TO_SCREEN_DELTA(d)      (SWAP_IDENT ? SWAP_DELTA((d)) : (d))
69
71
#define TO_SCREEN_SIGN_X(x)     (SWAP_IDENT ? SWAP_SIGN_X(x) : (x))
70
72
#define TO_SCREEN_SIGN_Y(y)     (SWAP_IDENT ? SWAP_SIGN_Y(y) : (y))
71
73
 
72
74
#ifndef TO_PCB
73
 
#define TO_PCB(x)               ((PCB->Zoom < 0) ? (x) >> -PCB->Zoom : (x) << PCB->Zoom)
 
75
#define TO_PCB(x)               ((LocationType)((x)/Zoom_Multiplier))
74
76
#endif
75
 
#define TO_PCB_X(x)             TO_PCB(x - Xorig)
 
77
#define TO_PCB_X(x)             TO_PCB(x) + Xorig
76
78
#define TO_PCB_Y(y)             (SWAP_IDENT ? \
77
 
                                PCB->MaxHeight -TO_PCB(y - Yorig) : TO_PCB(y - Yorig))
 
79
                                PCB->MaxHeight - TO_PCB(y) - Yorig : TO_PCB(y) + Yorig)
78
80
 
79
81
/* ---------------------------------------------------------------------------
80
82
 * misc macros, some might already be defined by <limits.h>
84
86
#define MAX(a,b)                ((a) > (b) ? (a) : (b))
85
87
#endif
86
88
#ifndef SGN
87
 
#define SGN(a)                  ((a) >= 0 ? 1 : -1)
 
89
#define SGN(a)                  ((a) >0 ? 1 : ((a) == 0 ? 0 : -1))
88
90
#endif
 
91
#define SGNZ(a)                 ((a) >=0 ? 1 : -1)
 
92
#define MAKEMIN(a,b)            if ((b) < (a)) (a) = (b)
 
93
#define MAKEMAX(a,b)            if ((b) > (a)) (a) = (b)
89
94
 
90
95
#define ENTRIES(x)              (sizeof((x))/sizeof((x)[0]))
91
96
#define UNKNOWN(a)              ((a) && *(a) ? (a) : "(unknown)")
 
97
#define NSTRCMP(a, b)           ((a) ? ((b) ? strcmp((a),(b)) : 1) : -1)
92
98
#define EMPTY(a)                ((a) ? (a) : "")
93
99
#define XOR(a,b)                (((a) && !(b)) || (!(a) && (b)))
94
100
#define SQUARE(x)               ((float) (x) * (float) (x))
95
101
#define TO_RADIANS(degrees)     (M180 * (degrees))
96
 
 
 
102
 
97
103
/* ---------------------------------------------------------------------------
98
104
 * macros to determine if something is on the visible part of the screen
99
105
 */
110
116
        (t)->BoundingBox.X2 >= vxl && \
111
117
        (t)->BoundingBox.Y1 <= vyh && \
112
118
        (t)->BoundingBox.Y2 >= vyl)
113
 
#define VLINE(l)        ((((l)->Point2.X >= vxl && (l)->Point1.X <= vxh) || \
114
 
        ((l)->Point1.X >= vxl && (l)->Point2.X <= vxh)) && \
115
 
        ((((l)->Point2.Y >= vyl && (l)->Point1.Y <= vyh) || \
116
 
        ((l)->Point1.Y >= vyl && (l)->Point2.Y <= vyh))))
 
119
#define VLINE(l)        ((((l)->Point2.X >= vxl - (l)->Thickness && \
 
120
        (l)->Point1.X <= vxh + (l)->Thickness) || \
 
121
        ((l)->Point1.X >= vxl - (l)->Thickness && \
 
122
        (l)->Point2.X <= vxh + (l)->Thickness)) && \
 
123
        ((((l)->Point2.Y >= vyl - (l)->Thickness && \
 
124
        (l)->Point1.Y <= vyh + (l)->Thickness) || \
 
125
        ((l)->Point1.Y >= vyl - (l)->Thickness && \
 
126
        (l)->Point2.Y <= vyh + (l)->Thickness))))
117
127
#define VARC(a)         ((a)->BoundingBox.X1 <= vxh && \
118
128
        (a)->BoundingBox.X2 >= vxl && \
119
129
        (a)->BoundingBox.Y1 <= vyh && \
120
130
        (a)->BoundingBox.Y2 >= vyl)
121
 
#define VPOLY(p)        ((p)->BoundingBox.X1 <= vxh && \
 
131
#define VPOLY(p)        (IsRectangleInPolygon(vxl, vyl, vxh, vyh, (p)))
 
132
/* (p)->BoundingBox.X1 <= vxh && \
122
133
        (p)->BoundingBox.X2 >= vxl && \
123
134
        (p)->BoundingBox.Y1 <= vyh && \
124
135
        (p)->BoundingBox.Y2 >= vyl)
125
 
#define VVIA(v)         ((v)->X >= vxl && (v)->X <= vxh && \
126
 
                        (v)->Y >= vyl && (v)->Y <= vyh)
 
136
*/
 
137
#define VVIA(v)         ((v)->X+(v)->Thickness >= vxl && (v)->X - (v)->Thickness <= vxh && \
 
138
                        (v)->Y+(v)->Thickness >= vyl && (v)->Y - (v)->Thickness  <= vyh)
 
139
#define VTHERM(v)       ((v)->X + (v)->Thickness + (v)->Clearance >= vxl && \
 
140
                        (v)->X - (v)->Thickness - (v)->Clearance <= vxh && \
 
141
                        (v)->Y + (v)->Thickness + (v)->Thickness >= vyl && \
 
142
                        (v)->Y - (v)->Thickness - (v)->Clearance <= vyh)
127
143
 
128
144
/* ---------------------------------------------------------------------------
129
145
 * layer macros
130
146
 */
131
147
#define LAYER_ON_STACK(n)       (&PCB->Data->Layer[LayerStack[(n)]])
 
148
#define LAYER_PTR(n)            (&PCB->Data->Layer[(n)])
132
149
#define CURRENT                 (PCB->SilkActive ? &PCB->Data->Layer[MAX_LAYER + \
133
150
                                (Settings.ShowSolderSide ? SOLDER_LAYER : COMPONENT_LAYER)] \
134
151
                                : LAYER_ON_STACK(0))
135
152
#define INDEXOFCURRENT          (PCB->SilkActive ? MAX_LAYER + \
136
153
                                (Settings.ShowSolderSide ? SOLDER_LAYER : COMPONENT_LAYER) \
137
154
                                : LayerStack[0])
138
 
#define SILKLAYER               (&PCB->Data->Layer[MAX_LAYER + \
139
 
                                (Settings.ShowSolderSide ? SOLDER_LAYER : COMPONENT_LAYER)])
140
 
#define BACKSILKLAYER           (&PCB->Data->Layer[MAX_LAYER + \
141
 
                                (Settings.ShowSolderSide ? COMPONENT_LAYER : SOLDER_LAYER)])
 
155
#define SILKLAYER               Layer[MAX_LAYER + \
 
156
                                (Settings.ShowSolderSide ? SOLDER_LAYER : COMPONENT_LAYER)]
 
157
#define BACKSILKLAYER           Layer[MAX_LAYER + \
 
158
                                (Settings.ShowSolderSide ? COMPONENT_LAYER : SOLDER_LAYER)]
142
159
 
143
160
/* ---------------------------------------------------------------------------
144
161
 * returns the object ID
151
168
#define PASTEBUFFER             (&Buffers[Settings.BufferNumber])
152
169
 
153
170
/* ---------------------------------------------------------------------------
154
 
 * some routines for flag setting, clearing, changeing and testing
 
171
 * some routines for flag setting, clearing, changing and testing
155
172
 */
156
173
#define SET_FLAG(f,p)           ((p)->Flags |= (f))
157
174
#define CLEAR_FLAG(f,p)         ((p)->Flags &= (~(f)))
158
 
#define TEST_FLAG(f,p)          (((p)->Flags & (f)) ? True : False)
159
 
#define TOGGLE_FLAG(f,p)        ((p)->Flags = TEST_FLAG((f),(p)) ? (p)->Flags & (~(f)) : (p)->Flags | (f))
 
175
#define TEST_FLAG(f,p)          ((p)->Flags & (f) ? True : False)
 
176
#define TOGGLE_FLAG(f,p)        ((p)->Flags ^= (f))
160
177
#define ASSIGN_FLAG(f,v,p)      ((p)->Flags = ((p)->Flags & (~(f))) | ((v) ? (f) : 0))
 
178
#define TEST_FLAGS(f,p)         (((p)->Flags & (f)) == (f) ? True : False)
161
179
 
162
180
/* ---------------------------------------------------------------------------
163
181
 * access macros for elements name structure
207
225
 */
208
226
#define FRONT(o)        \
209
227
        ((TEST_FLAG(ONSOLDERFLAG, (o)) != 0) == SWAP_IDENT)
210
 
                        
 
228
 
211
229
/* ---------------------------------------------------------------------------
212
230
 * some loop shortcuts
213
231
 * all object loops run backwards to prevent from errors when deleting objects
218
236
 * all data is relativ to an objects name 'top' which can be either
219
237
 * PCB or PasteBuffer
220
238
 */
221
 
#define VIA_LOOP(top, command)  {               \
 
239
#define END_LOOP  }} while (0)
 
240
 
 
241
#define STYLE_LOOP(top)  do {           \
 
242
        Cardinal        n;                      \
 
243
        RouteStyleTypePtr       style;                  \
 
244
        for (n = 0; n < NUM_STYLES; n++)        \
 
245
        {                                       \
 
246
                style = &(top)->RouteStyle[n]
 
247
 
 
248
#define VIA_LOOP(top)   do {            \
222
249
        Cardinal        n, sn;                  \
223
250
        PinTypePtr      via;                    \
224
251
        for (sn = (top)->ViaN, n = 0; (top)->ViaN > 0 && n < (top)->ViaN ; \
225
252
                n += 1 + (top)->ViaN - sn, sn = (top)->ViaN)   \
226
253
        {                                       \
227
 
                via = &(top)->Via[n];           \
228
 
                command;                        \
229
 
        }}
 
254
                via = &(top)->Via[n]
230
255
 
231
 
#define DRILL_LOOP(top, command)              {               \
 
256
#define DRILL_LOOP(top) do             {               \
232
257
        Cardinal        n;                                      \
233
258
        DrillTypePtr    drill;                                  \
234
259
        for (n = 0; (top)->DrillN > 0 && n < (top)->DrillN; n++)                        \
235
260
        {                                                       \
236
 
                drill = &(top)->Drill[n];                       \
237
 
                command;                                        \
238
 
        }}      
239
 
 
240
 
#define NET_LOOP(top, command)    {                             \
 
261
                drill = &(top)->Drill[n]
 
262
 
 
263
#define NETLIST_LOOP(top) do   {                         \
 
264
        Cardinal        n;                                      \
 
265
        NetListTypePtr   netlist;                               \
 
266
        for (n = (top)->NetListN-1; n != -1; n--)               \
 
267
        {                                                       \
 
268
                netlist = &(top)->NetList[n]
 
269
 
 
270
#define NET_LOOP(top) do   {                             \
241
271
        Cardinal        n;                                      \
242
272
        NetTypePtr   net;                                       \
243
273
        for (n = (top)->NetN-1; n != -1; n--)                   \
244
274
        {                                                       \
245
 
                net = &(top)->Net[n];                           \
246
 
                command;                                        \
247
 
        }}      
 
275
                net = &(top)->Net[n]
248
276
 
249
 
#define CONNECTION_LOOP(net, command) {                         \
 
277
#define CONNECTION_LOOP(net) do {                         \
250
278
        Cardinal        n;                                      \
251
279
        ConnectionTypePtr       connection;                     \
252
280
        for (n = (net)->ConnectionN-1; n != -1; n--)            \
253
281
        {                                                       \
254
 
                connection = & (net)->Connection[n];            \
255
 
                command;                                        \
256
 
        }}
 
282
                connection = & (net)->Connection[n]
257
283
 
258
 
#define ELEMENT_LOOP(top, command)      {               \
 
284
#define ELEMENT_LOOP(top) do    {               \
259
285
        Cardinal                n;                      \
260
286
        ElementTypePtr  element;                        \
261
287
        for (n = (top)->ElementN-1; n != -1; n--)       \
262
288
        {                                               \
263
 
                element = &(top)->Element[n];           \
264
 
                command;                                \
265
 
        }}
 
289
                element = &(top)->Element[n]
266
290
 
267
 
#define RAT_LOOP(top, command)  {                       \
 
291
#define RAT_LOOP(top) do        {                       \
268
292
        Cardinal        n;                              \
269
293
        RatTypePtr      line;                           \
270
294
        for (n = (top)->RatN-1; n != -1; n--)           \
271
295
        {                                               \
272
 
                line = &(top)->Rat[n];                  \
273
 
                command;                                \
274
 
        }}
275
 
 
276
 
 
277
 
#define ELEMENTTEXT_LOOP(element, command)      {       \
 
296
                line = &(top)->Rat[n]
 
297
 
 
298
 
 
299
#define ELEMENTTEXT_LOOP(element) do {  \
278
300
        Cardinal        n;                              \
279
301
        TextTypePtr     text;                           \
280
302
        for (n = MAX_ELEMENTNAMES-1; n != -1; n--)      \
281
303
        {                                               \
282
 
                text = &(element)->Name[n];             \
283
 
                command;                                \
284
 
        }}
 
304
                text = &(element)->Name[n]
285
305
 
286
 
#define ELEMENTNAME_LOOP(element, command)      {               \
 
306
#define ELEMENTNAME_LOOP(element) do    {               \
287
307
        Cardinal        n;                                      \
288
308
        char            *textstring;                            \
289
309
        for (n = MAX_ELEMENTNAMES-1; n != -1; n--)              \
290
310
        {                                                       \
291
 
                textstring = (element)->Name[n].TextString;     \
292
 
                command;                                        \
293
 
        }}
 
311
                textstring = (element)->Name[n].TextString
294
312
 
295
 
#define PIN_LOOP(element, command)      {               \
 
313
#define PIN_LOOP(element)       do {            \
296
314
        Cardinal        n, sn;                          \
297
315
        PinTypePtr      pin;                            \
298
316
        for (sn = (element)->PinN, n = 0; (element)->PinN > 0 && n < (element)->PinN ; \
299
317
                n += 1 + (element)->PinN - sn, sn = (element)->PinN)   \
300
318
        {                                               \
301
 
                pin = &(element)->Pin[n];               \
302
 
                command;                                \
303
 
        }}
 
319
                pin = &(element)->Pin[n]
304
320
 
305
 
#define PAD_LOOP(element, command)      {               \
 
321
#define PAD_LOOP(element)       do {            \
306
322
        Cardinal        n, sn;                          \
307
323
        PadTypePtr      pad;                            \
308
324
        for (sn = (element)->PadN, n = 0; (element)->PadN > 0 && n < (element)->PadN ; \
309
325
                 sn == (element)->PadN ? n++ : 0)   \
310
326
        {                                               \
311
 
                pad = &(element)->Pad[n];               \
312
 
                command;                                \
313
 
        }}
 
327
                pad = &(element)->Pad[n]
314
328
 
315
 
#define ARC_LOOP(element, command)      {               \
 
329
#define ARC_LOOP(element)       do {            \
316
330
        Cardinal        n;                              \
317
331
        ArcTypePtr      arc;                            \
318
332
        for (n = (element)->ArcN-1; n != -1; n--)       \
319
333
        {                                               \
320
 
                arc = &(element)->Arc[n];               \
321
 
                command;                                \
322
 
        }}
 
334
                arc = &(element)->Arc[n]
323
335
 
324
 
#define ELEMENTLINE_LOOP(element, command)      {       \
 
336
#define ELEMENTLINE_LOOP(element)       do {    \
325
337
        Cardinal        n;                              \
326
338
        LineTypePtr     line;                           \
327
339
        for (n = (element)->LineN-1; n != -1; n--)      \
328
340
        {                                               \
329
 
                line = &(element)->Line[n];             \
330
 
                command;                                \
331
 
        }}
 
341
                line = &(element)->Line[n]
332
342
 
333
 
#define LINE_LOOP(layer, command) {                     \
 
343
#define LINE_LOOP(layer) do {                   \
334
344
        Cardinal                n;                      \
335
345
        LineTypePtr             line;                   \
336
346
        for (n = (layer)->LineN-1; n != -1; n--)        \
337
347
        {                                               \
338
 
                line = &(layer)->Line[n];               \
339
 
                command;                                \
340
 
        }}
 
348
                line = &(layer)->Line[n]
341
349
 
342
 
#define TEXT_LOOP(layer, command) {                     \
 
350
#define TEXT_LOOP(layer) do {                   \
343
351
        Cardinal                n;                      \
344
352
        TextTypePtr             text;                   \
345
353
        for (n = (layer)->TextN-1; n != -1; n--)        \
346
354
        {                                               \
347
 
                text = &(layer)->Text[n];               \
348
 
                command;                                \
349
 
        }}
 
355
                text = &(layer)->Text[n]
350
356
 
351
 
#define POLYGON_LOOP(layer, command) {                  \
 
357
#define POLYGON_LOOP(layer) do {                        \
352
358
        Cardinal                n;                      \
353
359
        PolygonTypePtr  polygon;                        \
354
360
        for (n = (layer)->PolygonN-1; n != -1; n--)     \
355
361
        {                                               \
356
 
                polygon = &(layer)->Polygon[n];         \
357
 
                command;                                \
358
 
        }}
 
362
                polygon = &(layer)->Polygon[n]
359
363
 
360
 
#define POLYGONPOINT_LOOP(polygon, command)     {       \
 
364
#define POLYGONPOINT_LOOP(polygon) do   {       \
361
365
        Cardinal                        n;              \
362
366
        PointTypePtr    point;                          \
363
367
        for (n = (polygon)->PointN-1; n != -1; n--)     \
364
368
        {                                               \
365
 
                point = &(polygon)->Points[n];          \
366
 
                command;                                \
367
 
        }}
368
 
 
369
 
#define ALLPIN_LOOP(top, command)       {                       \
370
 
        ELEMENT_LOOP((top), PIN_LOOP(element, command ))        \
371
 
        }
372
 
 
373
 
#define ALLPAD_LOOP(top, command)       {                       \
374
 
        ELEMENT_LOOP((top), PAD_LOOP(element, command ))        \
375
 
        }
376
 
 
377
 
#define ALLLINE_LOOP(top, command)      {               \
 
369
                point = &(polygon)->Points[n]
 
370
 
 
371
#define ENDALL_LOOP }} while (0);  }} while (0)
 
372
 
 
373
#define ALLPIN_LOOP(top)        \
 
374
        ELEMENT_LOOP(top); \
 
375
                PIN_LOOP(element)\
 
376
 
 
377
#define ALLPAD_LOOP(top) \
 
378
        ELEMENT_LOOP(top); \
 
379
          PAD_LOOP(element)
 
380
 
 
381
#define ALLLINE_LOOP(top) do    {               \
378
382
        Cardinal                l;                      \
379
383
        LayerTypePtr    layer = (top)->Layer;           \
380
384
        for (l = 0; l < MAX_LAYER + 2; l++, layer++)    \
381
 
                LINE_LOOP(layer, command );             \
382
 
        }
 
385
        { \
 
386
                LINE_LOOP(layer)
383
387
 
384
 
#define ALLARC_LOOP(top, command)       {               \
 
388
#define ALLARC_LOOP(top) do {           \
385
389
        Cardinal                l;                      \
386
390
        LayerTypePtr    layer = (top)->Layer;           \
387
391
        for (l =0; l < MAX_LAYER + 2; l++, layer++)             \
388
 
                ARC_LOOP(layer, command );              \
389
 
        }
 
392
        { \
 
393
                ARC_LOOP(layer)
390
394
 
391
 
#define ALLPOLYGON_LOOP(top, command)   {               \
 
395
#define ALLPOLYGON_LOOP(top)    do {            \
392
396
        Cardinal                l;                      \
393
397
        LayerTypePtr    layer = (top)->Layer;           \
394
398
        for (l = 0; l < MAX_LAYER + 2; l++, layer++)    \
395
 
                POLYGON_LOOP(layer, command );          \
396
 
        }
 
399
        { \
 
400
                POLYGON_LOOP(layer)
397
401
 
398
 
#define COPPERLINE_LOOP(top, command)   {               \
 
402
#define COPPERLINE_LOOP(top) do {               \
399
403
        Cardinal                l;                      \
400
404
        LayerTypePtr    layer = (top)->Layer;           \
401
405
        for (l = 0; l < MAX_LAYER; l++, layer++)        \
402
 
                LINE_LOOP(layer, command );             \
403
 
        }
 
406
        { \
 
407
                LINE_LOOP(layer)
404
408
 
405
 
#define COPPERARC_LOOP(top, command)    {               \
 
409
#define COPPERARC_LOOP(top) do  {               \
406
410
        Cardinal                l;                      \
407
411
        LayerTypePtr    layer = (top)->Layer;           \
408
412
        for (l =0; l < MAX_LAYER; l++, layer++)         \
409
 
                ARC_LOOP(layer, command );              \
410
 
        }
 
413
        { \
 
414
                ARC_LOOP(layer)
411
415
 
412
 
#define COPPERPOLYGON_LOOP(top, command)        {               \
 
416
#define COPPERPOLYGON_LOOP(top) do      {               \
413
417
        Cardinal                l;                      \
414
418
        LayerTypePtr    layer = (top)->Layer;           \
415
419
        for (l = 0; l < MAX_LAYER; l++, layer++)        \
416
 
                POLYGON_LOOP(layer, command );          \
417
 
        }
418
 
 
419
 
#define ALLTEXT_LOOP(top, command)      {               \
420
 
        Cardinal                l;                      \
421
 
        LayerTypePtr    layer = (top)->Layer;           \
422
 
        for (l = 0; l < MAX_LAYER + 2; l++, layer++)    \
423
 
                TEXT_LOOP(layer, command );             \
424
 
        }
425
 
 
426
 
#define VISIBLELINE_LOOP(top, command)  {               \
427
 
        Cardinal                l;                      \
428
 
        LayerTypePtr    layer = (top)->Layer;           \
429
 
        for (l = 0; l < MAX_LAYER + 2; l++, layer++)    \
430
 
                if (layer->On)                          \
431
 
                        LINE_LOOP(layer, command );     \
432
 
        }
433
 
 
434
 
#define VISIBLEARC_LOOP(top, command)   {               \
435
 
        Cardinal                l;                      \
436
 
        LayerTypePtr    layer = (top)->Layer;           \
437
 
        for (l = 0; l < MAX_LAYER + 2; l++, layer++)    \
438
 
                if (layer->On)                          \
439
 
                        ARC_LOOP(layer, command );      \
440
 
        }
441
 
 
442
 
#define VISIBLETEXT_LOOP(board, command)        {               \
 
420
        { \
 
421
                POLYGON_LOOP(layer)
 
422
 
 
423
#define SILKLINE_LOOP(top) do   {               \
 
424
        Cardinal                l;                      \
 
425
        LayerTypePtr    layer = (top)->Layer;           \
 
426
        layer += MAX_LAYER;                             \
 
427
        for (l = 0; l < 2; l++, layer++)                \
 
428
        { \
 
429
                LINE_LOOP(layer)
 
430
 
 
431
#define SILKARC_LOOP(top) do    {               \
 
432
        Cardinal                l;                      \
 
433
        LayerTypePtr    layer = (top)->Layer;           \
 
434
        layer += MAX_LAYER;                             \
 
435
        for (l = 0; l < 2; l++, layer++)                \
 
436
        { \
 
437
                ARC_LOOP(layer)
 
438
 
 
439
#define SILKPOLYGON_LOOP(top) do        {               \
 
440
        Cardinal                l;                      \
 
441
        LayerTypePtr    layer = (top)->Layer;           \
 
442
        layer += MAX_LAYER;                             \
 
443
        for (l = 0; l < 2; l++, layer++)                \
 
444
        { \
 
445
                POLYGON_LOOP(layer)
 
446
 
 
447
#define ALLTEXT_LOOP(top)       do {            \
 
448
        Cardinal                l;                      \
 
449
        LayerTypePtr    layer = (top)->Layer;           \
 
450
        for (l = 0; l < MAX_LAYER + 2; l++, layer++)    \
 
451
        { \
 
452
                TEXT_LOOP(layer)
 
453
 
 
454
#define VISIBLELINE_LOOP(top) do        {               \
 
455
        Cardinal                l;                      \
 
456
        LayerTypePtr    layer = (top)->Layer;           \
 
457
        for (l = 0; l < MAX_LAYER + 2; l++, layer++)    \
 
458
        { \
 
459
                if (layer->On)                          \
 
460
                        LINE_LOOP(layer)
 
461
 
 
462
#define VISIBLEARC_LOOP(top) do {               \
 
463
        Cardinal                l;                      \
 
464
        LayerTypePtr    layer = (top)->Layer;           \
 
465
        for (l = 0; l < MAX_LAYER + 2; l++, layer++)    \
 
466
        { \
 
467
                if (layer->On)                          \
 
468
                        ARC_LOOP(layer)
 
469
 
 
470
#define VISIBLETEXT_LOOP(board) do      {               \
443
471
        Cardinal                l;                      \
444
472
        LayerTypePtr    layer = (board)->Data->Layer;           \
445
473
        for (l = 0; l < MAX_LAYER + 2; l++, layer++)    \
446
 
                TEXT_LOOP(layer,                                        \
447
 
                          if (TEXT_IS_VISIBLE((board), layer, text))                      \
448
 
                          command );                              \
449
 
        }
 
474
        { \
 
475
                TEXT_LOOP(layer);                                      \
 
476
                  if (TEXT_IS_VISIBLE((board), layer, text))
450
477
 
451
 
#define VISIBLEPOLYGON_LOOP(top, command)       {       \
 
478
#define VISIBLEPOLYGON_LOOP(top) do     {       \
452
479
        Cardinal                l;                      \
453
480
        LayerTypePtr    layer = (top)->Layer;           \
454
481
        for (l = 0; l < MAX_LAYER + 2; l++, layer++)    \
 
482
        { \
455
483
                if (layer->On)                          \
456
 
                        POLYGON_LOOP(layer, command );  \
457
 
        }
 
484
                        POLYGON_LOOP(layer)
458
485
 
459
 
#define POINTER_LOOP(top, command)      {       \
 
486
#define POINTER_LOOP(top) do    {       \
460
487
        Cardinal        n;                      \
461
488
        void    **ptr;                          \
462
489
        for (n = (top)->PtrN-1; n != -1; n--)   \
463
490
        {                                       \
464
 
                ptr = &(top)->Ptr[n];           \
465
 
                command;                        \
466
 
        }}
 
491
                ptr = &(top)->Ptr[n]
467
492
 
468
 
#define MENU_LOOP(top, command) {       \
 
493
#define MENU_LOOP(top)  do {    \
469
494
        Cardinal        l;                      \
470
495
        LibraryMenuTypePtr menu;                \
471
496
        for (l = (top)->MenuN-1; l != -1; l--)  \
472
497
        {                                       \
473
 
                menu = &(top)->Menu[l];         \
474
 
                command;                        \
475
 
        }}
 
498
                menu = &(top)->Menu[l]
476
499
 
477
 
#define ENTRY_LOOP(top, command)        {       \
 
500
#define ENTRY_LOOP(top) do      {       \
478
501
        Cardinal        n;                      \
479
502
        LibraryEntryTypePtr entry;              \
480
503
        for (n = (top)->EntryN-1; n != -1; n--) \
481
504
        {                                       \
482
 
                entry = &(top)->Entry[n];       \
483
 
                command;                        \
484
 
        }}
 
505
                entry = &(top)->Entry[n]
 
506
 
 
507
#define GROUP_LOOP(group) do {  \
 
508
        Cardinal entry; \
 
509
        for (entry = 0; entry < PCB->LayerGroups.Number[(group)]; entry++) \
 
510
        { \
 
511
                LayerTypePtr layer;             \
 
512
                Cardinal number;                \
 
513
                number = PCB->LayerGroups.Entries[(group)][entry]; \
 
514
                if (number >= MAX_LAYER)        \
 
515
                  continue;                     \
 
516
                layer = LAYER_PTR (number)
485
517
#endif
486