1 /* ----------------------------------------------------------------- 2 FILE: custom.h 3 CONTENTS: definitions for globals structures and variables 4 file organized - defines, typedefs, globals. 5 DATE: Jan 29, 1988 6 REVISIONS: 7 Feb 13, 1988 - changed numBinsX & numBinsY -> maxBinX 8 and maxBinY. Also redefine LOCBOX to be termbox. 9 Feb 19, 1988 - changed aveChanWid to DOUBLE from int. 10 Oct 21, 1988 - remove Hweight and Vweight from DIMBOX. 11 Oct 26, 1988 - updated FIXEDBOX for neighborhoods. 12 changed PATHNETPTR to generic pointer and added 13 groupbox to cell data structure. 14 Dec 3, 1988 - added PSETPTR record for timing driven code 15 - add list of paths to cell record. 16 Jan 20, 1989 - added softPinArrayG for softcells. 17 Feb 26, 1989 - added G suffix for all global variables. 18 - changed SetBin to SETBIN so looks like macro. 19 - added CUSTOM_H compile switch. 20 Mar 01, 1989 - remove netctr variable. 21 - made iteration a global variable. 22 Mar 02, 1989 - moved start_overlap, end_overlap, etc. to 23 penalties.c 24 Mar 07, 1989 - added numinstancesG to list of cell info. 25 Mar 12, 1989 - added group_nested field to CELLBOX so 26 that groups can be hierarchical. 27 Mar 16, 1989 - rewrote entire netlist data structures. 28 Deleted unnecessary data structures. 29 Mar 30, 1989 - changed tile datastructure and MOVEBOX. 30 May 18, 1989 - added layer and HOWMANYORIENTs. 31 May 18, 1989 - removed extraneous variables. Added pad 32 control variables and defines. 33 Jul 19, 1989 - added numstdcellG global for avoiding work. 34 Oct 18, 1989 - removed pitch and track_spacing. Added 35 two wire factors - one for each direction. 36 Mar 28, 1990 - major rewrite of softcell code. 37 Apr 11, 1990 - changed group record. 38 Nov 23, 1990 - changed mean_cellAreaG and dev_cellareaG 39 to doubles. 40 Sun Dec 16 00:27:36 EST 1990 - modified to handle analog 41 information. 42 Thu Jan 17 00:45:41 PST 1991 - added numpins to VERTBOX. 43 Mon Feb 4 02:03:45 EST 1991 - added new definitions to 44 make a correct softpin placer. 45 Wed Feb 13 23:34:29 EST 1991 - rewrote pad code. 46 Sat Feb 23 00:19:51 EST 1991 - finalized pad data structure 47 to be like placepad algorithm. 48 Thu Apr 18 01:30:38 EDT 1991 - got rid of grid variables 49 now use library function. 50 Sun May 5 14:22:05 EDT 1991 - now user can set origin. 51 Mon May 6 02:34:54 EDT 1991 - added lo and hi pos to 52 make pin placement better. 53 Thu Aug 22 22:08:22 CDT 1991 - added unique_classG to fix 54 problem with fixed cells. 55 ----------------------------------------------------------------- */ 56 /* ***************************************************************** 57 "@(#) custom.h (Yale) version 3.15 8/22/91" 58 ***************************************************************** */ 59 #ifndef CUSTOM_H 60 #define CUSTOM_H 61 62 #include <main.h> 63 #include <analog.h> 64 65 #ifndef CUSTOM_DEFS 66 #define EXTERN extern 67 68 #else 69 #define EXTERN 70 #endif 71 72 /* ----------------------------------------------------------------- 73 DEFINE STATEMENTS FOR PLACEMENT STAGE 74 ----------------------------------------------------------------- */ 75 #define SETBINX(x) (( (TrybinG=((x)-binXOffstG)/binWidthXG)<0 ) ? 0 : \ 76 ((TrybinG>maxBinXG) ? maxBinXG : TrybinG )) 77 #define SETBINY(x) (( (TrybinG=((x)-binYOffstG)/binWidthYG)<0 ) ? 0 : \ 78 ((TrybinG>maxBinYG) ? maxBinYG : TrybinG )) 79 #define PICK_INT(l,u) (((l)<(u)) ? ((RAND % ((u)-(l)+1))+(l)) : (l)) 80 81 #define deltaX 2 82 #define deltaY 2 83 #define EXPCELLPERBIN 5 /* we expect no more than 5 cells in a bin */ 84 #define HOWMANYORIENT 8 85 86 /* control for pad spacing */ 87 #define UNIFORM_PADS 0 88 #define VARIABLE_PADS 1 89 #define ABUT_PADS 2 90 #define EXACT_PADS 3 91 92 /* ----------------------------------------------------------------- 93 STUCTURE AND TYPEDEFS FOR PLACEMENT STAGE 94 ----------------------------------------------------------------- */ 95 typedef struct glistbox { /* generic list */ 96 union { 97 INT net ; /* make code easier to read */ 98 INT path ; 99 INT cell ; 100 INT side ; 101 } p ; 102 struct glistbox *next ; 103 } GLISTBOX , *GLISTPTR ; 104 105 typedef struct movebox { 106 INT xcenter ; 107 INT ycenter ; 108 INT r ; 109 INT l ; 110 INT t ; 111 INT b ; 112 DOUBLE rw ; /* the tile weights */ 113 DOUBLE lw ; 114 DOUBLE tw ; 115 DOUBLE bw ; 116 INT binR ; 117 INT binL ; 118 INT binT ; 119 INT binB ; 120 INT cell ; 121 INT orient ; 122 INT numtiles ; 123 BOOL loaded_previously ; 124 } MOVEBOX, *MOVEBOXPTR ; 125 126 typedef struct eq_pinbox { /* for hard equiv pins and addequiv pins */ 127 char *pinname ; /* equivalent pin name */ 128 INT *restrict1 ; /* softpin is restricted to these sides */ 129 INT *txpos ; /* array of cell instance xpos. cell rel. */ 130 INT *typos ; /* array of cell instance ypos. cell rel. */ 131 INT layer ; /* layer of the equivalent pin */ 132 struct eq_pinbox *next; /* pointer to next equivalent pin */ 133 } EQUIVBOX, *EQUIVPTR ; 134 135 typedef struct sbox { 136 struct pinbox **children; /* array of the pin's children */ 137 struct pinbox *parent; /* pointer back to softpin pinbox */ 138 INT *restrict1 ; /* softpin is restricted to these sides */ 139 INT hierarchy ; /* type of pin root leaf, subroot etc */ 140 INT side ; /* current side of the softpin */ 141 BOOL permute ; /* true if rank ordered */ 142 BOOL ordered ; /* true if ordered in a group */ 143 BOOL fixed ; /* true if rank is fixed */ 144 INT lo_pos ; /* low valid position */ 145 INT hi_pos ; /* hi valid position */ 146 FLOAT lowerbound ; /* bounds of a pingroup */ 147 FLOAT upperbound ; /* upper bound of a pin group */ 148 } SOFTBOX, *SOFTBOXPTR ; 149 150 typedef struct pinbox { 151 struct pinbox *next ; /* next pin for this net */ 152 struct pinbox *nextpin ; /* next pin for this cell */ 153 SOFTBOXPTR softinfo ; /* soft pin info if appl. otherwise NULL */ 154 char *pinname ; /* pin record */ 155 INT pin ; /* global index of pin */ 156 INT net ; /* global index of net */ 157 INT cell ; /* global index of cell */ 158 INT xpos ; /* global x position */ 159 INT ypos ; /* global y position */ 160 INT instance ; /* current cell instance */ 161 INT txpos_new ; /* proposed cell relative position of pin */ 162 INT typos_new ; /* proposed cell relative position of pin */ 163 INT txpos ; /* current cell relative position of pin */ 164 INT typos ; /* current cell relative position of pin */ 165 INT *txpos_orig ; /* orig array of cell inst xpos. cell rel.*/ 166 INT *typos_orig ; /* orig array of cell inst ypos. cell rel.*/ 167 INT newx ; /* scratch for determining new global xpos*/ 168 INT newy ; /* scratch for determining new global ypos*/ 169 INT flag ; 170 INT skip ; 171 INT layer ; /* layer information */ 172 INT type ; /* softpin, hardpin, equiv pin */ 173 FLOAT *timing ; /* array of timing information for a pin */ 174 SOFTBOXPTR *soft_inst ; /* array of spin info if appl. o.w. NULL */ 175 EQUIVPTR eqptr ; /* list of equivalent pins */ 176 ANALOGPTR analog ; /* analog information if given */ 177 ANALOGPTR *ainst ; /* analog instance information */ 178 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 179 Note: For all pins t?pos_orig is what the user gave us. We need 180 to use original position to calculate new pin position for aspect 181 ratio moves for softcells and for outputing pin information to 182 global router for hard pins. T?pos is the current x and y 183 positions of the pin and for hard cells it is the average of all 184 the equivs for a pin and for softcells it is the current position 185 due to the current aspect ratio. For softcell, softinfo is valid 186 otherwise it is NULL. 187 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ 188 } *PINBOXPTR , PINBOX ; 189 190 typedef struct tilebox { 191 DOUBLE lweight ; 192 DOUBLE rweight ; 193 DOUBLE bweight ; 194 DOUBLE tweight ; 195 INT left ; /* current tile sides */ 196 INT right ; 197 INT bottom ; 198 INT top ; 199 INT orig_left ;/* original tile sides specified by user */ 200 INT orig_right ;/* for hard cell left = orig_left, that is */ 201 INT orig_bottom ;/* sides don't change throughout run. But for */ 202 INT orig_top ;/* soft cells use this to calculate current side*/ 203 struct tilebox *next ; /* next tile in list */ 204 } *TILEBOXPTR , TILEBOX ; 205 206 typedef struct psidebox { 207 INT length ; 208 DOUBLE pincount; 209 INT vertical ; 210 INT position ; 211 } PSIDEBOX ; 212 213 typedef struct { 214 INT r ; 215 INT l ; 216 INT t ; 217 INT b ; 218 } BOUNBOX, *BOUNBOXPTR ; 219 220 typedef struct { 221 INT *x ; /* the current positions of vertices */ 222 INT *x_orig ; /* the original positions of vertices */ 223 INT *x_new ; /* the proposed positions of the vertices */ 224 INT *y ; /* the current positions of vertices */ 225 INT *y_orig ; /* the original positions of vertices */ 226 INT *y_new ; /* the proposed positions of the vertices */ 227 FLOAT *numpins; /* number of pins on each side */ 228 } VERTBOX, *VERTBOXPTR ; 229 230 typedef struct { 231 INT fixedType ; /* POINT, NEIGHBORHOOD, GROUP, FIXEDGROUP */ 232 INT xcenter ; 233 INT ycenter ; 234 BOOL leftNotRight ; 235 BOOL bottomNotTop ; 236 INT xloc1 ; /* for fixing cell within a neighborhood */ 237 INT yloc1 ; /* remembers relative position to core */ 238 INT xloc2 ; 239 INT yloc2 ; 240 BOOL leftNotRight2 ; 241 BOOL bottomNotTop2 ; 242 INT x1, y1 ; /* global position */ 243 INT x2, y2 ; 244 INT xspan ; /* for speed of calculation */ 245 INT yspan ; 246 } FIXEDBOX, *FIXEDBOXPTR ; 247 248 typedef struct pad_rec { 249 INT cellnum ; /* index in carray */ 250 INT length ; 251 INT height ; 252 INT position ; /* linear placement position for a side */ 253 INT tiebreak ; /* ideal location to place the pad */ 254 INT *children ; /* added for pad code */ 255 INT padside ; /* current side */ 256 INT padtype ; /* type of pad - pad or padgroup */ 257 INT hierarchy ; /* type of pad - root, lead, pad, etc */ 258 INT lo_pos ; /* low valid position -1 if every valid */ 259 INT hi_pos ; /* hi valid position PINFINITY if valid */ 260 BOOL ordered ; /* whether a pad is ordered in a group */ 261 BOOL permute ; /* whether rank is to be enforced */ 262 BOOL fixed ; /* whether pad is fixed on a side */ 263 BOOL valid_side[5] ; /* valid side a pad may be placed */ 264 DOUBLE lowerbound ; 265 DOUBLE upperbound ; 266 } PADBOX, *PADBOXPTR ; 267 268 typedef struct { /* keeps track of group information */ 269 FIXEDBOXPTR fixed ; /* the groups neighborhood */ 270 GLISTPTR cells ; /* the cells of a group */ 271 } GROUPBOX, *GROUPBOXPTR ; 272 273 typedef struct { 274 char **name_inst ; /* array of names for each instance */ 275 INT numinstances ; /* number of instances for this cell */ 276 INT *numtile_inst ; /* number of tiles for each instance */ 277 INT *numsides ; /* array of number of sides for inst. */ 278 TILEBOXPTR *tile_inst ; /* array of tile lists for each inst */ 279 BOUNBOXPTR **bounBox ; /* the bbox in each view 0 each inst */ 280 VERTBOXPTR *vert_inst ; /* array of vertices of cell orient 0 */ 281 } INSTBOX, *INSTBOXPTR ; 282 283 typedef struct cellbox { 284 char *cname ; 285 INT cellnum ; 286 INT class ; 287 INT xcenter ; 288 INT ycenter ; 289 INT orientList[9] ; 290 INT orient ; 291 INT numpins ; /* number of pins for this cell */ 292 INT numtiles ; /* number of tiles in current instance */ 293 INT numsides ; /* number of sides for the current inst */ 294 INT cur_inst ; /* current instance of cell [0,numinst] */ 295 BOOL softflag ; /* TRUE if it is a soft cell */ 296 CELLTYPE celltype ; /* custom, soft , pad etc */ 297 GLISTPTR paths ; /* paths of a cell */ 298 GLISTPTR nets ; /* all the nets that a cell is on */ 299 FIXEDBOXPTR fixed ; /* cell can't move if non NULL */ 300 INSTBOXPTR instptr ; /* valid if cell has instances */ 301 PADBOXPTR padptr ; /* if pad - pad attributes */ 302 GROUPBOXPTR group ; /* whether cell belongs to a group */ 303 BOOL group_nested ; /* shows whether this cell is nested */ 304 DOUBLE orig_aspect ; /* original aspect ratio */ 305 DOUBLE aspect ; /* current aspect ratio */ 306 DOUBLE aspUB ; /* aspect ratio upper bound */ 307 DOUBLE aspLB ; /* aspect ration lower bound */ 308 TILEBOXPTR tiles ; /* current tiles of a cell-head of list */ 309 VERTBOXPTR vertices ; /* array of vertices of cell orient 0 */ 310 BOOL boun_valid ; /* boundary calc. - use delayed calc. */ 311 BOUNBOXPTR *bounBox ; /* the bounding box excluding routing */ 312 PINBOXPTR pinptr ; /* all the pins of a cell */ 313 PINBOXPTR *softpins ; /* all the pins including softpingroups */ 314 } *CELLBOXPTR , CELLBOX ; 315 316 typedef struct netbox { 317 char *nname ; /* net name */ 318 PINBOXPTR pins ; /* pins of this net */ 319 GLISTPTR paths ; /* paths which this net belongs */ 320 INT skip ; 321 INT xmin ; 322 INT newxmin ; 323 INT xmax ; 324 INT newxmax ; 325 INT ymin ; 326 INT nflag ; 327 INT newymin ; 328 INT ymax ; 329 INT newymax ; 330 INT numpins ; 331 INT Bnum ; /* no. of pins on the bottom edge of bb */ 332 INT Lnum ; /* no. of pins on the left edge of bb */ 333 INT Rnum ; /* no. of pins on the right edge of bb */ 334 INT Tnum ; /* no. of pins on the top edge of bb */ 335 INT newBnum ; /* no. of pins on the bottom edge of bb */ 336 INT newLnum ; /* no. of pins on the left edge of bb */ 337 INT newRnum ; /* no. of pins on the right edge of bb */ 338 INT newTnum ; /* no. of pins on the top edge of bb */ 339 INT newhalfPx ; /* new half perimeter bounding box for x */ 340 INT newhalfPy ; /* new half perimeter bounding box for y */ 341 INT halfPx ; /* current half perimeter bounding box for x */ 342 INT halfPy ; /* current half perimeter bounding box for y */ 343 FLOAT driveFactor ; /* driver strength of this net */ 344 FLOAT max_driver ; /* largest driver on this net */ 345 FLOAT min_driver ; /* smallest driver on this net */ 346 ANETPTR analog_info ; /* for analog nets */ 347 } *NETBOXPTR , NETBOX ; 348 349 typedef struct kbox { 350 INT cap ; 351 INT HV ; 352 INT sp ; 353 INT x ; 354 INT y ; 355 } KBOX , *KBOXPTR ; 356 357 typedef struct pathbox { 358 INT lo_path_len ; /* lower bound on the calculated half perim */ 359 INT hi_path_len ; /* upper bound on the calculated half perim */ 360 INT new_lo_path_len ; /* new low path */ 361 INT new_hi_path_len ; /* new upper path */ 362 INT priority ; 363 INT upper_bound ; 364 INT lower_bound ; 365 GLISTPTR nets ; 366 struct pathbox *next ; /* build a list first then array for speed */ 367 } PATHBOX , *PATHPTR ; 368 369 typedef struct binbox { 370 INT left ; 371 INT right ; 372 INT top ; 373 INT bottom ; 374 INT penalty ; 375 INT nupenalty ; 376 INT *cells ; /* array of cells in bin */ 377 INT space ; /* size of binbox->cells array */ 378 } BINBOX , 379 *BINBOXPTR ; 380 381 typedef struct psetrec { 382 INT member; /* integer for determining membership */ 383 INT path ; /* data */ 384 struct psetrec *next ; 385 } PSETBOX, *PSETPTR ; /* path set record */ 386 387 /* ---------------------------------------------------------- 388 The global variable definitions 389 ---------------------------------------------------------- */ 390 EXTERN CELLBOXPTR *cellarrayG ; 391 EXTERN CELLBOXPTR *activeCellarrayG ; /* cells that are active */ 392 EXTERN CELLBOXPTR *softPinArrayG ; /* softcells that have pins */ 393 EXTERN NETBOXPTR *netarrayG ; /* array of nets */ 394 EXTERN PATHPTR *patharrayG ; /* array of paths */ 395 EXTERN PINBOXPTR *termarrayG ; /* array of pins */ 396 EXTERN BINBOXPTR **binptrG ; /* overlap data structure */ 397 EXTERN INT **net_cap_matchG ; /* set of match nets */ 398 EXTERN INT **net_res_matchG ; /* set of match nets */ 399 400 /* ---------------------------------------------------------- 401 The global variable definitions for Jimmy's controller. 402 ---------------------------------------------------------- */ 403 EXTERN INT d_costG; 404 EXTERN DOUBLE init_accG; 405 EXTERN DOUBLE ratioG ; 406 407 408 /* ---------------------------------------------------------- 409 global definitions for overlap calculations 410 ---------------------------------------------------------- */ 411 /* move box array */ 412 EXTERN MOVEBOXPTR *old_aposG, *new_aposG, *old_bposG, *new_bposG ; 413 /* first element of move box array */ 414 EXTERN MOVEBOXPTR old_apos0G, new_apos0G, old_bpos0G, new_bpos0G ; 415 EXTERN BINBOXPTR newbptrG; /* *** bin cell ptr *** */ 416 EXTERN INT *newCellListG ; /* *** bin cell list *** */ 417 EXTERN INT TrybinG ; /* used in setBin calculations */ 418 419 /* ---------------------------------------------------------- 420 global definitions for configuration calculations 421 ---------------------------------------------------------- */ 422 EXTERN INT bdxlengthG , bdylengthG ; 423 EXTERN INT blocklG , blockrG , blocktG , blockbG ; 424 EXTERN INT blockmxG , blockmyG ; 425 EXTERN INT halfXspanG , halfYspanG ; 426 EXTERN DOUBLE chipaspectG ; 427 428 /* ---------------------------------------------------------- 429 cells are arranged in cellarray in the following fashion: 430 1. - core cells - custom and softcells 1..numcells. 431 1a.- core cells may have instances. so add numinstances to all below. 432 2. - super cells - numcells+1..numcells+numsupercells. 433 3. - pad cells - numcells+numsupercells+11.. 434 numcells+numsupercells+numpads. 435 4 - pad groups - numcells+numsupercells+numpads+1.. 436 numcells+numpads+numpadgroups 437 5. - padmacros - always four-for channel graph generator. see outgeo.c. 438 We have the following definitions to simplify region indexes: 439 endsuper = numcells + numsupercells + numinstances ; 440 endpads = numcells+numsupercells+numpads ; 441 endpadgrps = numcells+numsupercells+numpads+numpadgroups ; 442 totalcells = numcells+numsupercells+numpads+numpadgroups+NUMPADMACROS ; 443 ---------------------------------------------------------- */ 444 EXTERN INT numcellsG ; 445 EXTERN INT numpadsG ; 446 EXTERN INT totalpadsG ; 447 EXTERN INT numsoftG ; 448 EXTERN INT numstdcellG ; 449 EXTERN INT numpadgroupsG ; 450 EXTERN INT numinstancesG ; 451 EXTERN INT numsupercellsG ; 452 EXTERN INT numpathsG ; 453 EXTERN INT endpadsG ; 454 EXTERN INT endpadgrpsG ; 455 EXTERN INT endsuperG ; 456 EXTERN INT totalcellsG; 457 EXTERN INT activecellsG; /* number of active cells not fixed or merged */ 458 EXTERN INT numnetsG ; 459 EXTERN INT numpinsG ; 460 EXTERN INT maxBinXG ; 461 EXTERN INT maxBinYG ; 462 EXTERN INT binWidthXG ; 463 EXTERN INT binWidthYG ; 464 EXTERN INT binXOffstG ; 465 EXTERN INT binYOffstG ; 466 EXTERN INT maxWeightG ; 467 EXTERN INT baseWeightG; 468 EXTERN DOUBLE mean_cellAreaG ; 469 EXTERN DOUBLE dev_cellAreaG ; 470 EXTERN DOUBLE slopeXG ; 471 EXTERN DOUBLE slopeYG ; 472 EXTERN DOUBLE basefactorG; 473 EXTERN DOUBLE aveChanWidG; 474 EXTERN DOUBLE wireFactorXG; 475 EXTERN DOUBLE wireFactorYG; 476 477 /* ---------------------------------------------------------- 478 global definitions for cost function 479 ---------------------------------------------------------- */ 480 EXTERN INT penaltyG ; 481 EXTERN INT binpenalG ; 482 EXTERN INT funccostG ; 483 EXTERN INT offsetG ; 484 EXTERN INT timingcostG ; 485 EXTERN INT timingpenalG ; 486 EXTERN DOUBLE coreFactorG ; 487 EXTERN DOUBLE lapFactorG ; 488 EXTERN DOUBLE timeFactorG ; 489 EXTERN DOUBLE vertical_wire_weightG ; 490 EXTERN DOUBLE vertical_path_weightG ; 491 492 /* annealing stuff */ 493 EXTERN DOUBLE TG ; 494 EXTERN FILE *fpoG ; 495 EXTERN INT randVarG ; 496 EXTERN INT attmaxG ; 497 EXTERN INT iterationG ; 498 499 EXTERN DOUBLE pinsPerLenG ; 500 EXTERN INT layersFactorG ; 501 EXTERN INT unique_classG ; 502 503 /* ---------------------------------------------------------- 504 global definitions for calculated statistics 505 ---------------------------------------------------------- */ 506 EXTERN INT perimG ; 507 EXTERN INT totChanLenG ; 508 EXTERN INT totNetLenG ; 509 EXTERN DOUBLE aveCellSideG ; 510 EXTERN DOUBLE expandExtraG ; 511 512 EXTERN INT flipsG ; 513 EXTERN DOUBLE avg_funcG , avgsG ; 514 515 EXTERN INT iwireG, iwirexG , iwireyG , icostG ; 516 EXTERN INT fwireG, fwirexG , fwireyG , fcostG ; 517 518 /* control for pad code */ 519 EXTERN INT padspacingG ; /* may be UNIFORM, VARIABLE, or ABUT */ 520 EXTERN BOOL contiguousG ; 521 EXTERN BOOL external_pad_programG ; /* TRUE for calling placepads */ 522 EXTERN INT min_pad_spacingG ; 523 EXTERN INT coreG[2][2] ; 524 EXTERN INT perdimG[2] ; 525 EXTERN PADBOXPTR *padarrayG ; /* array of all the pads and padgroups */ 526 EXTERN PADBOXPTR *sortarrayG ; /* the sorted array of pads */ 527 EXTERN PADBOXPTR *placearrayG ; /* array where the pads will be placed */ 528 529 /* control gridding of cells */ 530 EXTERN BOOL gridGivenG ; 531 EXTERN BOOL gridCellsG ; 532 EXTERN BOOL coreGivenG ; 533 EXTERN INT x_originG, y_originG ; 534 535 536 #undef EXTERN 537 538 539 #endif /* CUSTOM_H */ 540