Shape decompositon system and method
RELATED APPLICATION 
     Application Ser. No. 736654 to Chung et al., &#34;E-Beam Control Data Compaction System And Method&#34; which was filed coincident with this application is related to this application and assigned to the assignee of this invention. 
     FIELD OF THE INVENTION 
     The present invention relates generally to the fabrication of integrated circuits and more particularly, to a system and method of lithographic patterning of radiation sensitive layers by an electron beam exposure system 
     BACKGROUND OF THE INVENTION 
     Integrated circuit shapes can be patterned on a wafer entirely by means of direct writing electron beam (e-beam) lithography. Using e-beam to write microcircuit patterns in integrated circuit fabrication is well known in the art. The intended pattern can be directly written onto the wafer by exposing a thin layer of radiation sensitive material on the wafer with a beam of electrons or, alternatively, by using a mask made with an e-beam tool to optically expose a thin layer of photoresist on the semiconductor wafer. Whether the pattern is directly written or indirectly written with a mask, the e-beam tool control remains the same. See generally, U.S. Pat. 4,789,945 for an example of direct writing e-beam lithography used to expose to an entire wafer. The use of a computer to control the e-beam is also well known. See U.S. Pat. No. 4,728 797 for an example of a computer controlled microcircuit. fabrication system. 
     While e-beam lithography provides the advantage of very sharply defined patterns for very small geometric shapes, transferring those shapes from a computer designed shape to a physical image on a photoresistive, or radiation sensitive layer (resist), can be both expensive and time consuming. Most of the cost associated with transferring the shape is computer operating cost, which is also generally time dependent. Therefore, reducing computer operating time will reduce both the time and the expense associated with e-beam lithography. Several approaches have been used to reduce the time required to expose a wafer with an e-beam tool. See U.S. Pat. No. 4,147,937 for an example of a method and an apparatus for exposing a wafer by raster scan writing, i.e., a single line at a time. See also, U.S. Pat. No. 4,914,304 for an example of an e-beam exposure system that uses a shaped beam to improve exposure of different shapes. Although these prior art approaches reduce the exposure time, they do not appreciably reduce the computer time required to convert the design shape into Numerical Control for the e-beam tool (process a design shape). Using the prior art method of processing design shapes, it sometimes takes several hundreds of Central Processing Unit (CPU) minutes to convert an entire design into a format which may be used to control an e-beam tool. So, converting the graphics representation of a shape to control parameters for controlling the e-beam tool is a major computer bottleneck. 
     THe flow diagram of FIG. 1 shows the steps typically taken in the prior art to convert design data into e-beam tool control data and expose a semiconductor wafer. Each design shape is represented (30) in a graphics language by lines, rectangles, circles, and polygons. Such a representation is characteristic of the particular graphics language used and the shape represented. The graphics representation of the shape must be converted to control signals for an e-beam tool. The e-beam tool uses the converted, or postprocessed, information to direct the electron beam onto the radiatio.n sensitive layer, which writes, or exposes, the design shape onto the layer. A postprocessor is a computer program which combines the graphics data (30) and key e-beam tool processing parameters (32), also called keywords, to produce Numerical Control (NC) data for use by the e-beam lithographic exposure tool. Converting the design data to numerical control data iis called postporcessing the design data. Numerical control data is the data used to control exposure of the radiation sensitive layer by the e-beam tool. 
     Before postprocessing the design data, the graphics language representation of the design data (30) and the keywords (32) are checked (34) for syntax errors. After verifying that there are no syntax errors, the postprocessor decomposes (36) each design shape into a series of edges and then labels (38) each edge. An edge is a portion of the shape&#39;s perimeter and is normally a straight line connecting two vertices on the shape. Each converted edge is labeled (38) according to its position on a shape as a top, bottom, right or left edge. The postprocessor then applies (40) keywords which describe shape compensation, known as etch biases, to the edges. An etch bias is a compensation for the amount of distortion to a design shape which occurs in the process of making the final shape. The postprocessor then transforms (42) the edges from the graphics language grid (a unit of measure) to the e-beam tool grid. Alternatively, the postprocessor may apply the etch biases (40) to the shapes and transform the shapes (42) from the graphics grid to the tool grid before converting the shapes to edges (36) and labeling the edges (38). 
     After transforming the shapes into the tool grid, the postprocessor fills (44) the shapes. &#34;Filling&#34; is a term used to describe the process of reconstructing a shape out of one or more types of polygons, such as rectangles, so that the reconstructed shape is, as nearly as possible, identical to the design shape. The design shape is said to be filled with fill polygons or fill rectangles. See U.S. Patent No. 4,554,625 for an example of a method of producing non-overlapping rectangles to fill a shape. During the fill, some undesirably small rectangles, called slivers, may have been created. A sliver is a rectangle whose height or width is less than a sliver size, a size defined in the keywords (32). Slivers are usually narrower than the narrowest rectangle the e-beam tool can correctly expose. The presence of a sliver rectangle in the fill rectangles for a shape will cause distortion in the microcircuit. In some extreme cases, the presence of slivers can lead to reduced integrated circuit chip production (known as yield loss) or lead to defective integrated circuit chips that fail much sooner than would the identical chip without the presence of slivers If the same shape could be filled without creating slivers then the fill is not optimum. The fill also may not be optimum because the shape could have been filled with fewer rectangles. So, prior art methods required that each shape be filled twice: once to fill the shape and a second time to determine if the first fill was optimum. The second fill may take as much CPU time and generate as much data volume as or more than the first fill. 
     The fill rectangles provide the e-beam tool with control data to direct the e-beam to expose a rectangular area. See, &#34;Method and Apparatus for Digital Control of E-Beam Pattern Writing as Applied to Subfield and Vector Equipment,&#34; in the March, 1980 IBM Technical Disclosure Bulletin page 4583 and see, &#34;Method and Apparatus to Provide Rapid Interpretation of Digital Source Information During Electron-Beam Pattern Writing of Rectangular Shapes,&#34; in the April, 1982 IBM Technical Disclosure Bulletin page 5681 for examples of rectangle generators. U.S. Patent No. 3,956,634 discloses a method of exposing a fill rectangle by an inward spiral, which starts by tracing the perimeter of the rectangle and spiralling the beam inward until the center of the rectangle is reached. 
     After the fill (44), overlapping fill rectangles were cut and the overlaps were eliminated (46). Overlaps occurred when a designer used two or more overlapping simple shapes to create a more complex shape As a result of filling each of the simple shapes, the more complex shape was filled However, the fill rectangles overlapped whenever the simple shapes overlapped The overlap can be eliminated by either combining the overlapping fill rectangles into a single fill rectangle, by shrinking one of the overlapping fill rectangles, by removing the overlapping fill rectangles and filling along the overlap, or, by any other method which would result in butting fill rectangles filling the area within the complex shape. The fill rectangle overlaps may be eliminated (46) in the second pass of the fill (44) or after the second pass of the fill (44). Once the fill rectangle overlaps are eliminated (46) the fill rectangles are proximity corected (47). 
     Proximity correction (47) means adding control information to the fill rectangles to adjust the length of time the e-beam must expose the resist in order to print a clear image. After proximity correction, the fill data is passed (48) to the e-beam tool as Numerical Control (NC) data. NC data is actually a series of commands for the e-beam tool to control the tool to expose each rectangle. The e-beam tool writes (50) the design onto a wafer by exposing each fill rectangle onto the resist. After every fill rectangle has been written, the design shape will have been written onto the resist layer. The exposed pattern can be developed in a manner similar to to photodeveloping. The wafer, covered by the developed pattern, is then etched, implanted or otherwise similarly altered to imprint the pattern onto the wafer. So, the Numerical Control data for the e-beam tool is generated from the data generated during the fill and proximity correction. Since the computer must treat every shape as a puzzle in which the computer must both create the pieces and then fit them together during the fill (44) and, since the computer must then calculate the effect on a fill rectangle from every fill rectangle in close proximity during proximity correction (47), the fill (44) and proximity correction (47) use the most CPU time and produce the largest volume of data. 
     A semiconductor chip, typically, is comprised of several layers of shapes commonly known as levels and which are overlaid to form micro circuits. In the prior art, when each of these layers was created optically through a mask, these layers were known as mask levels. Some levels may still be made optically on the wafer, while the masks are made with an e-beam tool. A single design may require several levels which must be independently converted to E-beam control data. Filling each mask level is a major CPU bottleneck which may take several CPU hours with prior art fill methods. The CPU thruput times tend to increase with N**2, where N is the number of shape edges. Since each circuit is comprised of several design shapes, and since the number of edges is directly related to the number of design shapes, CPU thruput is related to the number of circuits in the design If a design is sufficiently complex, the time required to fill a single mask level would exceed the average time between CPU failures, known as the CPU&#39;s mean time to fail. Thus, the number of circuits allowed on an integrated circuit chip could be limited by factors such as the CPU&#39;s mean time to fail rather than the e-beam tool&#39;s other physical limitations when a prior art fill is used. Reducing the time required to fill a design would provide a significant improvement over slow prior art fill methods. 
     Also, besides being slow and awkward, prior art fill methods may lead to a unfavorable cutting of slanted edges Filling along a slanted edge may be done by placing a staircase of small rectangles along the edge. Fragmenting the edge unequally may result in edge variations from staircases of varying size being placed along each piece of the angled edge. So, the uniformity of that angled edge is often lost, degrading image quality. 
     OBJECTS OF THE INVENTION 
     It is an object of the claimed invention to improve semiconductor chip fabrication with a particle beam tool. 
     It is another object of the claimed invention to reduce the computer processing time required to fabricate a semiconductor chip with a particle beam tool. 
     It is another object of the claimed invention to reduce manufacturing yield loss in semiconductor chips fabricated with a particle beam tool. 
     It is still another object of the claimed invention to reduce the number of particle beam fabricated semiconductor chips which fail prematurely. 
     It is still another object of the claimed invention to increase the number of circuits which may be placed on a semiconductor chip fabricated by particle beam lithography. 
     It is still another object of the claimed invention to minimize unfavorable cutting of slanted edges. 
     It is still another object of the claimed invention to improve conversion of circuit design shapes into particle beam lithography tool control data. 
     It is still another object of the claimed invention to convert circuit design shapes into optimal control data for a particle beam tool without rearranging the control data after the first conversion. 
     SUMMARY OF THE INVENTION 
     In accordance with the objects of this invention, a more efficient method of converting circuit design shapes into control data for particle beam lithography is provided wherein design shapes are converted into optimal fill data in a single pass with slivers minimized. The fill data are fill polygons used to control a particle beam or electron beam lithography tool in direct writing the filled design shape onto a semiconductor wafer. The method comprises: (a) forming a top chain of top and side edges; (b) triggering a fill of at least part of the design shape whenever enough information exists to avoid creating slivers (enough information existing whenever a bottom edge is encountered); (c) partitioning the region in the shape which is under the top chain and above the triggering bottom edge, by: identifying all bottom edges on the shape which are colinear with the encountered bottom edge (requiring additional filling of the shape) and, identifying bottom edges below but, near the triggering bottom edge (source of future slivers); (d) filling to minimize present and future slivers; and leaving unfilled portions of the shape for filling when lower bottom edges are encountered; (e) truncating filled areas from the shape; (f) adding more side and top edges to the truncated top chain; and (g) continuing the steps of building chains of edges and filling until all shapes in the design have been filled. The fill rectangles are passed to the lithography tool and, direct the particle beam or electron beam in writing the design shapes onto the radiation sensitive layer. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     While the specification concludes with claims particularly pointing out and distinctly claiming that which is regarded as the present invention, details of the preferred embodiments of the invention may be more readily ascertained from the following technical description when read in conjunction with the following drawings wherein: 
     FIG. 1 is a flow diagram for converting design data into e-beam tool numerical control data. 
     FIG. 2 is a flow diagram of a prior art fill. 
     FIG. 3 shows a shape divided into quadrilaterals according to the prior art. 
     FIGS. 4A-4C shows a shape filled and sleeved according to the prior art. 
     FIG. 5 is an example of a shape which can be divided into three rectangular quadrilaterals and filled according a prior art method. 
     FIG. 6A is an example of a design shape 
     FIGS. 6B-6F shows the shape of FIG. 6 as filled according to a prior art method 
     FIG. 7-7A is flow diagram of the fill method of the present invention. 
     FIG. 7B is a flow diagram for converting design data into NC data according to the preferred embodiment of the present invention. 
     FIG. 8 is a diagrammatic representation of an INPUT list entry. 
     FIG. 9 is a diagrammatic representation of the INPUT list of the preferred embodiment for the sorted edges of the figure of FIG. 6. 
     FIGS. 10.A-10H shows the shape of FIG. 6 as filled according to the preferred embodiment. 
     FIG. 11A is a diagrammatic representation of a TOP-CHAIN entry. 
     FIG. 11B is an example of a TOP CHAIN entry. 
     FIG. 12 is a flow diagram of how the BOT NEARBY list is built, 308 in FIG. 7. 
     FIG. 13A-13B shows a shape with an angled edge as filled by a prior art fill method and by the preferred embodiment. 
    
    
     TECHNICAL DESCRIPTION 
     First, a description of how shapes were filled by a prior art method and some examples of shapes filled by that method are provided to facilitate understanding of the present invention. 
     FIG. 2 is a flow diagram of a prior art fill method. First the edges were sorted (60). The sorted edges were sequentially connected together, or processed, until a quadrilateral could be formed (62). The top and bottom edges of the quadrilaterals were horizontal. FIG. 3 shows shape 70 divided into quadrilaterals according to the prior art. When edges 72, 74, 76, 78, 80, 82, and 84 were processed, quadrilaterals 86, 88, and 90 were built The quadrilaterals in FIG. 3 were built such that every unique lower endpoint of a side edge (92, 94, 96, and 98) is a quadrilateral&#39;s bottom corner. Because top and bottom edges are horizontal, any bottom corner of a quadrilateral not being the lower endpoint of a side edge (100 and 102) lies on a side edge at the same Y coordinate as the first corner. 
     After partitioning the shape into quadrilaterals, each quadrilateral was filled with rectangles (64) by a rectangle generator. The first time a shape has been filled is known as &#34;the first pass&#34; because the postprocessor has passed or processed through the shape for the first time. 
     When an edge of a quadrilateral lies on an angle to the vertical or horizontal direction, the postprocessor covers that quadrilateral with a series of very small rectangles. These small rectangles produce a staircase of edges along the slanted or angled edge to approximate the angled edge. See U.S. Pat. No. 4,532,598 for an example of an e-beam system which fills along angled edges with a staircase of rectangles. The postprocessor uses size limits from the keywords to limit the width and height of these staircase rectangles. This staircase of edges produces a jagged edge. For example, sleeving shape 110 in FIG. 4A as taught in U.S. Pat. No. 4,717,644 and incorporated herein by reference, would first require decomposing shape 110 into quadrilaterals 112 and 114 shown in FIG. 4B. In FIG. 4C, the edges of the quadrilaterals are delineated by e-beam exposure pattern 116, which is the sleeve for shape 110. It should be noted that fully sleeving quadrilaterals 112 and 114 would lead to overlapping sleeve portions 118 and 120. Sleeve portions 118 and 120 lie within and are, therefore, internal to shape 110. Consequently, 118 and 120 are normally discarded and, as shown in FIG. 4D, sleeve 116 completely defines the perimeter of 110. Internal area 122 may be filled using optical methods, not the subject of this invention, or filled with rectangles. Alternatively, sleeve 116 could be eight sleeve rectangles with a sleeve rectangle placed along each edge of shape 110. Sleeving provides sharp edge definition and is done when the postprocessor fills the shape. 
     Whenever sleeving is required, lists of top and bottom edges must be maintained for proper identification of any parts of each quadrilaterals&#39; perimeter which will require sleeves. Since the quadrilaterals&#39; side edges are side edges of the shape, sleeve rectangles will be generated for the quadrilaterals&#39; side edges when each quadrilateral is filled and so, lists need not be maintained for side edges With horizontal edges, however, as with 104 in FIG. 3, some edges may be internal to the shape and, therefore, would not require sleeves. Also, as with 118 in FIG. 4b, a quadrilateral&#39;s horizontal edges may be partially internal to a shape and partially on the shape&#39;s edges. The lists will, therefore, contain the portions of the quadrilateral&#39;s horizontal edges which are top and bottom edges of the shape. The height and width of the sleeve rectangles may be defined in the keywords. For example, shape 130 in FIG. 5 is divided into quadrilaterals as described above. In FIG. 5, input edges are labeled 132, 134, . . . , 154 and quadrilaterals which were generated are labeled 160, 162, and 164. Top and bottom lists for each quadrilateral would be as follows: 
     
         ______________________________________                                    
         160 -                                                            
              Top list - 134                                              
              Bottom List - Empty                                         
         162 -                                                            
              Top list - 138, 154                                         
              Bottom List - 142, 150                                      
         164 -                                                            
              Top list - Empty                                            
              Bottom List - 146                                           
