src/macro.h

   1 /*
   2  *                            COPYRIGHT
   3  *
   4  *  PCB, interactive printed circuit board design
   5  *  Copyright (C) 1994,1995,1996 Thomas Nau
   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  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  *
  21  *  Contact addresses for paper mail and Email:
  22  *  Thomas Nau, Schlehenweg 15, 88471 Baustetten, Germany
  23  *  Thomas.Nau@rz.uni-ulm.de
  24  *
  25  */
  26
  27 /* some commonly used macros not related to a special C-file
  28  * the file is included by global.h after const.h
  29  */
  30
  31 #ifndef PCB_MACRO_H
  32 #define PCB_MACRO_H
  33
  34 /* ---------------------------------------------------------------------------
  35  * macros to transform coord systems
  36  * draw.c uses a different definition of TO_SCREEN
  37  */
  38 #ifndef SWAP_IDENT
  39 #define SWAP_IDENT                      Settings.ShowBottomSide
  40 #endif
  41
  42 #define SWAP_SIGN_X(x)          (x)
  43 #define SWAP_SIGN_Y(y)          (-(y))
  44 #define SWAP_ANGLE(a)           (-(a))
  45 #define SWAP_DELTA(d)           (-(d))
  46 #define SWAP_X(x)               (SWAP_SIGN_X(x))
  47 #define SWAP_Y(y)               (PCB->MaxHeight +SWAP_SIGN_Y(y))
  48
  49 /* ---------------------------------------------------------------------------
  50  * misc macros, some might already be defined by <limits.h>
  51  */
  52 #ifndef MIN
  53 #define MIN(a,b)                ((a) < (b) ? (a) : (b))
  54 #define MAX(a,b)                ((a) > (b) ? (a) : (b))
  55 #endif
  56 #ifndef SGN
  57 #define SGN(a)                  ((a) >0 ? 1 : ((a) == 0 ? 0 : -1))
  58 #endif
  59 #define SGNZ(a)                 ((a) >=0 ? 1 : -1)
  60 #define MAKEMIN(a,b)            if ((b) < (a)) (a) = (b)
  61 #define MAKEMAX(a,b)            if ((b) > (a)) (a) = (b)
  62
  63 #define ENTRIES(x)              (sizeof((x))/sizeof((x)[0]))
  64 #define UNKNOWN(a)              ((a) && *(a) ? (a) : "(unknown)")
  65 #define UNKNOWN_NAME(a, n)      ((a) && *(a) ? (a) : (n))
  66 #define NSTRCMP(a, b)           ((a) ? ((b) ? strcmp((a),(b)) : 1) : -1)
  67 #define EMPTY(a)                ((a) ? (a) : "")
  68 #define EMPTY_STRING_P(a)       ((a) ? (a)[0]==0 : 1)
  69 #define XOR(a,b)                (((a) && !(b)) || (!(a) && (b)))
  70 #define SQUARE(x)               ((float) (x) * (float) (x))
  71 #define TO_RADIANS(degrees)     (M180 * (degrees))
  72
  73 /* ---------------------------------------------------------------------------
  74  * layer macros
  75  */
  76 #define LAYER_ON_STACK(n)       (&PCB->Data->Layer[LayerStack[(n)]])
  77 #define LAYER_PTR(n)            (&PCB->Data->Layer[(n)])
  78 #define CURRENT                 (PCB->SilkActive ? &PCB->Data->Layer[ \
  79                                 (Settings.ShowBottomSide ? bottom_silk_layer : top_silk_layer)] \
  80                                 : LAYER_ON_STACK(0))
  81 #define INDEXOFCURRENT          (PCB->SilkActive ? \
  82                                 (Settings.ShowBottomSide ? bottom_silk_layer : top_silk_layer) \
  83                                 : LayerStack[0])
  84 #define SILKLAYER               Layer[ \
  85                                 (Settings.ShowBottomSide ? bottom_silk_layer : top_silk_layer)]
  86 #define BACKSILKLAYER           Layer[ \
  87                                 (Settings.ShowBottomSide ? top_silk_layer : bottom_silk_layer)]
  88
  89 #define TEST_SILK_LAYER(layer)  (GetLayerNumber (PCB->Data, layer) >= max_copper_layer)
  90
  91
  92 /* ---------------------------------------------------------------------------
  93  * returns the object ID
  94  */
  95 #define OBJECT_ID(p)            (((AnyObjectType *) p)->ID)
  96
  97 /* ---------------------------------------------------------------------------
  98  * access macro for current buffer
  99  */
 100 #define PASTEBUFFER             (&Buffers[Settings.BufferNumber])
 101
 102 /* ---------------------------------------------------------------------------
 103  * some routines for flag setting, clearing, changing and testing
 104  */
 105 #define SET_FLAG(F,P)           ((P)->Flags.f |= (F))
 106 #define CLEAR_FLAG(F,P)         ((P)->Flags.f &= (~(F)))
 107 #define TEST_FLAG(F,P)          ((P)->Flags.f & (F) ? 1 : 0)
 108 #define TOGGLE_FLAG(F,P)        ((P)->Flags.f ^= (F))
 109 #define ASSIGN_FLAG(F,V,P)      ((P)->Flags.f = ((P)->Flags.f & (~(F))) | ((V) ? (F) : 0))
 110 #define TEST_FLAGS(F,P)         (((P)->Flags.f & (F)) == (F) ? 1 : 0)
 111
 112 #define FLAGS_EQUAL(F1,F2)      (memcmp (&F1, &F2, sizeof(FlagType)) == 0)
 113
 114 #define THERMFLAG(L)            (0xf << (4 *((L) % 2)))
 115
 116 #define TEST_THERM(L,P)         ((P)->Flags.t[(L)/2] & THERMFLAG(L) ? 1 : 0)
 117 #define GET_THERM(L,P)          (((P)->Flags.t[(L)/2] >> (4 * ((L) % 2))) & 0xf)
 118 #define CLEAR_THERM(L,P)        (P)->Flags.t[(L)/2] &= ~THERMFLAG(L)
 119 #define ASSIGN_THERM(L,V,P)     (P)->Flags.t[(L)/2] = ((P)->Flags.t[(L)/2] & ~THERMFLAG(L)) | ((V)  << (4 * ((L) % 2)))
 120
 121 extern int mem_any_set (unsigned char *, int);
 122 #define TEST_ANY_THERMS(P)      mem_any_set((P)->Flags.t, sizeof((P)->Flags.t))
 123
 124 /* ---------------------------------------------------------------------------
 125  * access macros for elements name structure
 126  */
 127 #define DESCRIPTION_INDEX       0
 128 #define NAMEONPCB_INDEX         1
 129 #define VALUE_INDEX             2
 130 #define NAME_INDEX(p)           (TEST_FLAG(NAMEONPCBFLAG,(p)) ? NAMEONPCB_INDEX :\
 131                                 (TEST_FLAG(DESCRIPTIONFLAG, (p)) ?              \
 132                                 DESCRIPTION_INDEX : VALUE_INDEX))
 133 #define ELEMENT_NAME(p,e)       ((e)->Name[NAME_INDEX((p))].TextString)
 134 #define DESCRIPTION_NAME(e)     ((e)->Name[DESCRIPTION_INDEX].TextString)
 135 #define NAMEONPCB_NAME(e)       ((e)->Name[NAMEONPCB_INDEX].TextString)
 136 #define VALUE_NAME(e)           ((e)->Name[VALUE_INDEX].TextString)
 137 #define ELEMENT_TEXT(p,e)       ((e)->Name[NAME_INDEX((p))])
 138 #define DESCRIPTION_TEXT(e)     ((e)->Name[DESCRIPTION_INDEX])
 139 #define NAMEONPCB_TEXT(e)       ((e)->Name[NAMEONPCB_INDEX])
 140 #define VALUE_TEXT(e)           ((e)->Name[VALUE_INDEX])
 141
 142 /* ---------------------------------------------------------------------------
 143  *  Determines if text is actually visible
 144  */
 145 #define TEXT_IS_VISIBLE(b, l, t) \
 146         ((l)->On)
 147
 148 /* ---------------------------------------------------------------------------
 149  *  Determines if object is on front or back
 150  */
 151 #define FRONT(o)        \
 152         ((TEST_FLAG(ONSOLDERFLAG, (o)) != 0) == SWAP_IDENT)
 153
 154 /* ---------------------------------------------------------------------------
 155  *  Determines if an object is on the given side. side is either BOTTOM_GROUP
 156  *  or TOP_GROUP.
 157  */
 158 #define ON_SIDE(element, side) \
 159         (TEST_FLAG (ONSOLDERFLAG, element) == (side == BOTTOM_SIDE))
 160
 161 /* ---------------------------------------------------------------------------
 162  * some loop shortcuts
 163  *
 164  * a pointer is created from index addressing because the base pointer
 165  * may change when new memory is allocated;
 166  *
 167  * all data is relativ to an objects name 'top' which can be either
 168  * PCB or PasteBuffer
 169  */
 170 #define END_LOOP  }} while (0)
 171
 172 #define STYLE_LOOP(top)  do {                                       \
 173         Cardinal n;                                                 \
 174         RouteStyleType *style;                                      \
 175         for (n = 0; n < NUM_STYLES; n++)                            \
 176         {                                                           \
 177                 style = &(top)->RouteStyle[n]
 178
 179 #define VIA_LOOP(top) do {                                          \
 180   GList *__iter, *__next;                                           \
 181   Cardinal n = 0;                                                   \
 182   for (__iter = (top)->Via, __next = g_list_next (__iter);          \
 183        __iter != NULL;                                              \
 184        __iter = __next, __next = g_list_next (__iter), n++) {       \
 185     PinType *via = __iter->data;
 186
 187 #define DRILL_LOOP(top) do             {               \
 188         Cardinal        n;                                      \
 189         DrillType *drill;                                       \
 190         for (n = 0; (top)->DrillN > 0 && n < (top)->DrillN; n++)                        \
 191         {                                                       \
 192                 drill = &(top)->Drill[n]
 193
 194 #define NETLIST_LOOP(top) do   {                         \
 195         Cardinal        n;                                      \
 196         NetListType *netlist;                                   \
 197         for (n = (top)->NetListN-1; n != -1; n--)               \
 198         {                                                       \
 199                 netlist = &(top)->NetList[n]
 200
 201 #define NET_LOOP(top) do   {                             \
 202         Cardinal        n;                                      \
 203         NetType *net;                                           \
 204         for (n = (top)->NetN-1; n != -1; n--)                   \
 205         {                                                       \
 206                 net = &(top)->Net[n]
 207
 208 #define CONNECTION_LOOP(net) do {                         \
 209         Cardinal        n;                                      \
 210         ConnectionType *connection;                             \
 211         for (n = (net)->ConnectionN-1; n != -1; n--)            \
 212         {                                                       \
 213                 connection = & (net)->Connection[n]
 214
 215 #define ELEMENT_LOOP(top) do {                                      \
 216   GList *__iter, *__next;                                           \
 217   Cardinal n = 0;                                                   \
 218   for (__iter = (top)->Element, __next = g_list_next (__iter);      \
 219        __iter != NULL;                                              \
 220        __iter = __next, __next = g_list_next (__iter), n++) {       \
 221     ElementType *element = __iter->data;
 222
 223 #define RAT_LOOP(top) do {                                          \
 224   GList *__iter, *__next;                                           \
 225   Cardinal n = 0;                                                   \
 226   for (__iter = (top)->Rat, __next = g_list_next (__iter);          \
 227        __iter != NULL;                                              \
 228        __iter = __next, __next = g_list_next (__iter), n++) {       \
 229     RatType *line = __iter->data;
 230
 231 #define ELEMENTTEXT_LOOP(element) do {  \
 232         Cardinal        n;                              \
 233         TextType *text;                                 \
 234         for (n = MAX_ELEMENTNAMES-1; n != -1; n--)      \
 235         {                                               \
 236                 text = &(element)->Name[n]
 237
 238
 239 #define ELEMENTNAME_LOOP(element) do    {                       \
 240         Cardinal        n;                                      \
 241         char            *textstring;                            \
 242         for (n = MAX_ELEMENTNAMES-1; n != -1; n--)              \
 243         {                                                       \
 244                 textstring = (element)->Name[n].TextString
 245
 246 #define PIN_LOOP(element) do {                                      \
 247   GList *__iter, *__next;                                           \
 248   Cardinal n = 0;                                                   \
 249   for (__iter = (element)->Pin, __next = g_list_next (__iter);      \
 250        __iter != NULL;                                              \
 251        __iter = __next, __next = g_list_next (__iter), n++) {       \
 252     PinType *pin = __iter->data;
 253
 254 #define PAD_LOOP(element) do {                                      \
 255   GList *__iter, *__next;                                           \
 256   Cardinal n = 0;                                                   \
 257   for (__iter = (element)->Pad, __next = g_list_next (__iter);      \
 258        __iter != NULL;                                              \
 259        __iter = __next, __next = g_list_next (__iter), n++) {       \
 260     PadType *pad = __iter->data;
 261
 262 #define ARC_LOOP(element) do {                                      \
 263   GList *__iter, *__next;                                           \
 264   Cardinal n = 0;                                                   \
 265   for (__iter = (element)->Arc, __next = g_list_next (__iter);      \
 266        __iter != NULL;                                              \
 267        __iter = __next, __next = g_list_next (__iter), n++) {       \
 268     ArcType *arc = __iter->data;
 269
 270 #define ELEMENTLINE_LOOP(element) do {                              \
 271   GList *__iter, *__next;                                           \
 272   Cardinal n = 0;                                                   \
 273   for (__iter = (element)->Line, __next = g_list_next (__iter);     \
 274        __iter != NULL;                                              \
 275        __iter = __next, __next = g_list_next (__iter), n++) {       \
 276     LineType *line = __iter->data;
 277
 278 #define ELEMENTARC_LOOP(element) do {                               \
 279   GList *__iter, *__next;                                           \
 280   Cardinal n = 0;                                                   \
 281   for (__iter = (element)->Arc, __next = g_list_next (__iter);      \
 282        __iter != NULL;                                              \
 283        __iter = __next, __next = g_list_next (__iter), n++) {       \
 284     ArcType *arc = __iter->data;
 285
 286 #define LINE_LOOP(layer) do {                                       \
 287   GList *__iter, *__next;                                           \
 288   Cardinal n = 0;                                                   \
 289   for (__iter = (layer)->Line, __next = g_list_next (__iter);       \
 290        __iter != NULL;                                              \
 291        __iter = __next, __next = g_list_next (__iter), n++) {       \
 292     LineType *line = __iter->data;
 293
 294 #define TEXT_LOOP(layer) do {                                       \
 295   GList *__iter, *__next;                                           \
 296   Cardinal n = 0;                                                   \
 297   for (__iter = (layer)->Text, __next = g_list_next (__iter);       \
 298        __iter != NULL;                                              \
 299        __iter = __next, __next = g_list_next (__iter), n++) {       \
 300     TextType *text = __iter->data;
 301
 302 #define POLYGON_LOOP(layer) do {                                    \
 303   GList *__iter, *__next;                                           \
 304   Cardinal n = 0;                                                   \
 305   for (__iter = (layer)->Polygon, __next = g_list_next (__iter);    \
 306        __iter != NULL;                                              \
 307        __iter = __next, __next = g_list_next (__iter), n++) {       \
 308     PolygonType *polygon = __iter->data;
 309
 310 #define POLYGONPOINT_LOOP(polygon) do   {       \
 311         Cardinal                        n;              \
 312         PointType *point;                               \
 313         for (n = (polygon)->PointN-1; n != -1; n--)     \
 314         {                                               \
 315                 point = &(polygon)->Points[n]
 316
 317 #define ENDALL_LOOP }} while (0); }} while(0)
 318
 319 #define ALLPIN_LOOP(top)        \
 320         ELEMENT_LOOP(top); \
 321                 PIN_LOOP(element)\
 322
 323 #define ALLPAD_LOOP(top) \
 324         ELEMENT_LOOP(top); \
 325           PAD_LOOP(element)
 326
 327 #define ALLLINE_LOOP(top) do    {               \
 328         Cardinal                l;                      \
 329         LayerType *layer = (top)->Layer;                \
 330         for (l = 0; l < max_copper_layer + 2; l++, layer++)     \
 331         { \
 332                 LINE_LOOP(layer)
 333
 334 #define ALLARC_LOOP(top) do {           \
 335         Cardinal                l;                      \
 336         LayerType *layer = (top)->Layer;                \
 337         for (l =0; l < max_copper_layer + 2; l++, layer++)              \
 338         { \
 339                 ARC_LOOP(layer)
 340
 341 #define ALLPOLYGON_LOOP(top)    do {            \
 342         Cardinal                l;                      \
 343         LayerType *layer = (top)->Layer;                \
 344         for (l = 0; l < max_copper_layer + 2; l++, layer++)     \
 345         { \
 346                 POLYGON_LOOP(layer)
 347
 348 #define COPPERLINE_LOOP(top) do {               \
 349         Cardinal                l;                      \
 350         LayerType *layer = (top)->Layer;                \
 351         for (l = 0; l < max_copper_layer; l++, layer++) \
 352         { \
 353                 LINE_LOOP(layer)
 354
 355 #define COPPERARC_LOOP(top) do  {               \
 356         Cardinal                l;                      \
 357         LayerType *layer = (top)->Layer;                \
 358         for (l =0; l < max_copper_layer; l++, layer++)          \
 359         { \
 360                 ARC_LOOP(layer)
 361
 362 #define COPPERPOLYGON_LOOP(top) do      {               \
 363         Cardinal                l;                      \
 364         LayerType *layer = (top)->Layer;                \
 365         for (l = 0; l < max_copper_layer; l++, layer++) \
 366         { \
 367                 POLYGON_LOOP(layer)
 368
 369 #define SILKLINE_LOOP(top) do   {               \
 370         Cardinal                l;                      \
 371         LayerType *layer = (top)->Layer;                \
 372         layer += max_copper_layer;                      \
 373         for (l = 0; l < 2; l++, layer++)                \
 374         { \
 375                 LINE_LOOP(layer)
 376
 377 #define SILKARC_LOOP(top) do    {               \
 378         Cardinal                l;                      \
 379         LayerType *layer = (top)->Layer;                \
 380         layer += max_copper_layer;                      \
 381         for (l = 0; l < 2; l++, layer++)                \
 382         { \
 383                 ARC_LOOP(layer)
 384
 385 #define SILKPOLYGON_LOOP(top) do        {               \
 386         Cardinal                l;                      \
 387         LayerType *layer = (top)->Layer;                \
 388         layer += max_copper_layer;                      \
 389         for (l = 0; l < 2; l++, layer++)                \
 390         { \
 391                 POLYGON_LOOP(layer)
 392
 393 #define ALLTEXT_LOOP(top)       do {            \
 394         Cardinal                l;                      \
 395         LayerType *layer = (top)->Layer;                \
 396         for (l = 0; l < max_copper_layer + 2; l++, layer++)     \
 397         { \
 398                 TEXT_LOOP(layer)
 399
 400 #define VISIBLELINE_LOOP(top) do        {               \
 401         Cardinal                l;                      \
 402         LayerType *layer = (top)->Layer;                \
 403         for (l = 0; l < max_copper_layer + 2; l++, layer++)     \
 404         { \
 405                 if (layer->On)                          \
 406                         LINE_LOOP(layer)
 407
 408 #define VISIBLEARC_LOOP(top) do {               \
 409         Cardinal                l;                      \
 410         LayerType *layer = (top)->Layer;                \
 411         for (l = 0; l < max_copper_layer + 2; l++, layer++)     \
 412         { \
 413                 if (layer->On)                          \
 414                         ARC_LOOP(layer)
 415
 416 #define VISIBLETEXT_LOOP(board) do      {               \
 417         Cardinal                l;                      \
 418         LayerType *layer = (board)->Data->Layer;                \
 419         for (l = 0; l < max_copper_layer + 2; l++, layer++)     \
 420         { \
 421                 TEXT_LOOP(layer);                                      \
 422                   if (TEXT_IS_VISIBLE((board), layer, text))
 423
 424 #define VISIBLEPOLYGON_LOOP(top) do     {       \
 425         Cardinal                l;                      \
 426         LayerType *layer = (top)->Layer;                \
 427         for (l = 0; l < max_copper_layer + 2; l++, layer++)     \
 428         { \
 429                 if (layer->On)                          \
 430                         POLYGON_LOOP(layer)
 431
 432 #define POINTER_LOOP(top) do    {       \
 433         Cardinal        n;                      \
 434         void    **ptr;                          \
 435         for (n = (top)->PtrN-1; n != -1; n--)   \
 436         {                                       \
 437                 ptr = &(top)->Ptr[n]
 438
 439 #define MENU_LOOP(top)  do {    \
 440         Cardinal        l;                      \
 441         LibraryMenuType *menu;                  \
 442         for (l = (top)->MenuN-1; l != -1; l--)  \
 443         {                                       \
 444                 menu = &(top)->Menu[l]
 445
 446 #define ENTRY_LOOP(top) do      {       \
 447         Cardinal        n;                      \
 448         LibraryEntryType *entry;                \
 449         for (n = (top)->EntryN-1; n != -1; n--) \
 450         {                                       \
 451                 entry = &(top)->Entry[n]
 452
 453 #define GROUP_LOOP(data, group) do {    \
 454         Cardinal entry; \
 455         for (entry = 0; entry < ((PCBType *)(data->pcb))->LayerGroups.Number[(group)]; entry++) \
 456         { \
 457                 LayerType *layer;               \
 458                 Cardinal number;                \
 459                 number = ((PCBType *)(data->pcb))->LayerGroups.Entries[(group)][entry]; \
 460                 if (number >= max_copper_layer) \
 461                   continue;                     \
 462                 layer = &data->Layer[number];
 463
 464 #define LAYER_LOOP(data, ml) do { \
 465         Cardinal n; \
 466         for (n = 0; n < ml; n++) \
 467         { \
 468            LayerType *layer = (&data->Layer[(n)]);
 469
 470
 471 #endif