home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1993 #3 / NN_1993_3.iso / spool / gnu / g / bug / 2329 < prev    next >
Encoding:
Text File  |  1993-01-25  |  21.8 KB  |  842 lines
  1. Path: sparky!uunet!zaphod.mps.ohio-state.edu!pacific.mps.ohio-state.edu!cis.ohio-state.edu!ecs.ox.ac.UK!u90jl
  2. From: u90jl@ecs.ox.ac.UK
  3. Newsgroups: gnu.g++.bug
  4. Subject: Internal error: <built-in>:0: crosses initialization of `__FUNCTION__'
  5. Date: 25 Jan 1993 21:01:46 -0500
  6. Organization: GNUs Not Usenet
  7. Lines: 829
  8. Sender: daemon@cis.ohio-state.edu
  9. Approved: bug-g++@prep.ai.mit.edu
  10. Distribution: gnu
  11. Message-ID: <9301251321.AA00651@booth2.ecs.ox.ac.uk>
  12.  
  13. I'm on a SparcStation SLC, SunOS4.1.1 running GCC 2.3.3.
  14.  
  15. First, a trivial point.  The option `-x c++-cpp-output' isn't documented
  16. in the info that comes with gcc-2.3.3.  Perhaps it should be?
  17.  
  18. Second, a compiler bug:
  19.  
  20. $ gcc -v -x c++-cpp-output -Wall -c -o region.o region.pp
  21.  
  22. Produces:
  23.  
  24. gcc version 2.3.3
  25.  /mclab/u90jl/gnu/lib/gcc-lib/sparc-sun-sunos4.1.1/2.3.3/cc1plus region.pp -quiet -Wall -version -o /usr/tmp/cca00645.s
  26. GNU C++ version 2.3.3 (sparc) compiled by GNU C version 2.3.3.
  27. region.cpp: In function `static class Region::RegionNode* Region::ROP_subtract (class Region::RegionPair*, class Region::RegionPair*, class Region::RegionNode*, int &, int &)':
  28. region.cpp:1750: label `A_and_B' used but not defined
  29. <built-in>:0: crosses initialization of `__PRETTY_FUNCTION__'
  30. <built-in>:0: crosses initialization of `__FUNCTION__'
  31. region.cpp:1825: Internal compiler error.
  32. region.cpp:1825: Please report this to `bug-g++@prep.ai.mit.edu'.
  33.  
  34. If I correct the reference to the label `A_and_B', by changing it to
  35. `A_not_B', the compiler does not crash.
  36.  
  37. Preprocessed source follows (blank lines removed).
  38. --
  39. Jamie Lokier
  40. -------------------------------------------------------------------------------
  41. # 1 "region.cpp"
  42.   #pragma implementation "Point.h"
  43.   #pragma implementation "Rectangle.h"
  44.   #pragma implementation "Region.h"
  45.   #pragma implementation "RegionIterator.h"
  46. # 1 "config.h" 1
  47. # 126 "config.h"
  48. # 199 "config.h"
  49. # 218 "config.h"
  50. # 29 "region.cpp" 2
  51. # 1 "Point.h" 1
  52.   #pragma interface
  53. class Point {
  54.   public:
  55.     int x, y;
  56.     inline Point() {}
  57.     inline Point(const Point& A) : x(A.x), y(A.y) {}
  58.     inline Point(int xnew, int ynew) : x(xnew), y(ynew) {}
  59.     inline Point& operator = (const Point A) { x=A.x; y=A.y; return *this; }
  60.     inline Point operator + (Point B) const { return Point(x+B.x, y+B.y); }
  61.     inline Point operator - (Point B) const { return Point(x-B.x, y-B.y); }
  62.     inline Point& operator += (Point B) { x+=B.x; y+=B.y; return *this; }
  63.     inline Point& operator -= (Point B) { x-=B.x; y-=B.y; return *this; }
  64.     inline int operator <= (Point B) const { return (x<=B.x) && (y<=B.y); }
  65.     inline int operator < (Point B) const { return (x<B.x) && (y<B.y); }
  66.     inline int operator == (Point B) const { return (x==B.x) && (y==B.y); }
  67.     inline int operator != (Point B) const { return (x!=B.x) || (y!=B.y); }
  68. };
  69. # 33 "region.cpp" 2
  70. # 1 "Rectangle.h" 1
  71.   #pragma interface
  72. class Rectangle {
  73.   public:
  74.     Point topLeft, bottomRight;
  75.     inline Rectangle() {}
  76.     inline Rectangle(const Rectangle& A)
  77.         : topLeft(A.topLeft), bottomRight(A.bottomRight) {}
  78.     inline Rectangle(Point tl, Point br)
  79.         : topLeft(tl), bottomRight(br) {};
  80.     inline Rectangle(int left, int top, int right, int bottom)
  81.         : topLeft(left, top), bottomRight(right, bottom) {}
  82.     inline Rectangle& operator = (const Rectangle& A)
  83.         { topLeft=A.topLeft; bottomRight=A.bottomRight; return *this; }
  84.     inline int contains(Point A) const
  85.         { return topLeft <= A && A < bottomRight; }
  86.     inline void translate(Point A) { topLeft+=A; bottomRight+=A; }
  87. };
  88. # 37 "region.cpp" 2
  89. # 1 "Region.h" 1
  90.   #pragma interface
  91. # 1 "/mclab/u90jl/gnu/lib/g++-include/stdlib.h" 1 3
  92. # 1 "/mclab/u90jl/gnu/lib/g++-include/stddef.h" 1 3
  93. extern "C" {
  94. # 1 "/mclab/u90jl/gnu/lib/gcc-lib/sparc-sun-sunos4.1.1/2.3.3/include/stddef.h" 1 3
  95. # 43 "/mclab/u90jl/gnu/lib/gcc-lib/sparc-sun-sunos4.1.1/2.3.3/include/stddef.h" 3
  96. typedef int ptrdiff_t;
  97. typedef int size_t;
  98. typedef __wchar_t wchar_t;
  99. # 179 "/mclab/u90jl/gnu/lib/gcc-lib/sparc-sun-sunos4.1.1/2.3.3/include/stddef.h" 3
  100. # 7 "/mclab/u90jl/gnu/lib/g++-include/stddef.h" 2 3
  101. }
  102. # 6 "/mclab/u90jl/gnu/lib/g++-include/stdlib.h" 2 3
  103. extern "C" {
  104. int       abs(int);
  105. void volatile abort(void);
  106. double    atof(const char*);
  107. int       atoi(const char*);
  108. long      atol(const char*);
  109. int       atexit(auto void (*p) (void));
  110. int       bsearch (const void *, const void *, size_t, 
  111.                    size_t, auto int (*ptf)(const void*, const void*));
  112. void*     calloc(size_t, size_t);
  113. void      cfree(void*);
  114. void volatile exit(int);
  115. char*     fcvt(double, int, int*, int*);
  116. void      free(void*);
  117. char*     getenv(const char*);
  118. int       getopt(int, char * const *, const char*);
  119. int       getpw(int, char*);
  120. char*     gcvt(double, int, char*);
  121. char*     ecvt(double, int, int*, int*);
  122. extern char**   environ;
  123. long      labs(long);
  124. void*     malloc(size_t);
  125. size_t    malloc_usable_size(void*);
  126. int       putenv(const char*);
  127. extern char*    optarg;
  128. extern int      opterr;
  129. extern int      optind;
  130. void      qsort(void*, size_t, size_t, auto int (*ptf)(void*,void*));
  131. int       rand(void);
  132. void*     realloc(void*, size_t);
  133. int       setkey(const char*);
  134. int       srand(unsigned int);
  135. double    strtod(const char*, char**);
  136. long      strtol(const char*, char**, int);
  137. unsigned long stroul(const char**, int);
  138. int       system(const char*);
  139. long      random(void);
  140. void      srandom(int);
  141. char*     setstate(char*);
  142. char*     initstate(unsigned, char*, int);
  143. double    drand48(void);
  144. void      lcong48(short*);
  145. long      jrand48(short*);
  146. long      lrand48(void);
  147. long      mrand48(void);
  148. long      nrand48(short*);
  149. short*    seed48(short*);
  150. void      srand48(long);
  151. char*     ctermid(char*);
  152. char*     cuserid(char*);
  153. char*     tempnam(const char*, const char*);
  154. char*     tmpnam(char*);
  155. }
  156. # 29 "Region.h" 2
  157. class RegionIterator;
  158. class Region {
  159.     class RegionPair;
  160.     class RegionRow;
  161.     class RegionNode;
  162.     class Initialiser;
  163.     class RegionPair {
  164.     friend Region;
  165.     friend RegionIterator;
  166.     friend Region::Initialiser;
  167.     enum { BlockSize = 20 };  
  168.     static RegionPair *freeList;
  169.       public:
  170.     static void allocateBlock(RegionPair *);
  171.       private:
  172.     static void *operator new (size_t)
  173.     {
  174.         register Region::RegionPair *nodE=freeList;
  175.         if (!(freeList=nodE->tail))
  176.         allocateBlock(nodE);
  177.         return (nodE);
  178.     }
  179.     static void operator delete (void *node)
  180.     {
  181.         ((Region::RegionPair *)node)->tail=freeList;
  182.         freeList=(Region::RegionPair *)node;
  183.     }
  184.     static RegionPair *peek()
  185.     {
  186.         return freeList;
  187.     }
  188.     RegionPair *tail;       
  189.     int left, right;        
  190.     };
  191.     class RegionRow {
  192.     friend Region;
  193.     friend RegionIterator;
  194.     enum { BlockSize = 20 };  
  195.     static RegionRow *freeList;
  196.     static RegionRow *allocateBlock();
  197.     static void *operator new (size_t)
  198.     {
  199.         if (!freeList)
  200.         return allocateBlock();
  201.         register Region::RegionRow *nodE=freeList;
  202.         freeList=nodE->tail; return (nodE);
  203.     }
  204.     static void operator delete (void *node)
  205.     {
  206.         ((Region::RegionRow *)node)->tail=freeList;
  207.         freeList=(Region::RegionRow *)node;
  208.     }
  209.     union {
  210.         RegionPair *pair; 
  211.         RegionRow *tail;     
  212.     };
  213.     unsigned int ref;        
  214.     int right;               
  215.     };
  216.     class RegionNode {
  217.     friend Region;
  218.     friend RegionIterator;
  219.     friend Region::Initialiser;
  220.     enum { BlockSize = 20 };  
  221.     static RegionNode *freeList;
  222.       public:
  223.     static void allocateBlock(RegionNode *);
  224.       private:
  225.     void *operator new (size_t)
  226.     {
  227.         register Region::RegionNode *nodE=freeList;
  228.         if (!(freeList=nodE->tail))
  229.         allocateBlock(nodE);
  230.         return (nodE);
  231.     }
  232.     void operator delete (void *node)
  233.     {
  234.         ((Region::RegionNode *)node)->tail=freeList;
  235.         freeList=(Region::RegionNode *)node;
  236.     }
  237.     static RegionNode *peek()
  238.     {
  239.         return freeList;
  240.     }
  241.     RegionNode *tail;        
  242.     RegionRow *row;          
  243.     int y;                   
  244.     };
  245.     class Initialiser {
  246.       public:
  247.     Initialiser()
  248.     {
  249.         Region::RegionPair::allocateBlock(0);
  250.         Region::RegionNode::allocateBlock(0);
  251.     }
  252.     static Initialiser initialiser;
  253.     };
  254.     friend RegionIterator;
  255.     Rectangle rect;
  256.     enum { EmptyRegion, SimpleRegion, ComplexRegion } type;
  257.     class RegionNode *node;
  258.     typedef RegionNode *(*__RegionOp)(RegionPair *, RegionPair *,
  259.                       RegionNode *, int&, int&);
  260.     static RegionNode *ROP_merge(RegionPair *, RegionPair *,
  261.                  RegionNode *, int &, int &);
  262.     static RegionNode *ROP_intersect(RegionPair *, RegionPair *,
  263.                      RegionNode *, int&, int&);
  264.     static RegionNode *ROP_subtract(RegionPair *, RegionPair *,
  265.                     RegionNode *, int&, int&);
  266.     static RegionNode *ROP_xor(RegionPair *, RegionPair *,
  267.                    RegionNode *, int&, int&);
  268.     static RegionNode *make_complex_node(const Rectangle&);
  269.     static void free_complex_node(RegionNode *node);
  270.     static void simplify_result(Region&, RegionNode *);
  271.     static RegionNode *region_op(char, char, char, __RegionOp,
  272.                  RegionNode *, int,
  273.                  RegionNode *, int, Rectangle&);
  274.     static void copy(const Region&, Region&);
  275.     static void free_nodes(Region&);
  276.   public:
  277.     Region();
  278.     Region(Point, Point);
  279.     Region(const Rectangle&);
  280.     Region(int, int, int, int);
  281.     Region(const Region&);
  282.     ~Region();
  283.     Region& operator = (const Rectangle&);
  284.     Region& operator = (const Region&);
  285.     static void merge(const Rectangle&, const Rectangle&, Region&);
  286.     static void merge(const Region&, const Rectangle&, Region&);
  287.     static void merge(const Region&, const Region&, Region&);
  288.     static void intersect(const Rectangle&, const Rectangle&, Region&);
  289.     static void intersect(const Region&, const Rectangle&, Region&);
  290.     static void intersect(const Region&, const Region&, Region&);
  291.     static void subtract(const Rectangle&, const Rectangle&, Region&);
  292.     static void subtract(const Rectangle&, const Region&, Region&);
  293.     static void subtract(const Region&, const Rectangle&, Region&);
  294.     static void subtract(const Region&, const Region&, Region&);
  295.     static void xor(const Rectangle&, const Rectangle&, Region&);
  296.     static void xor(const Region&, const Rectangle&, Region&);
  297.     static void xor(const Region&, const Region&, Region&);
  298.     Region& operator |= (const Rectangle&);
  299.     Region& operator |= (const Region&);
  300.     Region& operator &= (const Rectangle&);
  301.     Region& operator &= (const Region&);
  302.     Region& operator -= (const Rectangle&);
  303.     Region& operator -= (const Region&);
  304.     Region& operator ^= (const Rectangle&);
  305.     Region& operator ^= (const Region&);
  306.     int isEmpty() const;
  307.     int contains(Point) const;
  308.     void clear();
  309.     void translate(Point);
  310. };
  311. inline Region::Region()
  312.     : type(EmptyRegion)
  313. {
  314. }
  315. inline Region::Region(Point tl, Point br)
  316.     : type(SimpleRegion), rect(tl, br)
  317. {
  318. }
  319. inline Region::Region(const Rectangle& A)
  320.     : type(SimpleRegion), rect(A)
  321. {
  322. }
  323. inline Region::Region(int left, int top, int right, int bottom)
  324.     : type(SimpleRegion), rect(left, top, right, bottom)
  325. {
  326. }
  327. inline Region::Region(const Region& A)
  328. {
  329.     copy(A, *this);
  330. }
  331. inline Region::~Region()
  332. {
  333.     free_nodes(*this);
  334. }
  335. inline Region& Region::operator = (const Rectangle& A)
  336. {
  337.     free_nodes(*this);
  338.     rect=A;
  339.     type=SimpleRegion;
  340.     return *this;
  341. }
  342. inline Region& Region::operator = (const Region& A)
  343. {
  344.     if (this != &A) {
  345.     free_nodes(*this);
  346.     copy(A, *this);
  347.     }
  348.     return *this;
  349. }
  350. inline Region operator | (const Rectangle& A, const Rectangle& B) return result
  351. {
  352.     Region::merge(A, B, result); return;
  353. }
  354. inline Region operator | (const Rectangle& A, const Region& B) return result
  355. {
  356.     Region::merge(B, A, result); return;
  357. }
  358. inline Region operator | (const Region& A, const Rectangle& B) return result
  359. {
  360.     Region::merge(A, B, result); return;
  361. }
  362. inline Region operator | (const Region& A, const Region& B) return result
  363. {
  364.     Region::merge(A, B, result); return;
  365. }
  366. inline Region operator & (const Rectangle& A, const Rectangle& B) return result
  367. {
  368.     Region::intersect(A, B, result); return;
  369. }
  370. inline Region operator & (const Rectangle& A, const Region& B) return result
  371. {
  372.     Region::intersect(B, A, result); return;
  373. }
  374. inline Region operator & (const Region& A, const Rectangle& B) return result
  375. {
  376.     Region::intersect(A, B, result); return;
  377. }
  378. inline Region operator & (const Region& A, const Region& B) return result
  379. {
  380.     Region::intersect(A, B, result); return;
  381. }
  382. inline Region operator - (const Rectangle& A, const Rectangle& B) return result
  383. {
  384.     Region::subtract(A, B, result); return;
  385. }
  386. inline Region operator - (const Rectangle& A, const Region& B) return result
  387. {
  388.     Region::subtract(A, B, result); return;
  389. }
  390. inline Region operator - (const Region& A, const Rectangle& B) return result
  391. {
  392.     Region::subtract(A, B, result); return;
  393. }
  394. inline Region operator - (const Region& A, const Region& B) return result
  395. {
  396.     Region::subtract(A, B, result); return;
  397. }
  398. inline Region operator ^ (const Rectangle& A, const Rectangle& B) return result
  399. {
  400.     Region::xor(A, B, result); return;
  401. }
  402. inline Region operator ^ (const Rectangle& A, const Region& B) return result
  403. {
  404.     Region::xor(B, A, result); return;
  405. }
  406. inline Region operator ^ (const Region& A, const Rectangle& B) return result
  407. {
  408.     Region::xor(A, B, result); return;
  409. }
  410. inline Region operator ^ (const Region& A, const Region& B) return result
  411. {
  412.     Region::xor(A, B, result); return;
  413. }
  414. # 552 "Region.h"
  415. inline Region& Region::operator |= (const Rectangle& B)
  416. {
  417.     Region::merge(*this, B, *this);
  418.     return *this;
  419. }
  420. inline Region& Region::operator |= (const Region& B)
  421. {
  422.     Region::merge(*this, B, *this);
  423.     return *this;
  424. }
  425. inline Region& Region::operator &= (const Rectangle& B)
  426. {
  427.     Region::intersect(*this, B, *this);
  428.     return *this;
  429. }
  430. inline Region& Region::operator &= (const Region& B)
  431. {
  432.     Region::intersect(*this, B, *this);
  433.     return *this;
  434. }
  435. inline Region& Region::operator -= (const Rectangle& B)
  436. {
  437.     return *this;
  438. }
  439. inline Region& Region::operator -= (const Region& B)
  440. {
  441.     return *this;
  442. }
  443. inline Region& Region::operator ^= (const Rectangle& B)
  444. {
  445.     return *this;
  446. }
  447. inline Region& Region::operator ^= (const Region& B)
  448. {
  449.     return *this;
  450. }
  451. inline void merge(const Rectangle& A, const Rectangle& B, Region& C)
  452. {
  453.     Region::merge(A, B, C);
  454. }
  455. inline void merge(const Rectangle& A, const Region& B, Region& C)
  456. {
  457.     Region::merge(B, A, C);
  458. }
  459. inline void merge(const Region& A, const Rectangle& B, Region& C)
  460. {
  461.     Region::merge(A, B, C);
  462. }
  463. inline void merge(const Region& A, const Region& B, Region& C)
  464. {
  465.     Region::merge(A, B, C);
  466. }
  467. inline void intersect(const Rectangle& A, const Rectangle& B, Region& C)
  468. {
  469.     Region::intersect(A, B, C);
  470. }
  471. inline void intersect(const Rectangle& A, const Region& B, Region& C)
  472. {
  473.     Region::intersect(B, A, C);
  474. }
  475. inline void intersect(const Region& A, const Rectangle& B, Region& C)
  476. {
  477.     Region::intersect(A, B, C);
  478. }
  479. inline void intersect(const Region& A, const Region& B, Region& C)
  480. {
  481.     Region::intersect(A, B, C);
  482. }
  483. inline void subtract(const Rectangle& A, const Rectangle& B, Region& C)
  484. {
  485.     Region::subtract(A, B, C);
  486. }
  487. inline void subtract(const Rectangle& A, const Region& B, Region& C)
  488. {
  489.     Region::subtract(A, B, C);
  490. }
  491. inline void subtract(const Region& A, const Rectangle& B, Region& C)
  492. {
  493.     Region::subtract(A, B, C);
  494. }
  495. inline void subtract(const Region& A, const Region& B, Region& C)
  496. {
  497.     Region::subtract(A, B, C);
  498. }
  499. inline void xor(const Rectangle& A, const Rectangle& B, Region& C)
  500. {
  501.     Region::xor(A, B, C);
  502. }
  503. inline void xor(const Rectangle& A, const Region& B, Region& C)
  504. {
  505.     Region::xor(B, A, C);
  506. }
  507. inline void xor(const Region& A, const Rectangle& B, Region& C)
  508. {
  509.     Region::xor(A, B, C);
  510. }
  511. inline void xor(const Region& A, const Region& B, Region& C)
  512. {
  513.     Region::xor(A, B, C);
  514. }
  515. inline int Region::isEmpty() const
  516. {
  517.     return type == EmptyRegion;
  518. }
  519. inline void Region::clear()
  520. {
  521.     free_nodes(*this);
  522.     type=EmptyRegion;
  523. }
  524. inline void Region::translate(Point)
  525. {
  526. }
  527. # 41 "region.cpp" 2
  528. # 1 "RegionIterator.h" 1
  529.   #pragma interface
  530. class RegionIterator {
  531.     Region::RegionNode *node;
  532.     Region::RegionPair *pair;
  533.   public:
  534.     RegionIterator() {}
  535.     int first(const Region&);
  536.     int next();
  537.     Point topLeft, bottomRight;
  538. };
  539. # 109 "RegionIterator.h"
  540. inline int RegionIterator::next()
  541. {
  542.     if (!pair) {
  543.     if (!node)
  544.         return 0;
  545.     if (!node->row) {
  546.         topLeft.y=node->y;
  547.         node=node->tail;
  548.         bottomRight.y=node->y;
  549.     } else {
  550.         topLeft.y=bottomRight.y;
  551.         bottomRight.y=node->y;
  552.     }
  553.     pair=node->row->pair;
  554.     node=node->tail;
  555.     }
  556.     topLeft.x=pair->left;
  557.     bottomRight.x=pair->right;
  558.     pair=pair->tail;
  559.     return 1;
  560. }
  561. # 45 "region.cpp" 2
  562. # 1 "misc.h" 1
  563.   #pragma interface
  564. typedef unsigned char Byte;
  565. typedef Byte    *BytePointer;
  566. typedef BytePointer    *BytePointerPointer;
  567. volatile   void _botchFunction(const char *,
  568.                  const char *, unsigned int);
  569. volatile   void _fatalFunction(const char *,
  570.                  const char *, unsigned int);
  571. volatile   void _allocationError();
  572. volatile   void printError(const char *, ...);
  573. volatile   void abortProgram();
  574. # 49 "region.cpp" 2
  575. # 1 "/mclab/u90jl/gnu/lib/g++-include/values.h" 1 3
  576. # 57 "/mclab/u90jl/gnu/lib/g++-include/values.h" 3
  577. # 166 "/mclab/u90jl/gnu/lib/g++-include/values.h" 3
  578. # 56 "region.cpp" 2
  579. # 1566 "region.cpp"
  580. Region::RegionNode *
  581. Region::ROP_subtract(RegionPair *PA, RegionPair *PB,
  582.              RegionNode *nd, int& left, int& right)
  583. {
  584.     register RegionPair *pa=PA;
  585.     register RegionPair *pb=PB;
  586.     register RegionPair *pd;     
  587.     register RegionPair *ppd;    
  588.     RegionPair *first_pd;
  589.     if (pa->left >= pb->left) {
  590.     first_pd=RegionPair::peek();
  591.     pd=0;
  592.     if (nd && nd->row) {
  593.         ppd=nd->row->pair;
  594.         goto B_not_A_with_comparison;
  595.     }
  596.     goto B_not_A;
  597.     }
  598.     first_pd=pd=new RegionPair;
  599.     pd->left=pa->left;
  600.     if (nd && nd->row) {
  601.     ppd=nd->row->pair;
  602.     if (pd->left == ppd->left)
  603.         goto A_not_B_with_comparison;
  604.     }
  605.   A_not_B:
  606.     for (;;) {                     
  607.     if (pa->right <= pb->left) {
  608.         pd->right=pa->right;         
  609.         if (pa=pa->tail) {
  610.         if (pa->left < pb->left) {
  611.             pd=new RegionPair;
  612.             pd->left=pa->left;         
  613.             continue;
  614.         }
  615.         goto B_not_A;             
  616.         }
  617.         goto not_ending;             
  618.     }
  619.     pd->right=pb->left;             
  620.     if (pa->right > pb->right) {
  621.         pd=new RegionPair;             
  622.         pd->left=pb->right;
  623.         if (pb=pb->tail) {
  624.         continue;
  625.         }
  626.         pd->right=pa->right;         
  627.         pa=pa->tail;
  628.         goto ending;
  629.     }
  630.     if (pa=pa->tail) {             
  631.         goto B_not_A;
  632.     }
  633.         goto not_ending;             
  634.     }
  635.   B_not_A:
  636.     for (;;) {                     
  637.     if (pb->right <= pa->left) {
  638.         if (pb=pb->tail) {             
  639.         if (pb->left <= pa->left) {
  640.             continue;             
  641.         }
  642.         pd=new RegionPair;
  643.         pd->left=pa->left;
  644.         goto A_not_B;             
  645.         }
  646.         goto ending;             
  647.     }
  648.     if (pb->right >= pa->right) {         
  649.         if (pa=pa->tail) {             
  650.         continue;
  651.         }
  652.         goto not_ending;             
  653.     }
  654.     pd=new RegionPair;             
  655.     pd->left=pb->right;
  656.     if (pb=pb->tail) {             
  657.         goto A_not_B;
  658.     }
  659.     pd->right=pa->right;
  660.     pa=pa->tail;
  661.         goto ending;                 
  662.     }
  663.   ending:
  664.     while (pa) {
  665.     pd=new RegionPair;
  666.     pd->left=pa->left;
  667.     pd->right=pa->right;
  668.     pa=pa->tail;
  669.     }
  670.   not_ending:
  671.   finally:
  672.     if (pd) {
  673.     pd->tail=0;
  674.     ((nd=new RegionNode)->row=new RegionRow)->ref=0;
  675.     nd->row->right=pd->right;
  676.     if (pd->right > right)
  677.         right=pd->right;
  678.     nd->row->pair=pd=first_pd;
  679.     if (pd->left < left)
  680.         left=pd->left;
  681.     return nd;
  682.     }
  683.     (nd=new RegionNode)->row=0;
  684.     return nd;
  685.   ending_with_comparison:
  686.     while (pa) {
  687.     pd=new RegionPair;
  688.     if (!ppd
  689.         || (pd->left=pa->left) != ppd->left
  690.         || (pd->right=pa->right) != ppd->right) {
  691.         pd->left=pa->left;
  692.         pd->right=pa->right;
  693.         pa=pa->tail;
  694.         goto ending;
  695.     }
  696.     ppd=ppd->tail;
  697.     pa=pa->tail;
  698.     }
  699.   not_ending_with_comparison:
  700.     if (ppd)
  701.     goto finally;
  702.     RegionPair::freeList=first_pd;       
  703.     return nd;
  704.   A_not_B_with_comparison:
  705.     for (;;) {
  706.     if (pa->right <= pb->left) {
  707.         if ((pd->right=pa->right) != ppd->right) {
  708.         if (pa=pa->tail) {
  709.             if (pa->left < pb->left) {
  710.             pd=new RegionPair;
  711.             pd->left=pa->left;
  712.                 goto A_not_B;
  713.             }
  714.             goto B_not_A;
  715.         }
  716.         goto not_ending;
  717.         }
  718.         ppd=ppd->tail;
  719.         if (pa=pa->tail) {
  720.         if (pa->left < pb->left) {
  721.             pd=new RegionPair;
  722.             if (!ppd) {
  723.             pd->left=pa->left;
  724.             goto A_not_B;
  725.             }
  726.             if ((pd->left=pa->left) != ppd->left)
  727.             goto A_not_B;
  728.             continue;
  729.         }
  730.         goto B_not_A_with_comparison;
  731.         }
  732.         goto not_ending_with_comparison;
  733.     }
  734.     if ((pd->right=pb->left) != ppd->right) {
  735.         if (pa->right > pb->right) {
  736.         pd=new RegionPair;
  737.         pd->left=pb->right;
  738.         if (pb=pb->tail) {
  739.             continue;
  740.         }
  741.         pd->right=pa->right;
  742.         pa=pa->tail;
  743.         goto ending;
  744.         }
  745.         if (pa=pa->tail) {
  746.         goto B_not_A;
  747.         }
  748.         goto not_ending;
  749.     }
  750.     ppd=ppd->tail;
  751.     if (pa->right > pb->right) {
  752.         pd=new RegionPair;
  753.         if (!ppd) {
  754.         pd->left=pb->right;
  755.         if (pb=pb->tail) {
  756.             goto A_not_B;
  757.         }
  758.         pd->right=pa->right;
  759.         pa=pa->tail;
  760.         goto ending;
  761.         }
  762.         if ((pd->left=pb->right) != ppd->left) {
  763.         if (pb=pb->tail) {
  764.             goto A_and_B;
  765.         }
  766.         pd->right=pa->right;
  767.         pa=pa->tail;
  768.         goto ending;
  769.         }
  770.         if (pb=pb->tail) {
  771.         continue;
  772.         }
  773.         if ((pd->right=pa->right) != ppd->right) {
  774.         pa=pa->tail;
  775.         goto ending;
  776.         }
  777.         ppd=ppd->tail;
  778.         pa=pa->tail;
  779.         goto ending_with_comparison;
  780.     }
  781.     if (pa=pa->tail) {
  782.         goto B_not_A_with_comparison;
  783.     }
  784.         goto not_ending_with_comparison;
  785.     }
  786.   B_not_A_with_comparison:
  787.     for (;;) {
  788.     if (pb->right <= pa->left) {
  789.         if (pb=pb->tail) {
  790.         if (pb->left <= pa->left) {
  791.             continue;
  792.         }
  793.         pd=new RegionPair;
  794.         if (!ppd) {
  795.             pd->left=pa->left;
  796.             goto A_not_B;
  797.         }
  798.         if ((pd->left=pa->left) != ppd->left)
  799.             goto A_not_B;
  800.         goto A_not_B_with_comparison;
  801.         }
  802.         goto ending_with_comparison;
  803.     }
  804.     if (pb->right >= pa->right) {
  805.         if (pa=pa->tail) {
  806.         continue;
  807.         }
  808.         goto not_ending_with_comparison;
  809.     }
  810.     pd=new RegionPair;
  811.     if (!ppd) {
  812.         pd->left=pb->right;
  813.         if (pb=pb->tail) {
  814.         goto A_not_B;
  815.         }
  816.         pd->right=pa->right;
  817.         pa=pa->tail;
  818.         goto ending;
  819.     }
  820.     if ((pd->left=pb->right) != ppd->left) {
  821.         if (pb=pb->tail) {
  822.         goto A_not_B;
  823.         }
  824.         pd->right=pa->right;
  825.         pa=pa->tail;
  826.         goto ending;
  827.     }
  828.     if (pb=pb->tail) {
  829.         goto A_not_B_with_comparison;
  830.     }
  831.     if ((pd->right=pa->right) != ppd->right) {
  832.         pa=pa->tail;
  833.         goto ending;
  834.     }
  835.     ppd=ppd->tail;
  836.     pa=pa->tail;
  837.         goto ending_with_comparison;
  838.     }
  839. }
  840. # 3160 "region.cpp"
  841.  
  842.