______________________________________                                    
 
    
     Additionall when generating these top and bottom edge lists, the post processor makes two checks which may result in adding bottoms or tops to the lists. If the distance between any top edge of the shape and any bottom edge of the shape is less than a minimum keyword input, called the &#34;split value&#34;, then the top edge is included in the top list and the bottom edge is included in the bottom list for all quadrilaterals lying between those top and bottom edges. If, for example, the Y distance between edges 134 and 146 were less than the split value, then edge 134 would be included in the top list and edge 146 would be included in the bottom list for all three quadrilateral&#39;s (160, 162, and 164). The second check determines whether top or bottom quadrilaterals are shorter than the sleeve size. This check is done while generating the top and bottom lists for quadrilaterals adjacent to the top and bottom quadrilaterals, e.g., 162. If the top or bottom quadrilateral is shorter than the sleeve size, then the respective top or bottom is included in the appropriate list of the adjacent quadrilateral. For shape 130 in FIG. 5, if quadrilaterals 160 and 164 were shorter than the sleeve height, then edge 134 would be included in 162&#39;s top list and edge 146 would be included in 162&#39;s bottom list. Sleeve rectangles are generated from these lists. 
     Before the fill rectangles are passed to the e-beam tool, a second pass (66) is made. The second pass (66) may be made either after filling each shape or, alternatively, after having filled every shape design. In the second pass, each shape&#39;s fill rectangles are re-examined to optimize the fill arrangement and to eliminate &#34;slivers&#34; by generating (68) new fill rectangles The fill may be optimized by combining slivers with other fill rectangles and by rearranging the fill to provide a fill that is most suitable to the particular e-beam tool. Although slivers cannot always be eliminated, in most instances they can be. 
     In filling shape 200 in FIG. 6A according to the prior art, slivers were created The edges of shape 200 were sorted and labeled starting with edge 201 and ending with edge 210. The sorted edges were sequentially connected together until edges 204 and 205 were added, which defined the first quadrilateral 220. Defining 220 triggered a fill that completely filled the quadrilateral, see FIG. 6B. More edges were sequentially connected until, as shown in FIG. 6C, another fill was triggered when 206 and 207 were added generating the second quadrilateral 221. Quadrilateral 221 was completely filled. If, for example, the length of edge 204 did not exceed the sliver size, then the fill rectangle for quadrilateral 221 was a sliver rectangle, i.e., a sliver was generated. Next, more edges were sequentially added until in FIG. 6D quadrilateral 222 was generated when edges 208 and 209 were added. Generating quadrilateral 222 triggered a fill and 222 was completely filled. If edge 208 was shorter than a sliver then filling 222 would lead to creating slivers when the remainder of the shape would be filled in a subsequent fill. Adding edge 210 generated the fourth quadrilateral, 223, in FIG. 6E and 223 was filled In the final step, the second pass, the filled shape (shown in FIG. 6F) was reexamined to determine if the fill was optimum or if slivers could be eliminated. If slivers were found or if the fill was not optimum, shape 200 would be filled a second time 
     In the method of the present invention, unlike the prior art, shapes are filled in a single pass by interrogating the edges of each shape and, whenever sufficient information has been gathered on an area of a shape, filling that area. 
     FIG. 7A is a flow diagram of the fill method of the present invention. Table 1 is programming design language (also known as psuedocode) listing and is an alternate description of the fill method of the flow diagram of FIG. 7A. FIG. 7B is a flow diagram for converting design data to NC data according to the preferred embodiment of the present invention. 
     In the preferred embodiment of FIG. 7B, the post processor applies the etch biases (40) to shapes and then transforms the shapes (42) from the graphics grid to the tool grid before converting the shapes to edges (36) and labeling the edges (38). After labeling the edges (38) and before filling the shapes, the shapes are &#34;unioned&#34; (43). &#34;Unioning shapes&#34; means combining two or more simple shapes into a single shape. The unioned shape may or may not be more complex. For example, two small rectangles may, when unioned, form a 6 sided polygon or form a rectangle. 
     After the shapes are unioned (43), they are filled according to the fill method represented in FIG. 7A and Table 1. 
     
                                           TABLE 1                                 
__________________________________________________________________________
DCL 1 NEXTY BASED (P NEXTY)                                               
                           DCL 1 NEXTBOT BASED                            
                           (P.sub.-- NEXTBOT),                            
2 FORWARD LINK TO NEXT EDGE                                               
                           2 FORWARD LINK TO NEXT                         
                           EDGE,                                          
2 *                        2 FORWARD LINK TO NEXT                         
                           BOTTOM,                                        
2 EDGE.sub.-- RECORD       2 EDGE.sub.-- RECORD                           
/* FLOW */                                                                
/* INITIALIZE LISTS */                                                    
NEARBY.sub.-- RANGE.sub.-- CHK = RANGE TO LOOK WITHIN TO PREVENT          
SLIVERS;                                                                  
YCURR = YSORT PT OF FIRST EDGE IN INPUT LIST; /*P.sub.-- NEXTY*/          
YBOT = YSORT PT OF FIRST BOTTOM EDGE IN INPUT LIST;                       
/*P.sub.-- NEXTBOT*/                                                      
EOD.sub.-- Y = YSORT PT OF END.sub.-- OF.sub.-- DATA EDGE;                
/* MAIN LINE */                                                           
DO WHILE (YBOT &gt; = EOD.sub.-- Y); /* PROCESS UNTIL EOD IS FOUND */        
DO WHILE (YCURR &gt; YBOT);                                                  
CALL PROCESS.sub.-- YCURR;                                                
                   /* ADD LEFT, TOP, RIGHT EDGES WHOSE                    
                   YSORT PT = YCURR TO TOP CHAINS*/                       
YCURR = NEXTY.YSORT;                                                      
                   /* NEXT Y VALUE BELOW PREVIOUS YCURR*/                 
END;                                                                      
CALL PROCESS-NEARBY;                                                      
                 /* PREPARE BOT.sub.-- NEARBY LIST FOR CHECKING           
                 OF NEARBY.sub.-- BOTTOMS OF YBOT*/                       
CALL PRCCESS.sub.-- YBOT;                                                 
                 /* PROCESS BOTTOM EDGES WHOSE                            
                 YSORT PT = YBOT*/                                        
YBOT = NEXTBOT.YSORT;                                                     
                 /* NEXT BOTTOM EDGE YVALUE BELOW                         
                 PREVIOUS ONE */                                          
YCURR = NEXTY.YSORT;                                                      
                 /* IF A PARTICULAR Y VALUE HAD ALL BOTTOM                
                 EDGES ON IT PROCESS.sub.-- YBOT WOULD HAVE               
                 CHANGED P.sub.-- NEXTY */                                
END; /* END DO WHILE YBOT = EOD.sub.-- Y */                               
__________________________________________________________________________
 
    
     Although an edge could be curved or otherwise irregular, in the preferred embodiment edges are straight lines. An edge is a part of a shape&#39;s perimeter which connects two vertices together An edge&#39;s upper left end point is the edge&#39;s sort point The upper end point is a side edge&#39;s sort point The left end point is a horizontal (top or bottom) edge&#39;s sort point. An edge&#39;s other end point is called the edge&#39;s other point. Every sort point has an X and a Y coordinate designated as the sort point&#39;s XSORT POINT and YSORT POINT. Each edge&#39;s other point has an X and a Y coordinate designated as its XOTHER POINT and YOTHER POINT. Each edge is labeled according to its location on the shape. Thus, edges are labeled as right, left, top, or bottom. Edges are also labeled as internal 116 or external 116 for sleeving, if sleeving is required. A design language representation of an edge according to the preferred emobidment is: 
     
         ______________________________________                                    
DCL 1 EDGE.sub.-- RECORD,                                                 
          2   XSORT POINT,                                                
          2   YSORT POINT,                                                
          2   LABELING,                                                   
          2   XOTHER POINT,                                               
          2   YOTHER POINT                                                
______________________________________                                    
 
    
     Edges are sorted top to bottom according to YSORT POINT. Edges having the same YSORT POINT are sorted left to right according to XSORT POINT. Edges having the same YSORT POINT and XSORT POINT are sorted with side edges before top and bottom edges according to label. A design language representation of the edge sort criteria is: 
     
         YSORT PT DECREASING, XSORT PT INCREASING, LABELING. 
    
     The sorted edges are sequentially listed in a list called the INPUT list (300). FIG. 8 is a diagrammatic representation of an INPUT list entry. Each INPUT list entry contains A forward link to the next sorted edge in the INPUT list; a forward link to the next bottom edge for every bottom edge or 0 for every non-bottom edge; and an edge record. FIG. 9 is a diagrammatic representation of the INPUT list after sorting the edges of shape 200 according to the preferred embodiment. 
     After the edges have been sorted and entered in the INPUT list, two pointers are set. The first pointer, P --  NEXTY, is initialized to point to the first edge in the INPUT list. In FIG. 9, P --  NEXTY is set to point to edge 201. The second pointer, P --  NEXTBOT, is initialized to point to the first bottom edge in the INPUT list. In FIG. 9, P NEXTBOT is set to point at edge 205, the first bottom edge in the INPUT list. Each edge points to the next edge in the list, e.g., 206 points to 207. Each bottom edge points to the next bottom edge in the list, e.g., 205 points to 209. An END --  OF --  DATA edge is placed as the last entry in the INPUT LIST. The last bottom edge from the sort (210) will have both links pointing to the END --  OF --  DATA edge. For convenience and clarity in the discussion below, a reference to a pointer is a reference to the edge to which the pointer is pointing. 
     In the preferred embodiment, after building the INPUT list, the edges in the INPUT list are sequentially processed, i.e. connected together, until enough shape information is developed to partially or fully fill a shape. However, before processing the INPUT list, four variables, NEARBY --  RANGE --  CHK, YCURR, YBOT, and EOD --  Y, are defined (302) if no sleeving is required, otherwise it is set to the split value. NEARBY --  RANGE --  CHK is set equal to the sliver range keyword if no sleeving is required, otherwise it is set to the split value. YCURR is initialized to the YSORT point of the first edge in the INPUT list, edge 201&#39;s YSORT POINT. YBOT is initialized to the YSORT point of the first bottom edge in the INPUT list, edge 205&#39;s YSORT POINT. EOD --  Y is set to the YSORT point of the END --  OF --  DATA edge in the INPUT list. 
     Once these four variables have been defined, the edges in the INPUT list are processed sequentially. Table 2 is a programming design language listing of how the edges in the input list are processed. 
     
                                           TABLE 2                                 
__________________________________________________________________________
/* SUBROUTINE */                                                          
PROCESS.sub.-- YCURR: PROC;                                               
/*                                                                        
  P.sub.-- NEXTY PTS TO FIRST EDGE IN INPUT LIST WITH YSORT               
  VALUE OF YCURR */                                                       
/*                                                                        
  SINCE BOTTOM EDGES AT THIS YCURR WERE ALREADY PROCESSED BY A            
  PREVIOUS CALL TO PROCESS.sub.-- YBOT--FORWARD LINKS TO BOTTOMS AT       
  THIS YCURR HAVE BEEN REMOVED. */                                        
/*                                                                        
  ADDS LEFT, TOP, RIGHT EDGES WHOSE YSORT = YCURR TO THEIR                
  PROPER TOP.sub.-- CHAIN OR INSERTS ANY NEW TOP.sub.-- CHAINS INTO THE   
  TOP-CHAIN LIST. */                                                      
DO WHILE (NEXTY.YSORT = YCURR); /*                                        
                       PROCESS TOPS, SIDES WHOSE                          
                       YSORT = YCURR */                                   
PROCESS &#34;EDGE COMBINATION&#34; BASED ON P.sub.-- NEXTY AND EDGES THAT FOLLOW  
P.sub.-- NEXTY IN THE INPUT LIST LOOKING FOR EDGES THAT CONNECT.          
SELECT (&#34;EDGE COMBINATION&#34;);                                              
WHEN (LEFT EDGE &amp; TOP EDGE CONNECT)                                       
/* P.sub.-- NEXTY = LEFT EDGE - NEXT EDGE = TOP EDGE -- CONNECT */        
FIND THE TOP.sub.-- CHAIN WHOSE LEFTMOST EDGE CONNECTS TO THE X, Y        
OTHER PT OF THE TOP EDGE AND ADD THESE EDGES TO THE LEFT                  
END OF THAT TOP.sub.-- CHAIN.                                             
WHEN (TOP EDGE &amp; RIGHT EDGE CONNECT)                                      
/* P.sub.-- NEXTY = TOP EDGE - NEXT EDGE = RIGHT EDGE -- CONNECT */       
FIND THE TOP.sub.-- CHAIN WHOSE RIGHTMOST EDGE CONNECTS TO THE X, Y       
SORT PT OF THE TOP EDGE AND ADD THESE EDGES TO THE RIGHT                  
END OF THAT TOP.sub.-- CHAIN.                                             
WHEN (TOP EDGE ONLY)                                                      
/*P.sub.-- NEXTY = TOP EDGE--NO OTHER CONNECTION */                       
FIND THE TOP.sub.-- CHAIN WHOSE RIGHTMOST EDGE CONNECTS TO THE X,         
Y SORT PT OF THE TOP.sub.-- EDGE -- NEXT TOP.sub.-- CHAIN AFTER IN LIST   
WILL CONNECT TO X, Y OTHER PT OF TOP EDGE. MERGE THESE TWO                
TOP CHAINS INTO ONE ADDING TOP EDGE TO THE MERGED TOP.sub.-- CHAIN.       
WHEN (LEFT EDGE, TOP EDGE, RIGHT EDGE CONNECT)                            
/* P.sub.-- NEXTY = LEFT EDGE, - NEXT TWO EDGES ARE TOP, RIGHT THAT       
CONNECT. */                                                               
FIND PLACE IN TOP.sub.-- CHAIN LIST TO INSERT THIS NEW TOP.sub.-- CHAIN   
--                                                                        
CREATE NEW TOPCHAIN AND INSERT INTO LIST. TOP.sub.-- CHAIN LIST IS        
ORDERED LEFT TO RIGHT.                                                    
WHEN (LEFT EDGE OR RIGHT EDGE ONLY)                                       
/* P.sub.-- NEXTY = LEFT OR RIGHT EDGE -- NO OTHER CONNECTION */          
FIND TOP.sub.-- CHAIN THAT CONNECTS TO THE LEFT OR RIGHT EDGE AND         
ADD THAT EDGE TO THE PARTICULAR TOP.sub.-- CHAIN.                         
OTHERWISE                                                                 
END SELECT;                                                               
UPDATE P.sub.-- NEXTY TO POINT TO NEXT GROUP OF EDGES -- P.sub.-- NEXTY = 
LAST                                                                      
EDGE IN &#34;EDGE COMBINATION.&#34; FORWARD LINK -- MAY                           
CHANGE NEXTY.YSORT                                                        
END; /*END DO WHILE (NEXTY.YSORT = YCURR)*/                               
END PROCESS.sub.-- YCURR;                                                 
__________________________________________________________________________
 
    
     The edges in the INPUT list are processed according to sort point with P --  NEXTY pointing to the first edge in the list at the sort point. All edges with the sort point of PNEXTY are connected together before any edge is processed at a subsequent sort point. All of the edges in the INPUT list at a common YSORT point are processed before any edge with a lower YSORT point can be processed. As the edges are processed, YCURR is updated to hold the current value of the YSORT point of the edge being processed. 
     The connected edges create chains of top and side edges called TOP --  CHAIN&#39;s (304). So, when the edges in INPUT list in FIG. 9 are processed according to the preferred embodiment, TOP --  CHAIN 360 in figure 10a, is built from edges 201, 202, and 203. TOP --  CHAIN&#39;s do not contain any bottom edges A list is created, called the TOP --  CHAIN list, and each TOP --  CHAIN is entered in the list. The first and last entries in the TOP --  CHAIN list are dummy records called the start and end TOP CHAINS respectively. FIG. 11A is a diagrammatic representation of a TOP --  CHAIN list entry. Each entry in the TOP --  CHAIN list contains: a forward link to the next TOP --  CHAIN in the list; a backward link to the previous TOP --  CHAIN in the list; a link to the leftmost edge of the TOP --  CHAIN; and a link to the rightmost edge of the TOP --  CHAIN. 
     As indicated above, processing an edge means connecting it to other edges. An edge is connected to another edge if either end point of one edge is identical with an end point of the other edge, i.e., the first edge is linked, by its first (forward) link (see FIG. 8), to the other edge. So, when an edge is processed: if the edge is connected to the left side of a TOP --  CHAIN or of another edge, the first link in the processed edge is altered; or, if the edge is connected to the right side of a TOP --  CHAIN or of another edge, the processed edge&#39;s link is unchanged, and the other edge&#39;s first link is altered. Additionally, if the processed edge is the first or last edge in a TOP --  CHAIN, the appropriate TOP --  CHAIN link in the TOP --  CHAIN entry is altered. Therefore, individual edges in each TOP --  CHAIN are linked together by a forward link starting at the leftmost edge of the TOP --  CHAIN and proceeding to the rightmost edge, i.e., in order of ascending XSORT point. FIG. 11B is a diagramatic representation of the TOP --  CHAIN list entry for TOP --  CHAIN 360. The TOP --  CHAIN entry provides the first edge in the chain through its link to the leftmost edge and the last link in the chain through its link to the rightmost edge. As indicated above, sequentially processing the edges in the INPUT list means: if the processed edge is other than a bottom edge (304), connecting that edge to subsequent side or top edges in the INPUT list to build a chain of top and side edges (306) called a TOP --  CHAIN or, connecting that edge to previously built TOP --  CHAIN&#39;s; if the processed edge is a bottom edge then a fill is triggered (308) and at least part of a shape is filled. As each TOP --  CHAIN is built or modified, an entry is made in a TOP --  CHAIN list. 
     Processing PNEXTY to build TOP --  CHAIN&#39;s can lead to five possible connection combinations. First, when PNEXTY is a left edge and the next two edges are connecting top and right edges, then these three edges are connected and form a new TOP --  CHAIN which is inserted in the TOP --  CHAIN list. Second, when PNEXTY is a left edge and the next edge is a top edge, then these two edges are added to the left end of the TOP --  CHAIN in the TOP --  CHAIN list which has its left end at the X,Y OTHER point of the top edge. Third, when PNEXTY is a top edge and the next edge is a right edge, then these two edges are added to the right end of the TOP --  CHAIN in the TOP --  CHAIN list which has its right end at the XSORT and YSORT point of the top edge. Fourth, when PNEXTY is a top edge with no other edges in the list connected to it then, PNEXTY connects 2 TOP --  CHAIN&#39;s together; PNEXTY is added to the right end of the TOP --  CHAIN in the TOP --  CHAIN list which has its right end at the XSORT and YSORT point of PNEXTY, and, the TOP --  CHAIN in the TOP --  CHAIN list which has its left end at the XOTHER and YOTHER point of PNEXTY is added to the right side of PNEXTY. Finally, when PNEXTY is a side edge to which the next edge does not connect, then PNEXTY is added to the side of the TOP --  CHAIN in the TOP --  CHAIN list which has its left or right end at the XSORT and YSORT point of PNEXTY. 
     Sequential processing of the edges in the INPUT list continues until a bottom edge is encountered, i.e., the YSORT point of PNEXTY is equal to YBOT. Encountering a bottom edge (308) triggers a fill, because enough information exists about the shape containing the bottom edge to fill at least part of that shape. So, when edges 204 and 205 in the INPUT list in FIG. 9 are processed, a fill is triggered because 205 is a bottom edge. Since no subsequent edges in the INPUT list can be above edge 205 in figure 10b, all of the area under TOP --  CHAIN 360 above edge 205&#39;s YSORT point will be filled, either when 205 triggers the fill or, at a subsequent fill. However, to avoid creating slivers or a situation which would lead to creating slivers at future fills, more information must be gathered. Since shape 200 is not fully defined, only the part of shape 200 above edge 205 could be filled without first considering possible sources of problems at future fills. Other bottom edges (NEARBY --  BOTTOM edges) on shape 200 could lead to creating slivers when those NEARBY --  BOTTOM edges subsequently trigger fills. That is because the distance between YBOT and NEARBY --  BOTTOM edges is less than the width of a sliver. 
     To consider NEARBY --  BOTTOM edges when a fill is triggered, a list called the BOT --  NEARBY list is built and modified on each subsequent fill. Table 3 is a program design language listing of how the BOT --  NEARBY list is built according to the flow diagram provided in FIG. 12. Before building the BOT --  NEARBY list, NEARBY --  RANGE is determined by subtracting NEARBY --  RANGE --  CHK value from YBOT (3080). A pointer, P --  NEARBYBOT, is set (3082) to point to the first bottom edge below the last bottom edge in the BOT --  NEARBY list, i.e., not in the BOT --  NEARBY list. P --  NEARBYBOT is checked (3084) to determine if it is below NEARBY --  RANGE. If P --  NEARBYBOT is below NEARBY --  RANGE, then, all other bottom edges in the INPUT list are below NEARBY --  RANGE and no NEARBY --  BOTTOM edges are added to the BOT --  NEARBY list. If P --  NEARBYBOT is above NEARBY --  RANGE then an entry is made (3086) in the BOT --  NEARBY list and P --  NEARBYBOT is set (3082) to point to the first bottom edge in the INPUT list below that BOT --  NEARBY entry. Entries are made in the BOT --  NEARBY list for each YSORT point between YBOT and NEARBY --  RANGE at which there is a bottom edge (3086). P --  NEARBYBOT is set (3082) to point below each entry as the entry is made. Each entry in the BOT --  NEARBY list is the first bottom edge in the INPUT list at each such YSORT point. Y --  BOT --  VALUE is set to the YSORT value of the last entry in the BOT --  NEARBY list. When P --  NEARBYBOT points below NEARBY --  RANGE, then no more bottom edges will be added until the next fill is triggered. Every entry in the BOT --  NEARBY list having a YSORT point at or above YBOT has already been processed and, so, is deleted (3088) from the list. Once the BOT --  NEARBY list build is complete, it contains the information required to identify NEARBY --  BOTTOM edges during the fill. 
     
                       TABLE 3                                                     
______________________________________                                    
/* SUBROUTINE */                                                          
PROCESS.sub.-- NEARBY: PROC;                                              
/*    PREPARE OUR BOT.sub.-- NEARBY LIST FOR                              
      POSSIBLE ADDITIONS OF NEARBY.sub.-- BOTTOMS                         
      WITH NEARBY.sub.-- RANGE.sub.-- CHK OF YBOT */                      
NEARBY.sub.-- RANGE = YBOT -                                              
NEARBY.sub.-- RANGE.sub.-- CHK;                                           
Y.sub.-- BOT.sub.-- VAIUE = Y.sub.-- VALUE OF LAST BOTTOM IN              
BOT.sub.-- NEARBY LIST;                                                   
DO FOR (EACH Y VALUE THAT HAS BOTTOM                                      
EDGES WITHIN NEARBY.sub.-- RANGE) &amp; (IS NOT                               
ALREADY IN BOT.sub.-- NEARBY LIST);                                       
ADD AN ENTRY TO BOT.sub.-- NEARBY LIST FOR                                
THIS Y VALUE;                                                             
Y.sub.-- BOT.sub.-- VALUE =                                               
                  Y VALUE OF NEXT                                         
                  BOTTOMS BELOW PRE-                                      
                  VIOUS Y.sub.-- BOT.sub.-- VALUE;                        
IF Y.sub.-- BOT.sub.-- VALUE = BELOW NEAR-                                
BY.sub.-- RANGE THEN LEAVE;                                               
ELSE;                                                                     
END;                                                                      
END PROCESS.sub.-- NEARBY;                                                
______________________________________                                    
 
    
     After building the BOT --  NEARBY list, the region to be filled must be determined (310). P --  NEXTBOT points to the bottom edge that triggered the fill, which is also the first bottom edge in the INPUT list with its YSORT point equal to YBOT. P --  NEXTBOT is entered as the first entry in a list called the BOT --  PASS list (308). The single TOP --  CHAIN in the TOP --  CHAIN list over P --  NEXTBOT is identified (310) as the fill TOP --  CHAIN. So, TOP --  CHAIN 360 is identified as the TOP --  CHAIN over edge 205. As noted above, the region under the fill TOP --  CHAIN above YBOT is fully defined. That fully defined region is a fill region and the bottom edge that triggered the fill is a fill edge. Fill region 370 in FIG. 10B is the region under TOP --  CHAIN 360 and above the YSORT point of edge 205. Only areas in fill region 370 may be filled during the fill triggered by edge 205. Once the fill region has been determined, it must be partitioned into areas which shall be filled (fill areas) and areas which may be filled (optional fill areas). Since a shape may have more than one bottom edge at any YSORT point, when one of those bottom edges triggers a fill, they (the shapes&#39; s bottom edges at YBOT) are all fill edges and are identified before the fill region is partitioned. So, all other bottom edges at YBOT under the fill TOP --  CHAIN are identified (312) as fill edges and added to the BOT --  PASS list. In the example, however, shape 200 only has one bottom edge at any YSORT point. 
     Since the sort point for a side edge is the edge&#39;s upper end point, fill edges (205) may have side edges (204) extending downward from either end. Because these side edges are connected to a bottom edge they cannot be connected to a TOP --  CHAIN before the fill. Therefore, before the fill, every side edge connected to a fill edge having the same sort point as the fill edge is listed in a SAVE --  SIDE list. So, edge 204 is placed in the SAVE --  SIDE list. 
     In considering NEARBY --  BOTTOM edges, it is evident that not every bottom edge in the BOT --  NEARBY list can cause problems. Filling the entire fill region would create slivers only above the NEARBY --  BOTTOM edges that are part of the shape being filled and only above those NEARBY --  BOTTOM edges that are either partially or fully below the fill TOP --  CHAIN. All NEARBY --  BOTTOM edges under the fill TOP --  CHAIN, are identified (314) from the BOT --  NEARBY list and added to the BOT --  PASS list. In the preferred embodiment, the TOP --  CHAIN list, the BOT --  PASS list, the BOT --  NEARBY list, and the SAVE --  SIDE list, have entries of identical size so that entries may be passed between lists during a fill. 
     Once the fill region (310), the fill edges (312), and possible sources of future slivers have been defined, enough data has been processed to minimize (314) sliver creation in or below the fill region. So, the fill TOP --  CHAIN and the BOT --  PASS list are passed to the rectanL. gle generator. TOP --  CHAIN 360 and the BOT --  PASS list, consisting of edge 205, are passed to the rectangle generator. Any area in the fill region above a fill edge is a fill area and is filled by the rectangle generator (316). Area 370 in FIG. 10B is a fill area. Any area in the fill region which is not a fill area, is an optional fill area and may be filled (318) if conditions are favorable (320). Conditions are favorable (320) for filling optional fill areas if doing so does not create slivers or does not lead to creating slivers. Slivers could be created by filling an optional fill area if part or all of the optional area were shorter than a sliver. Filling an optional fill area could lead to creating slivers if a NEARBY --  BOTTOM edge is partially or completely below the optional fill area. Parts of the optional fill areas where conditions are favorable are favorable optional fill areas. Parts of the optional fill areas where conditions are not favorable are unfavorable optional fill areas. Occasionally, a sliver will be created regardless of whether or not an optional fill area is filled. In this circumstance, the optional fill area may be treated as a favorable optional fill area or treated as an unfavorable optional fill area. However, in the preferred embodiment, a comparison is made of the two alternative slivers which would be created by filling or not filling, and, based on that comparison the alternative which produces the largest sliver area is selected. Area 380 in FIG. 10C is an optional fill area. So, the rectangle generator must fill the fill area 372 and may partially or completely fill optional fill area 380. Alternatively, optional fill area 380 may be left unfilled for filling at a later bottom edge. 
     If the shape had been completely filled, then no TOP --  CHAIN would be returned to the TOP --  CHAIN list. If part of the shape remains unfilled then the fill TOP --  CHAIN must be truncated and returned to the TOP-CHAIN list. So, the portions of the fill TOP --  CHAIN which border filled areas are truncated from the fill TOP --  CHAIN by removing from the fill TOP --  CHAIN edges or portions of edges that bordered filled areas. After truncation, the portion or portions of the fill TOP --  CHAIN that remain may need to be further altered before being returned to the TOP --  CHAIN list. In FIG. 10d, TOP --  CHAIN 360 was truncated to edges 201 and 202&#39; because optional fill area 380 was left unfilled. 
     When a TOP --  CHAIN is truncated the part of the shape&#39;s perimeter which borders the filled area is removed. Removing part of the perimeter creates a gap in the perimeter internal to the shape along the internal side of the filled area. Connecting edges must be created to fill the gaps in the fill TOP --  CHAIN. Connecting edges are internal edges because they are internal to the shape being filled. In the preferred embodiment connecting edges are top or side edges only. Connecting edges connect the truncated fill TOP --  CHAIN to an end of a fill edge so that, the fill TOP --  CHAIN&#39;s borders all unfilled area and no longer borders any filled area. Connecting edges also connect the sides in the SAVE --  SIDE list to the fill TOP --  CHAIN. Truncating TOP --  CHAIN 360 in FIG. 10C created a gap between the truncated TOP --  CHAIN and edge 204. Connecting side edge 390 is connected to truncated TOP --  CHAIN 360 at 202&#39; to form a new partial TOP --  CHAIN. 
     Before returning to process the edges in the INPUT list, the side edges in the SAVE --  SIDE list must be processed. Since the side edges in the SAVE --  SIDE list were connected to fill edges before the fill, they will be connected to connecting edges after the fill. So, edge 204 was connected to edge 390 in figure 10d forming TOP --  CHAIN 361 from edges 201, 202&#39;, 390 and 204. Newly formed TOP --  CHAIN 361 is returned to the TOP --  CHAIN list. 
     If no software sleeving was required, 390 and 204 would have been combined into a single edge. If sleeving was to be done, then 390 would not have a sleeve rectangle placed along it. Before processing subsequent edges from the INPUT list, P --  NEXTBOT is updated. P --  NEXTBOT is set to point to the enxt bottome dges in the INPUT list which is also the first unprocessed bottom edges in the list. Initially, the next bottom edge is also the first bottom edge in the INPUT list. Table 4 is a program design language listing of what is done when a fill is triggered relative to the flow diagram of FIG. 7. 
     
                                           TABLE 4                                 
__________________________________________________________________________
/* SUBROUTINE */                                                          
PROCESS.sub.-- YBOT: PROC;                                                
/*                                                                        
  P.sub.-- NEXTBOT PTS TO THE FIRST BOTTOM EDGE FOR THIS                  
  YSORT VALUE (YBOT) IN THE INPUT LIST */                                 
/*                                                                        
  PROCESS BOTTOM EDGES AT YBOT - WE CAN IDENTIFY BOTTOM EDGES             
  BY THE -- FORWARD LINK TO NEXT BOTTOM -- FIELD */                       
/*                                                                        
  BUILDS THE BOT.sub.-- PASS LIST OF BOTTOMS AT YBOT AND                  
  NEARBY.sub.-- BOTTOMS UNDER A PARTICULAR TOP.sub.-- CHAIN TO PASS       
  TO THE RECTANGLE GENERATION PROGRAMS. */                                
DO WHILE (NEXTBOT.YSORT = YBOT);                                          
PROCESS &#34;BOTTOM EDGE SITUATION&#34; BASED ON P.sub.-- NEXTBOT AND THE         
EDGE(S) THAT COULD CONNECT (BEFORE AND/OR AFTER P.sub.-- NEXTBOT IN       
THE INPUT LIST). STORE P.sub.-- NEXTBOT IN BOT.sub.-- PASS LIST.          
FIND THE TOP.sub.-- CHAIN &#34;OVER&#34; P.sub.-- NEXTBOT.                        
FIND ANY OTHER BOTTOMS AT YBOT THAT ARE UNDER THIS TOP.sub.-- CHAIN.      
ADD ANY ATTACHED SIDE (LEFT, RIGHT) EDGES THAT ATTACH TO BOT-             
TOMS IN BOT.sub.-- PASS AT YBOT TO SAVE.sub.-- SIDE LIST.                 
PROCESS THRU BOT.sub.-- NEARBY LIST TO ADD ANY UNIQUE OR PIECES OF        
NEARBY.sub.-- BOTTOMS TO BOT.sub.-- PASS LIST.                            
CALL RECTANGLE GENERATING PROGRAMS                                        
(CALL RECTANGLE GENERATING PROGRAMS PASSING                               
THE TOP.sub.-- CHAIN AND BOT.sub.-- PASS LIST. THESE                      
PROGRAMS WILL FILL ENTIRELY ABOVE ANY BOTTOM                              
IN BOT.sub.-- PASS LIST AT YBOT. ANY OTHER AREA                           
UNDER THE TOP.sub.-- CHAIN BUT NOT DIRECTLY ABOVE A                       
BOTTOM IN BOT.sub.-- PASS LIST AT YBOT IS AN                              
&#34;OPTIONAL&#34; AREA TO BE FIILED IF &#34;FAVORABLE&#34;                               
RECTANGLE GENERATIONS EXIST. &#34;FAVORABLE&#34;                                  
RECTANGLE GENERATION IS ABSENCE OF SLIVERS AT                             
THIS POINT AND FUTURE POINTS. WHAT IS                                     
RETURNED IS THE UPDATED TOP.sub.-- CHAIN(S) TO                            
REFLECT THE PARTIALLY FILLED TOP.sub.-- CHAIN SENT.                       
IF THE TOP.sub.-- CHAIN SENT IS TOTALLY FILLED THEN NO                    
TOP.sub.-- CHAIN WILL BE RETURNED.)                                       
ATTACH ANY CONNECTING SIDE EDGES IN SAVE.sub.-- SIDE LIST                 
TO TOP.sub.-- CHAIN(S) RETURNED.                                          
UPDATE P.sub.-- NEXTBOT TO POINT TO THE NEXT BOTTOM EDGE --               
P.sub.-- NEXTBOT = NEXTBOT.FORWARD LINK TO NEXT BOTTOM --                 
MAY CHANGE NEXTBOT.YSORT.                                                 
END; /* END DO WHILE (NEXTBOT.YSORT = YBOT) */                            
END PROCESS.sub.-- YBOT;                                                  
__________________________________________________________________________
 
    
     If the next bottom edge is above the END --  OF --  DATA edge, then processing continues (322) on the edges in the INPUT list. If the next bottom edge were the END --  OF --  DATA edge then the level would have been completely filled and processing would have ended (324). 
     For the example, shape 200 was to be sleeved, so, edge 204 was removed from the SAVE --  SIDE list and P --  NEXTBOT was pointed to edge 209. The next 2 edges processed were 206 and 207, a top and a side edge. The TOP --  CHAIN list was searched to find the TOP --  CHAIN (361) that connected to 206, and edges 206 and 207 were added to the rightmost side of TOP --  CHAIN 361. FIG. 10e shows resulting TOP --  CHAIN 362 which was placed in the TOP --  CHAIN list. When edges 208 and 209 were processed, bottom edge 209 triggered a fill. The TOP --  CHAIN list was searched to find the TOP --  CHAIN over bottom edge 209. TOP --  CHAIN 362 was identified and edge 208 was placed in the SAVE SIDE list. Since bottom edge 210 was within the nearby range of edge 209, edge 210 was identified as a NEARBY --  BOTTOM edge and added to the BOT PASS list. TOP --  CHAIN 362 and BOT --  PASS list edges 209 and 210 were passed to the rectangle generator. In FIG. 10f the rectangle generator filled fill area 374. Optional fill area 381 was not filled because doing so would have led to an unfavorable fill above NEARBY --  BOTTOM bottom edge 210. Therefore, 381 was an unfavorable optional fill area. The fill region was partitioned into the areas of fill area 374 and unfavorable optional fill area 381. With only fill area 374 filled, the TOP --  CHAIN was truncated to 201, 202&#39;, 390, 204 and in FIG. 10g another connecting side edge, 391, had to be added. The TOP --  CHAIN consisting of edges 201, 202&#39;, 390, 204 and 391 was returned to the TOP --  CHAIN list. 
     INPUT list processing continued and TOP --  CHAIN 363 in FIG. 10g was built when edge 208 was added to the truncated TOP --  CHAIN. TOP --  CHAIN 363 was placed in the TOP --  CHAIN list. Again, if no software sleeving was required, then edges 390, 204, 391 and 208 would be combined into a single edge. Processing bottom edge 210, the final bottom edge before the END --  OF --  DATA edge, triggered a fill. The TOP --  CHAIN list was searched to find TOP --  CHAIN 363, the TOP --  CHAIN over bottom edge 210. Since edge 210 was the entire bottom for TOP --  CHAIN 363, the entire fill region was a fill area. TOP --  CHAIN 363 and BOT --  PASS edge 210 were passed to the rectangle generator. The fill area, 376 in FIG. 10h, completely covered the fill region and, so, the remainder of the shape was filled. No TOP --  CHAIN was returned. P --  NEXTBOT was set to point to the END --  OF --  DATA edge. The fill was done (326) in a single pass. Every bottom edge on every shape in the design was filled with fill rectangles and, therefore, every shape had been filled. 
     The fill rectangles would be converted to commands used to control the e-beam tool to write the design onto a radiation sensitive layer on a semiconductor wafer. In contrast to the prior art fill method, the shape of FIG. 6, when filled according to the preferred embodiment, had slivers minimized and an optimum fill in a single pass. Consequently, because the presence of slivers is minimized in shapes filled according to the preferred embodiment, both manufacturing yield loss and premature chip failure are minimized. Also, since the time required to post process a design according to the preferred embodiment is reduced, more shapes (and as a result more circuits) may be placed on a semiconductor chip. 
     As noted above, the prior art fill can lead to unfavorable cutting of slanted edges. For example, shape 400 in FIG. 13A has an angled edge (402) and FIG. 13B depicts how shape 400 would be filled by the prior art fill method. Edge 402 is segmented at points 404 and 406. Each of the resulting edge segments is a different size, and triangular areas 408, 410, and 412 are unequal. A fill of one triangular area is different than a fill of another. If the fill had resulted in segmenting edge 402 into equal segments, then the same fill staircase could be used for each triangular area and the resulting edge would be uniform. 
     The preferred embodiment provides a fill which may be altered to avoid unfavorable cutting of angled edges. Filling shape 400 according to the preferred embodiment produced the fill of FIG. 13C. Edge 402 was segmented into 4 equal segments at points 420, 422, and 424. Triangular areas 426, 428, 430, and 432 are identical. 
     The same fill used for 426 could be stored, recalled&#34; and then repeated for 428, 430, and 432. 
     While what is considered to be the preferred embodiment of the invention is herein described, variations and modifications thereof will occur to those skilled in the art. Therefore, it is intended that the appended claims shall be construed to include the preferred embodiment and all such variations and modifications in form and detail that fall within the spirit and scope of the invention.