CA2069446C - Scanner to combine partial fragments of a complete code - Google Patents

Abstract

A scanner (100) can read machine-readable code (86) on an object. A scanner has a scanning device, a data device, and a registration device. The scanning device can repetitively scan the code and provide a scan signal repetitively corresponding to at least fragments of the code (86). The data device is coupled to the scanning device and responds to its scan signal for repetitively storing it. The registration device is coupled to the data device for reconstructing the code from at least two of the fragments of the code by relatively shifting the code fragments until they arc in registration (103).

Description

~~9446:~
SCANNER TO COMBINE PARTIAL FRAGMENTS OF A COMPLETE CODE
BACKGRQUND OF THE INVENTION
The present invention relates to code scanning devices and, in particular, to apparatus and methods for restoring a code from differing code fragments.
Well known equipment exists for reading a bar code that is printed on a package. Bar codes on merchandise may be scanned at the point of sale to identify the goods and correlate them to a price. Such equipment is commonly used at supermarket checkout counters.
A basic principle conventionally applied in bar code scanning is that of detecting reflected light contrasts. A
source of illumination such as a low powered helium neon laser, can produce a beam which is moved across the bar code.
Dark areas (bars) absorb laser light, whereas light areas (spaces) reflect light that is subsequently detected by the scanner.
Optics are used to "move" a laser beam. Without these optics, the laser beam appears as a dot. When the optics are used, the beam appears as a line of laser light.
This is defined WO 92/05516 PGT/US91/0687~
'~1I

as moving-beam scanning. As the moving beam "travels" across the conveyor (or area to be scanned for a code, commonly called the scanning zone) any light or dark transitions are detected and converted to a digital signal known as code. A valid bar code consists of a defined number of light and dark transitions with correct ratios between the Wide and narrow intervals.
Existing codms consist of a series of ~rallel bars separated by spaces. The bars and spaces are printed at either a full width or half width. The bars and spaces may signify a bit pattern wherein wide spaces or bars are denominated a "one" while narrow spaces and bars are denominated a "zero" (or vice versa).
A basic objective in known bar code scanning is laying Sown a trace that is dense and varied enough to ensure that at least one scan will recover a complete bar code. The denser the scanning, the more rapidly scanning must occur and, therefore, a higher demand is placed upon the circuitry processing the scanned data.
Known equipment (for example, U. S. Patent 3,728,677) employs a mirrored wheel having a polygonal periphery. Rotation of the mirrored wheel scans a laser beam across two azimuthally spaced mirrors which deflect the beam downwardly to trace an "X"
shaped pattern .
Other known equipment has used prisms, mirrors, vidicons, or other apparatus to turn the scan direction of an optical code scanning system. (See, for example, U.S. Patents 3,663,800: 3,774,014: 3,800,282: 3,902,047: and 4,064,390).

WO 92/05516 ~ ~ ~ ~ ~ ~ P~/US91/06876 It is also known (U.S. Patent 3,906,203) to scan a bar code and measure its interval widths by recording the time required to traverse each interval. The successive interval widths are multiplied by three, five, and eight. By storing and comparing the multiplied widths of successive scans, the equipment can determine whether the latest interval is about the same size as, or much smaller or larger than, the prior interval.
This equipment, however, performs a relatively coarse comparison and will accept as valid, scan times that are excessively short or long.
Accordingly there is a need for a code scanner that does not require support from extraordinarily high speed circuitry, but yet has a high probability of obtaining a complete code when an object passes by the scanner.
~~ARV Og T~ INVENTION
In accordance ~rith the principles of the present invention, a scanner is provided for reading machine-readable code on an object. The scanner includes a scanning means, a data means, and a registration means. The scanning means can repetitively scan the code and provide a scan signal repetitively corresponding to at least fragments of the code. The data means is coupled to the scanning means and responds to its scan signal for repetitively storing the scan signal. The registration means is coupled to the data means for reconstructing the code from at WO 92/05516 ~ ~ ~ ~ ~ ~ ~ PCT/US91/068~

least two of the fragments of the code, by relatively shifting them until they are in registration. Thus, one of the fragments provides a first portion of the code and the other a second portion. Both fragments provide a registered middle portion of the code.
In accordance with the princip7.es of the same invention, a related method is provided for reading machine-readable code on an object. The method includes repetitively scanning the code and obtaining at least fragments l0 of the code. Another step is repetitively recording the fragments of the code. The method also includes the step of reconstructing the code from at least two of the fragments of the code, by relatively shifting them until they are in registration.
Thus, one of the fragments provides a first portion of the code and the other a second portion, both providing a recJistered middle portion of the code.
By employing methods and apparatus of the foregoing type, an improved scanner is provided. In a preferred embodiment, the scanner can begin operation when an object passes a checkpoint. Preferably, an optical scanner measures the distance between transitions from light to dark and dark to light. These distances between transitions are assigned numeric values based upon a timing process. A preferred "digital filter" .
compares the numeric values of successive interval widths.
Depending upon the pattern of the interva3. Widths, a pattern detecting process determines whether the measured Widths are to be considered wide or narrow. For example, a ratio test may be used to determine if the widths are part of a pattern that may be a segment of a bar code.
All segments of "n" transitions (a value that can be set by software) or more that pass this ratio test are stored as a pattern of wide and narrow values for a subsequent reconstruction process. Patterns of less than five transitions are rejected. If no pattern has a code that is sufficiently long to be considered valid, the preferred apparatus attempts to l0 reconstruct code fragments into a complete bar code pattern. The fragments are compared to each other in consecutive order. The fragments are overlaid, shifting each subsequent segment until the wide and narrow patterns of the segments match or register.
When a complete bar code pattern has been reconstructed from two or more fragments, a microprocessor can decode the reconstructed bar code and verify that its checksum is valid.
In a preferred embodiment, the code is scanned optically by a pattern of staggered "X" shaped traces. These staggered scans may be centered at the vertices of a triangle.
By using three "X" shaped patterns a pattern of modest complexity is used, which has a high probability of obtaining a full bar code. But if only a fragment of a bar code need be obtained, the probability is nonetheless high that subsequent fragments will be able to reconstruct the full bar code.

- 5a -In accordance with one aspect of the present invention there is provided a scanner for reading machine-readable code on an object, comprising: scanning means for repetitively scanning said code and for providing a scan signal repetitively corresponding to at least fragments of said code;
data means coupled to said scanning means and responsive to its scan signal for repetitively storing said scan signal; and registration means coupled to said data means for reconstructing at least a portion of said code from at least two of said fragments of said code including means for identifying matching portions of said two fragments, and means for shifting said two fragments relative to one another until said matching portions are identified in registration.
In accordance with another aspect of the present invention there is provided a method for reading machine-readable code on an object, comprising the steps of:
repetitively scanning said code and obtaining at least fragments of said code; repetitively recording said fragments of said code; and reconstructing said code from at least two of said fragments of said code by identifying matching portions of said two fragments, and shifting said two fragments relative to one another until said matching portions are identified in registration.
.:.r.< ~i "'.s -,3 6 ~ 0 6 9 4 4 6 PCT/US91/06876 _ 6 ~FZIEF DESCRIPTTON''OF THE PREFERRED EMBODIMENTS
The above brief description as well as other objects, features and advantages of the present invention will be more fully appreciated by reference to the following detailed description of presently preferred but nonetheless illustrative embodiments in accordance with the present invention, with reference being made to the following figures in which:
Fig. 1 is a schematic perspective diagram of a scanning means that may be used in an embodiment of the present invention:
Fig. 2A is a plan diagram of the scans produced by the apparatus of Fig. 1:
Fig. 2B is an elevational view of a scanner employing the scanning means of Fig. 1:
Fig. 3 is a schematic block diagram of the data means and registration means that may be used in an embodiment of the present invention:
Figs. 4A and 4B are timing diagrams illustrating signals associated with the apparatus of Fig. 3;
Fig. 5 is a plan diagram showing successive scans across a bar code:
Fig. 6 is a state diagram associated with the pattern detecting circuitry of Fig. 3;
Fig. 7A is a flow chart showing in a general way the sequence of operations of the state means of Fig. 3;
Fig. 7B is a flow chart schematically illustrating the 2Q~~:~~

sequence of operations of the microprocessor of Fig. 3;
Fig. SA is a block diagram which schematically illustrates the code scanning system shown in Figs. 1 to 7;
Fig. 8B is a block diagram which schematically illustrates an alternative embodiment code scanning system in accordance with the present invention; and Figs. 9A and 9B are block diagrams of information processing portions of the alternative embodiment system shown in Fig. 88.
DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS
Referring to Fig. 1, it illustrates a scanning means employing a source 10 in the form of a laser beam producing through lenses 12 and 14, a narrowly focused coherent beam of light. hens 12 can be axially shifted by a galvanometer 98 which is part of a dynamic focussing system, described in further detail hereinafter. Briefly however, larger objects scanned by this system appear closer to the scanner while smaller objects appear further away. By dynamically focussing with lens 12, relatively fine bar codes can be clearly examined by the scanner.
For example, for code resolution of O.O1 inch, object size is measured by quantizing its size into three inch zones. For each zone transition, lens 12 is axially adjusted 0.001 inch. Of course the specific dimensions applicable in other embodiments will depend upon the specific of the optics employed.

g _ The beam is reflected by mirrors 16 and 18 and passes through aperture 20 in beam splitting mirror 22. The beam is thus directed to the periphery of a deflecting means, shown herein as a rotating mirrored wheel 24. Wheel 24 has twelve, peripheral, mirrored facets, each acting as a rotating mirror.
Wheel 24 is driven by a motor (not shown) that determines the scan speed of the laser beam.
After reflecting from wheel 24 (and depending on the angle of the reflected beam), the beam is then reflected from one of the faces of a pair of non-coplanar mirrors, shown herein as first and second contiguous mirrors 26. These mirrors 26 are in the shape of a folded mirror having an obtuse angle facing wheel 24. Accordingly, a beam deflected by wheel 24 can traverse the peak of mirrors 26 and be reflected right or left to intercept either mirror 28 or 30, respectively. Depending upon which path is taken by the laser beam, one or the other branches of "X"
pattern 32 is produced. As illustrated by returnincJ rays 34, light may return along the original path of the outgoing laser beam and be reflected again onto mirror 30 (or mirror 28).
Thereafter the returning laser light is reflected by mirrors 26, 24, and the reflecting side of beam-splitting mirror 22, before reaching a collector lens 36. The light thus collected is focused by lens 36 onto sensor 38 to measure whether a dark or light interval is being scanned.
The foregoing describes the path for one scan of half of an "X" shaped pattern. The same principles apply to the ~0~~~~~

_ g _ functioning of the other half of the pattern. In operation, the mirrors are used to split the single scan line into two parts.
As the mirror wheel 24 rotates at high speed, beam handling mirrors 26, 28 and 30 cause two lines of the "X" pattern to alternate rapidly. For example: five facets of the mirror wheel at a slow speed would appear as "\ / \ / \". When projected at high speed, the "X" pattern becomes visible.
The scan head of Fig. 1 will be supplemented with additional mirror systems to produce three "X" patterns and each l0 will have separate processing electronics of the type described hereinafter. Accordingly, only one "X" pattern need be processed by one circuit. In this preferred embodiment, mirrors 20, 26, 28 and 30 are twice replicated, so that three mirror systems are placed at positions spaced 90 degrees apart. By using three lasers, three separate °'X" shaped scans can be produced.
Figs . 2A and 2B show three scans '°X" I , "X°' II , and "X"III produced by three optical systems each as shown in Fig.
1. In a preferred embodiment, the line of an "X" shaped pattern has a length terminating at A and B, for the usable length (80%
efficiency) and effective line length, respectively. These two lengths are for objects placed at 28 inches from the scanner.
The terminus C represents the total physical line length for an object placed at 42 inches from the scanner of Fig. 1. The spacing L1 in the direction of travel, between scan "X"I and "X°'II, is 2 3/4" in the preferred embodiment. The effective length L2 of scan line A along the direction of travel is WO 92/05516 ~ Q ~ ~ PCT/US91/06876 preferably 6 2/3". The length L3 in the direction of travel is about 16". In this embodiment, the pattern to pattern spacing W1 between "X" patterns in a direction perpendicular to the direction of travel is 4 2/3". Preferably, the usable width W2 along a conveyor would be 16".
The cart signal is derived from start and end cart photoeyes 40, 41. In 'this embodiment, caZ~-t photoeyes 40, 41 cover an optical path which when interrupted by an object moving in the direction of travel, produces a signal indicating the need to commence scanning. The spacing of photoeye 40 from endpoints B of patterns "X°'II and "X'°III (spacings Ml and M2) are set to ensure complete scanning of the coded object. It will be appreciated, however, that all of these dimensions can change depending upon the size of the code and the relative uncertainty of the placement or distance of the object or the code on the object to be scanned. _ A typical scanning system will employ a mirror wheel with the mirrors on two adjacent sides used to produce the other two "X" patterns in Fig. 2. By using two "X" scanners, a conveyor can be covered with six "X°' patterns, and a scanning zone is created to ensure that bar codes located on products travelling the conveyor will be intercepted by one or more of the scanning lines. w As shown in Fig. 2B, the scanner can be contained in housing S and supported by bracket BR mounted on platform P above working surface W. For a large spacing between platform P and WO 92/05516 PG'T/US91/06876 _ a work surface W, there is a large depth of field required for laser focussing. Accordingly, the height of an object is determined by the zone detector Z. Relatively small objects will not intercept any of the beams associated with photoeyes Z1-Z7.
The next larger class of objects will intercept the beam associated with photoeye Z1. Successively larger objects will intercept the beams of the other photoeyes, the largest object intercepting all photoeyes. Zone detector Z produces in response a digital signal indicating the number of zones intercepted. The l0 zone to zone spacing depends on the fineness of the bar codes being examined. For example, an interleaved 2 of 5 barscode with 0.01 inch minimum bar would require the photoeyes to be placed three inches apart from each other. If the code had a minimum bar size of o.02 inch, the photoeyes would be placed five inches apart.
Referring to Fig. 3, a registration means is shown herein as microprocessor board 42 which, in this embodiment, employs a microprocessor chip such as a type 80286 manufactured by Intel. Microprocessor board 42 is shown coupled to three data means: data means 44 and 46, the third data means being more elaborately illustrated. The third data means is the balance of the system, excluding blocks 42, 44 and 46. In this embodiment, microprocessor board 42 has its own internal memory. In addition, each data means includes a common memory means shown herein as dual part, random access memory 48. Memory 48 has one port constituting data bus DA and address bus AD, both buses WO 92/05516 PCT/US91/0687~

coupled between microprocessor board 42 and common memory 48.
The other port comprises data bus DATA and address bus ADR. The dual port memory can be a high speed RAM (SRAM) having one kbyte (type IDT7130).
It will be noted that the buses DATA and ADR allow the automatic updating of code data and string qualifier data into RAM 48 without the intervention of microprocessor board 42. This frees microprocessor board 42 and allows for a very high speed update of code data without being limited by the speed of board 42.
A counter 50 is shown connected to clock input CLK to count it. Counter 50 has a capacity and speed determined by the desired resolution and scan speed. As further described hereinafter, counter 50 is enabled by terminal CART*SCAN during a scan, after an object is detected by the cart photoeyes (elements 40, 41 of Fig. 2A). The count is detena:ined just before the counter is cleared by the transition signal on terminal DEC2.
The count accumulated in counter 50 is loaded into the first register 52A, an eight bit data latch, by the transition signal on terminal DECl in synchronism with the clock input on terminal CLK3. Register 52A is cascaded with registers 52A and 52B which are interconnected to shift data from register 52A downstream, that is, to registers 52B and 52C.
The data loaded into register 52A are compared to an upper and lower limit through limit devices 54A and 548, respectively, to signal an out-of-range condition. Second and WO 92/05516 ~ ~ ~ ~ ~ PGT/US91/06876 third registers 52B and 52C each have their outputs connected to separate inputs of multiplexers 56 and 58. The output of multiplexes 56 is applied to the data input of a quantizing means which is shown herein as a programmable read only memory 60, organized to act as a look-up means. Memory 60 is actually composed of six sections. Each section responds to the common data input to produce a signal which signifies a tolerance limit.
The limits are three pairs each centered about a nominal value with a predetermined tolerance. off that nominal value. The three nominal values are the input value multiplied by one, one-half or two. As explained in further detail hereinafter, these tolerances around the nominal values, allow comparison of successive latched values to determine whether successive scanned intervals are the same, greater or less than the proceeding interval of the code.
The three pairs of data limits of the look-up means 60 are applied to separate inputs of a comparator means 62.
Comparator means 62 has six digital comparators that compare the output of first register 52A against each of the six limit values from memory 60. Accordingly, the recent output of first register 52A can be bracketed (or found not to be bracketable) within limits established by memory 60 as a function of the earlier values (stored in either second register 528 or third register 52C). The bracketed values are indicated by the six output lines of comparators 62.
The outputs of comparators 62 are applied to a pattern WO 92/05516 ~ ~ ~ ~ ~ /~ ~ PCT/US91/tD687~

means shown herein as pattern detecting machine 64. In a preferred embodiment, patterri detecting machine 64 includes a XILINX logic configurable array type XC2064. This array is a 68 pin CMOS programmable gate array. Such an array allows implementation of a substantial amount of logic in one integrated package. This high speed circuit is able to detect bar widths as small as four hundred nanoseconds.
As described in further detail hereinafter, pattern means 64 is a nine state machine whose state is determined, in l0 part, by the inputs from comparators 62. The other terminals of pattern means 64, CODE, WRxiJ, CNTZ, XTNDEC, SCAN, CLK and DEC, correspond to: the state of the optical scan (light or dark), the end of a scan, a clocking event, an extended pulse synchronous with a code transition, the start of a scan, the clock pulse and a non-extended code transition ~.gnal, respectively. Pattern machine 64 provides a pair of outputs to control the state of multiplexers 56 and 58. The control signal of multiplexes 56 is also connected to one input of memory 60.
Art important feature of pattern means 64 is the register means 66. In operation, the logic array of pattern means 64 can set certain data bits. As explained hereinafter, the successive bits detected in a scanned bar code are stored by the pattern means in register means 66 before being transmitted to dual port memory 48.
Pattern means 64 produces outputs on five control lines 68 to a state means 70 having a logic array similar to that of ' PCT/US91/06876 _ L5 _ pattern means 64. In addition, in this embodiment, state machine 70 (operating as a control signal state machine) employs three programmable logic arrays (PALS) to enable the various other devices illustrated herein. Control is effected over control lines 72. The three PLD's in state machine 70 include one type PAL16R6 and two type PAL16L8 devices. The type PAL16R6 device is an array with registered outputs that is used to generate twenty-three different states that are synchronous with the system clocks. These states are coded by five binary bits that are the outputs to the combinational logic. Two type PAL16L8 devices are used here to implement the combinational logic based strictly on the state that the state machine 7o is in.
The outputs are a function of only the current state.
Thus, this design may be deemed a Moore machine; that is, the outputs are dependent on the previous input history as held in this state, but are not directly affected by input values. For this reason, a totally synchronous control circuit is used to insure freedom from timing problems.
Control lines 72 include four inputs to dual port RAM
48. Enabling signals are also provided along lines 72 to empty means 74. Means 74 includes a counter and latch so that the total number of bad scans as read on terminal BAD SCANS can be written onto data line DATA.
A position means is shown herein as label position counter 76, a latched counter enabled by control lines 72. An input is provided from state machine 70 along line 72 digitally WO 92/05516 ~ ~ ~ ~ ~ ~ ~ PCf/US91/~687E~

signifying the position where the valid scanned code ends. The count stored on counter 76 can be written onto bus DATA.
A scan means, shown herein as scan number counter 78 is 4~
incremented at the start of.each scan and enabled by line 72 from state machine 70. Means 78 is latched so its count can be written onto data bus DATA.
The length of the string stored in register means 66 is loaded by state machine 70 into string length counter 80.
Counter 80 also provides the facility for counting the consecutive number of transitions where the ratio of. interval widths is one. Counter 80 also has a data output to data bus DATA.
A narrow means is shown herein as latch 86, which stores the data outputs from multiplexer 58. As will be explained hereinafter, the value stored is a value corresponding to the width of a narrow interval as measured by counter 50. The output of narrow means 86 is coupled to data line DATA.
An address means is shown herein as string data counter 82 and low string qualifier counter 84. The outputs of counters 82 and 84 ate connected to address bus ADR to indicate a location in dual port RAM 48 where data is to be stored. String data counter 82 is used to point to a location for storing the code bits of register means 66. Counter 84 is used to point to a location in RAM 48 for storing the counts of counters 74, 76, 78 and 80.
A focussing means is shown herein as latches 85 coupled WO 92/05516 ~ ~ ~ ~ ~ ~ ~ PCT/US91/06876 to zone detector Z (Fig. 2B) and galvanometric focussing device '' 98 (Fig. 1). When interrogated by microprocessor 42, means 85 transmits a signal corresponding to the highest zone number intercepted by the object carrying the bar code. When a focussing number is transmitted by microprocessor 42, a latch (not shown) in means 85 is set. This setting is converted by a digital to analog converter (not shown) to an analog signal that drives the galvanometer in focussing means 98 (Fig. 1).
Accordingly focussing of the laser is accomplished under l0 processor control. To facilitate an understanding of the principles associated with the foregoing apparatus, its operation will now be briefly described. With laser 10 (Fig. 1) illuminating mirror wheel 24, the "X" pattern 32 is traced.
Reflected light and dark bars of a code that fall within "X"
pattern 32 are reflected back to photo detector 38. As shown in Fig. 5, successive scans from one branch of "X" pattern 32 can traverse bar code 86 to produce a code signal.
Referring to Fig. 4A, the previously mentioned clock signal CLK is shown as a number of high frequency square pulses.
The response of photo detector 38 in the scanner of Fig. 1 is indicated as the output CODE in Fig. 4A. A D-type flip flop (not shown) is triggered by the clock input CLK to hold the data indicated by signal CODE. A synchronous code signal is indicated as signal SYNCODE in Fig. 4A. The signal SYNCODE is combined with the clock signal CLK to produce a single pulse DEC1 which begins at the rising edge of signal SYNCODE and ends one clock WO 92/05516 P~CT/US91/06876~

pulse period later. A following pulse in signal DEC1 is produced in a similar fashion following the falling edge of signal SYNCODE. Transition signal DEC2 is a pulse delayed by one clock pulse period from signal DEC1. The relationship between signal CODE and transition signals DEC1 and DEC2 are shown on a larger time scale in Fig. 4B.
Referring to Fic.~. 3, a code transition causes terminal DEC1 to latch the current count of counter 50 into register 52A.
One clock pulse period later, the pulse on terminal DEC2 clears l0 counter 50. Thus, at each code transition a new count is stored and then cleared so that a subsequent interval can be measured.
It will be noted that any values stored in registers 52A and 52B
are first transferred to registers 528 and 52C, respectively.
Therefore between successive transitions, counter 50 counts the width of the interval detected by the scanner of Fig. 1. After each transition, the counts then ripple through registers 52A, B
and C. Thus, registers 52A, B and C can he considered snapshots of the last three interval widths as determined by the scanner of Fig. 1.
Once register 528 has been loaded, a comparison can take place. Initially, register 52B is connected through multiplexes 56 to memory 60 to generate six outputs: the input multiplied by 1/2 -20%, 1/2 +20%, 1 -20%, 1 +20%, 2 -20%, 2 +20%
(0.4, 0.6, 0.8, 1.2, 1.6 and 2.4). These values are used to determine if the previous count in counter 52B is about half, equal or double the currently latched count in register 52A.

~I WO 92/05516 ~ ~ ~ ~ ~ ~ PCT/US91/06876 Thus, the memory 60 is used to set a 20~ window or tolerance around each value.
The bottom line (Counts) of Fig. 4B, and Table 1 illustrate how the counter values latched into registers 52A, B
and C are stepped through the registers so that bars can be compared to bars and spaces to spaces. Using scan 28 of Table 1 as an example, register 528 would contain a count of 19. The outputs of memory 60 would then be 8, 12, 16, 24, 32 and 48. The value in register 52A is compared against the value of register 52B in this case a first bar (1B) is compared against~a first space (1S). The eighteen count value of register 52A falls, therefore, between a pair of values from memory 60, namely, 16 and 24. In response, the states of comparators 62 would indicate this bracketing to pattern means 64. It will be noted that a bar is compared to a space only in the initial phase when insufficient data is available to compare like intervals.
Comparing like intervals is more desirable since in practical embodiments of printed bar codes, the width of bars will tend to be equal as will the width of spaces. But bars and spaces will 2o not necessarily have the same width.

WO 92/05516 PCT/US91/0687~

SCAN LATCHES CODE PATTERN

TYPE SIZE REGIS CdMPARE DATA
A
B
C

1 B 19 MS B' LS B

aB 21 19 42 7 00000010 3S - 4S 02 The pattern means es what binary values determin should be loaded into the code pattern register 66 in response to the six outputs comparator of 62.
the Regardless of the width of the fir st interval, zerois initially written into register 66, a designating the first bar as a zero. The first interval would be subsequently defined as a one by pattern means 64 if the following space was half the value.
After the next bar is received, the data is shifted in registers 52A, B and C, in response to the transition signal on terminal DEC1. Thereafter, the value of register 52C can be compared with the value of register 52A. This process enables bars to be compared with bars and spaces with spaces.
After each comparison, the pattern means 64 determines from the previous state what to load into register 66 (either a zero or a one). A zero represents a narrow bar or space and a one indicates a wide bar or space. When eight bits of information are shifted into register 66 (creating a byte), the information is written into the dual port RAM memory 48 by the state means 70. In the example of Table 1, the first byte written is 02 (hex). The second byte is 33 (hex).
Fig. 6 illustrates the pattern detecting algorithm of the pattern means 64. The machine is a synchronous state machine. A bar or space is compared to an adjacent or alternate bar or space. If the ratio is either equal, half or twice (within tolerances), then a valid pattern is found. A pattern is invalid if none of the above comparisons are true (nothing is stored for invalid patterns). If the number of consecutive valid ratios exceeds five (up to eight) the numerical representation of these patterns, that is a binary string of ones and zeros, is saved in memory.

WO 92/05516 PCT/US91/0687~

Because of the nature of the algorithm, the pattern detecting means 64 is highly fault tolerant. A variable error margin set by memory 60, is incorporated with the digital comparator circuit 62 to allow more flexible comparison of the width of bars and spaces. Because of this comparison, it is possible for a bar to vary from another bar by a large percentage and still be recognized a~ part of a valid pattern. In most cases, a bar is compared only with a bar and a space only with another space. This is important because most bar code label, printing is breached, causing the width of the bar to vary considerably with the width of the space.
As shown in Fig. 6, the pattern means 64 (Fig. 3) has a total of nine unique states, labelled A-I. Pattern means 64 operates on an asymmetric clock identified as terminal XTNDEC
(Fig. 3), a pulse generated on each transition between intervals and extended for five clock cycles. The operation of the pattern means 64 can be divided into two halves because only one half of the machine is active at any instant, either the left or right half. Fig. 6 clearly shows the two halves being symmetrical.
The left half consists of states C, E, G and I while the right half contains states B, F, D and H. The right half of the pattern means 64 is used if the first bar scanned is determined to be narrow. Otherwise, the left half is active.
The function of each state is described below:
State A: Power-on State. Also occurs if comparison is equal in this state or if any undefined comparison occurs.

WO 92/05516 PC'T/US91/06876 State F: Comparison is twice in state A, state B, or comparison is equal in state H. Also, comparison is twice AND
WINDOW is low (i.e.: no string of more than four transitions is found, no data stored) in state D or state C.
State D: Comparison is twice in state F or comparison is equal in this state.
State H: Comparison is equal in state F or comparison is half in state D.
State B: Comparison is half in state H or comparison l0 is equal in this state.
State G: Comparison is half in state A, state C, or comparison is equal in state I. Also, comparison is Halt ANt~
WINDOW is low (i.e.: no string of more than four transitions is found, no data stored) in state E or state B.
15 State E: Comparison-is--half i~--state-G or compa~isor.
is equal in this state.
State I: Comparison is equal in state G or comparison is half in state E.
State C: Comparison is twice in state I or comparison 20 is equal in this state.
ZOUT: The signal ZOUT is the output signal from the state machine. A "one" will be shifted into the shift register for a wide interval, and a ''zero" will be shifted in for a narrow interval. (A "one" means a wide interval.) 25 In addition to the functions described above, the LCA
of pattern means 64 also contains several timing signals to load counters and store data.

WO 92/05516 ~, ~ ~ ~ ~ PGT/LJS91/0687~

SCAN DATA STRING NARROW LABEL BAD
1 (NO DATA) LENGTH VALUE POSITION SCAN

3 02 33 15 99 ~50 0 4 02 66 A5 22 20 ~50 O
5 13 34 A7 9C 26 99 ~50 0 6 9A 53 81 06 26 20 ~50 0 7 94 EO OC 21 99 ~45 0 9 OC 07 99 ~35 0 State machine 70 (Fig. 3) writes latched data bytes from various registers into dual port RA1~ memory 48. This memory is accessed at the same time by microprocessor board 42 which permits high speed operation. While the state machine 70 stores the current data from the present scan in port ADR, DATA, the stored data from the previous scan is read by the microprocessor board 42 at the other port DA, AD.
Referring to Table 2, on each scan, one or more bytes of data indicating bar and space widths can be obtained. After the scanned width data are.written onto bus DATA, the data in the latches and counters connected to bus DATA sequentially write the indicated string length, narrow value, label position, and the ' number of bad scans. For example, the third scan produces two data bytes indicating the code pattern of narrow and wide bars and spaces. The string length, however, is only fifteen bits long, indicating that the last byte has only seven valid data bits. For this scan, the narrow value stored by counter 81 is 99 which compares properly with the narrow value of the prior scan, scan number two. Similarly, the label position from counter 76 is 50 which compares properly with the prior label position value.
In this embodiment, the data bytes indicating the l0 interval widths are stored between location XFOO and XF1F in the dual port RAM 48. The maximum that can be saved is thirty-two bytes (i.e. 256 transitions). The following block in memory is the string qualifier data. This block includes the narrow value, string length, label position and number of bad scans. The string qualifier data is stored between memory locations XF20 and XFC1.
The output from counters 74-81 are "tristated°' so that only one uses the bus DATA at one time. Referring to the flow chart of Fig. 7A, it shows the sequence of operations of state machine 70. When initialized, state means 70 starts at step S1 (Fig. 7A). Loop I starts with a branching decision. If a transition occurs (signal DEC) and the scan is not over, branches S1 and S2 transfer control to steps S3 and S4 so that a byte of values indicating a bit pattern of bars and spaces is loaded into memory 48. The string data counter 82 which points to the appropriate address is incremented.

WO 92/05516 2 ~ (~ ~ PCT/US91/0687~

If at the next transition all scanning is completed, then loop II is executed. In loop II, the state machine 70 successively stores bytes of interval pattern data and then increments the address pointer. Steps S5 and S6 are essentially the same as previously described steps S3 and S4. In the following steps S7 and S8, the string length of counter 80 is written into memory 48 along data bus DATA. String qualifier byte counter 84 is incremented. Next, in steps S9 and S10, narrow value latch 81 is loaded into memory 48 along data bus DATA. The string qualifier byte counter 84 is incremented to indicate the next position. In steps S11 and 512, the value in label position counter 76 is loaded along bus DATA into memory 48 and counter 84 is incremented. In steps S13 and 514, the bad scans counter 74 is loaded into memory 48 along bus DATA and counter 84 is again incremented.
If the scan has ended, loop III is executed so that the scan number stored in counter 78 is loaded into memory 48 along bus DATA to the address indicated by counter 84 which is then incremented.
The actual control signals for registers and memory interface are implemented in the state means 70. The function of various timing events are described below:
WINDOW: Indicates a save of the current string. This occurs if the minimum string length of five is exceeded. This signal resets at the end of the string.
SAVSD (L5): Indicates a byte of string data was saved.

2~~9~!~
!, WO 92/05516 PGT/US91/06876 This occurs when the eight-bits shift register is full or when the string is ended.
SAVALL (L3): Indicates all data was saved (i.e.:
string data, string length, narrow value, label position, and the number of bad scans). This signal is active if the string is ended.
SLEQCR (L1): Determines whether the String Length Counter 80 is loaded with a '°1!' or the number of consecutive equal WIDE/NARROWS. It chooses a "1" if the string is ended or l0 no string is being saved. It chooses later if the comparison to a wide is twice or comparison to a narrow is half AND the current string is not being saved.
LDSLC/ (L2): Synchronous load of String Length Counter (SLC). Occurs if the current string is being saved or if the comparison is JUNK.
LDEQ/ (L4): Synchronously loads a "1" into the Consecutive Equal Counter (CEC). Occurs if.the comparison is not equal.
JUNK: Occurs if the comparison is not half, equal or twice. It also occurs if the bar/space width exceeds the preset limits.
SELREG2 (Mux sel): Selects register 528 or register 52C for an adjacent or alternate comparison, respectively. It chooses the adjacent comparison if in state A and comparison is JUNK. It chooses later if comparison is not JONK.
Because the state machine 70 is arranged as just WO 92/05516 ~ PGT/US91/06876~

described, each state either proceeds to the next state or does not change. Also the next state is always a new state and never a previous state. This ensures that within one iteration, no state can be active more than one time.
Referring to Fig. 7B, it shows the operation associated with the microprocessor board 42 of Fig. 3, when scan data is available. The flow chart in Fig. 7B is executed starting at S20, to read the scanned data bytes. Next in step 521, the string qualifier data is read: the scan count number, the string length, the narrow value, the label position and the number of bad scans. Next in step 522, the microp~~ocessor determines whether the latest scan is equivalent to the earlier scans in label position value and narrow width value. If it is not, control returns to step 520: otherwise, control is given to step 523. In step 523, the microprocessor shifts the latest bit pattern with respect to prior bit patterns to see whether there is a matching subinterval. If there is, control is shifted to step 524: otherwise control reverts to step S20. Steps S24 and S25 are executed to store the reconstructed string. If the reconstructed string is sufficiently long, the micracomputer indicates that a complete and valid code has been assembled.
This valid code once assembled, can be used in a conventional manner.
It will be appreciated that various modifications and alterations can be made to the apparatus just described. For example, while three °°X°° patterns are illustrated, a different number can be used. Scanning geometries other than an "X"
pattern may also be used. For example, a single line may be used if the code passes through the line at a shallow enough angle. A
circle may be used if the code is constrained to the circumference of a circle. Two or more intersecting line segments may be used if the code passes through at least one of them at a shallow enough angle. Any of these scan patterns may be rastered to increase their area of coverage. The arrangement and use of mirrors can be altered depending upon the desired mode of slewing the laser beam.
While the comparison between data strings is -.~.,~; ~; ~ra~ nn hsavi par c-_orresn~ndinQ label positions and narrow .......... ~... ..~ _ ~..~ ------r-__--_ ~
values, in other embodiments different comparisons or no comparisons may be employed. The tolerance placed on the ratios of current to former interval widths can be varied depending upon the expected accuracy of the printed codes. While optically-readable printed labels are described, it will be understood that other media such as magnetic media may be employed instead. The illustrated digital circuits can be composed of larger or smaller scale integrated circuits without departing from the scope of the present invention, and can be composed of arrays as shown or may in some embodiments employ another independent microprocessor or digital signal processor.
Also the speed and the dimension of the scan can be altered depending upon the particular application.
It is even possible to alter the sequence in which WO 92/05516 ~ ~ ~ ~ ~ ~ ~ PGT/US91/06876 various steps are performed. For example, Fig. 8A schematically summarizes the system earlier described in conjunction with Figs.
1 to 7 of the drawings. Thus, a scanner 100 is provided for optically scanning the machine-readable code, providing electrical signals for further processing. Such processing includes the development of specified counts, at 101, followed by the compression (i.e., conversion) of data into digital form, at 102. The compressed data is then shifted and matched, at 103, to recreate the scanned bar code (from discrete portions which have been read). The reconstructed bar code is then decoded, at 104, providing the desired output. Thus, by means of digital comparison, a complete bar code can be reconstructed from two or more discrete fragments as previously described.
Fig. 8B shows an alternative sequence of steps for scanning a bar code. Once again, a scanne~~ 100 is provided for optically scanning the machine-readable code. This is again followed by the development of specified counts, at l~Dl'.
However, unlike the system of Fig. 8A, the system of Fig. 8B then operates to shift and match the scanned data, at i05, based upon the counts which have been developed, to reconstruct 'the bar code. The reconstructed bar code is th8n decoded (compressed to digital form and decoded), at 104°, providing the desired output.
Thus, a complete bar code can in this case be numerically reconstructed from two or more discrete fragments. Further detail regarding this alternative technique for reading machine-readable code is provided below.

2~~~4~~

Scanning (at 100) of the machine-readable code is accomplished in a manner which substantially corresponds to that previously described in connection with the system schematically illustrated in Fig. 8A, or using some other appropriate scanning pattern, so that "slices" of the bar code are read by the scanner as the bar code passes the scanner. Generally, no one slice will contain a complete bar ccde, and a plurality of slices will have to be processed to reconstruct the complete bar code. To this end, the scanner provides three output signals. A CART signal is provided to indicate that an object has entered the scan area. A
SCAN signal is provided at the beginning of the scan pattern, and is discontinued at the end of the scan pattern. A CODE signal indicates black and white areas within each scan.
These signals are then applied to. the pulse-counting portions 101' of the system. During each scan, pulse width counts (PWC) are generated to represent the widths of the black and white sections identified by the CODE signal. Each fragment (slice) of the bar code will therefore generate a plurality of bars (black) and spaces (white), producing a succession of counts (for each bar and space) incremented at the system's clock frequency. To be noted is that these pulse width counts are generated in real time, as is preferred, although other implementations are possible (provided appropriate buffers are made available between the scanning operation and the subsequent processing operations which are described below).
In addition to the development of pulse width counts, WO 92/05516 ~ ~ ~ J PCT/US91/0687~

an additional counter is started at the beginning of each scan (i.e., reset to "0") to develop an absolute position counter.
During the scan, this counter is also incremented at the system's clock frequency, reaching a maximum value at the end of each scan. Thus, the absolute position counter functions to indicate the location of the pulse width counts collected during each scan. To this end, on each black to white transition, the content of the absolute position counter is latched to identify the transition position count (i.e., location), while on each l0 ~,ahite to black transition, the pulse width count of the previous bar, the pulse width count of the previous space, and the transition position count for the pair, are saved (in memory) for further processing. Transfers of pulse width counts and transition position counts to memory are .done in real time making use of a DMA (direct memory access] process.
An alternative approach to this would be to make use of a single, high speed counter which starts at zero at the start of a scan, and which counts to some maximum value at the end of the scan. The content of the counter would then be stored for each transition of the CODE signal, with simple subtraction of one value from the next serving to provide an accurate indication of bar-pulse-width counts, space-pulse-width counts, and transition position counts (for subsequent processing .
Following each scan, all data for the scan is processed to determine if one or more series of pulse width counts (strings) constitute part of a possible valid bar code. Any 2~~~~~

string which exceeds a certain minimum length meeting this criteria is stored in memory. This process is repeated at the end of every scan while the object to be scanned is in the scanning area. Between the end of this process and the end of the next scan, steps are taken to recreate the bar code in memory making use of the pulse width counts and transition position counts which have been developed.
Referring now to Figs. 9A and 9B, the first step in this process is to check each string, at 110, to find a string l0 which contains a valid beginning portion (start) or ending portion (stop) of a bar code, at 111. It is important to note that since this can be recognized whether the pattern is in a forward or a backward orientation, or anywhere within the string, a white area (so-called "quiet zone") around the bar code is not required. When a valid start or stop pattern is found, the corresponding string is used to form the first string of a "cluster", at 112. To be noted is that plural clusters may be started, and that a single string can lead to the creation of more than one cluster. Further to be noted is that since the 2o strings of each scan are processed in the order in which they are transferred to memory, plural clusters may be processed in parallel.
Upon the formation of a cluster, at 112, a valid middle portion of the first string is identified. The transition position count for this valid middle portion is then recorded and a range (plus/minus) is created. Following this, the next scan WO 92/05516 ~ ~ ~ ~ ~ PCT/US91/0687~

is searched, at 113, for a string which matches (test 114) at least part, if not all of the previous string in the cluster. To prevent a mismatch, only the part of the next string which falls within the transition position count range of the previous string is used. It is possible that no string from the subsequent scan will fit within the range which has-been selected, in which case a string from the following scan will be analyzed. If after a few scans, no matching string can be found (test 115), the cluster is discarded, at 116, and another is analyzed.
The above-described matching process is sLUnmarized as follows. The strings of each scan are represented as a series of pulse width counts (i.e., bar, space, bar, space, etc.). The second string is shifted to each possible location within the calculated range specified for the first string. A comparison is then made between the pulse width counts for both strings in each possible location. To improve the accuracy of this comparison, adjacent bars and spaces are preferably summed so that a bar and an adjacent space create a bar/space pair while that same space and the next adjacent bar create a spacebar pair (and so on), which are then used for comparison purposes. Alterrnatively, a bar can be matched to a bar, and a space .can be matched to a space. In any event, as the data is relatively shifted and comparisons are made, the pulse width counts of both strings will eventually match (i.e., the pulse width counts will fall within an acceptable tolerance), identifying a registered middle portion of adjacent strings (fragments) of a scanned bar code.

WO 92/05516 '~~3 ~ ~ PCT/US91/06876 To be noted is that it is not necessary to match the entire string, but only some middle portion containing at least a predefined minimum number of bar/space pairs. This allows for non-bar-code data on either end of the strings, eliminating the need for a quiet zone around the label.
Once a match is found, the second string is added to the first (the cluster), at 117. To this end, the pulse width counts which match are preferably averaged together to create a longer string containing more of the bar code than either string would separately constitute. This string is then preferably decoded to identify at least a part of the bar code and confirm tvhat tvhr~ chi fi- anri ~natrh nrnnoea»rca roaec nnrrAe~t7 v ac~comnl i shpd _ ...... ....~........ t.~............,..~~. ..,..... .~~~..~~~~1 _----r---__.-_ This process is than repeated for successive scans (loop 118), each time creating a longer string containing more of the bar code being scanned.
Eventually, a string will be added to the cluster which contains the end (stop) portion of the bar code, assuming that the beginning (start) portion led to the creation of the cluster, or the beginning (start) portion of the bar code, assuming that the end (stop) portion led to the creation of the cluster. When this is detected, at 119, a.single string of pulse width counts containing an entire bar code will have been formed, and the cluster is closed, at 120. The final string is then decoded, at 121, to complete the reconstructed bar code. As a further test, at 122, additional strings from subsequent scans (if any) are preferably matched with the completed string to make sure that WO 92/05516 ~ ~ ~ PCT/US91/0687E~

there is no overrun, and that the assembled cluster is in fact a complete bar code and not part of a larger bar code which has not yet been completely reconstructed. If an overrun occurs, the cluster is reopened so that a bar code of greater length may be decoded. Otherwise, the cluster is discarded, at 123. If no overrun occurs, the cluster s deemed complete and a valid bar code has been decoded.
This same procedure is repeated, at I24, for each cluster which has been formed. Each identified cluster is either completed or discarded, as previously described. This allows for multiple bar codes to be decoded, and for another section of the pattern developed by the scanner (e. g., an '°X°°) to again decode the same label.
The foregoing operations contribute to various advantages in operation. For example, as previously indicated, no quiet zone is required on any side of the label. Rather, pulse width counts representing non-bar-code data on the ends of the strings are simply ignored during the shifting and matching procedure. This also has the advantage that even badly damaged bar codes can still be recreated. What is more, strings which are damaged can be salvaged if the section which falls within the transition position count range is nevertheless valid. Otherwise the string is ignored and the next string is analyzed. It is not necessary that all partial strings be used to recreate a particular bar code.
Another advantage is that multiple labels on a single WO 92/05516 ~ ~ ~ ~ ~ ~ ~ PCI'/US91/06876 object can now be decoded, whether or not the labels are of the same code type and/or length. The absolute position counter produces highly accurate transition position counts for each bar/space pair, ensuring valid string matches and allowing for separate bar codes as close as 0.25 inches to be decoded.
Yet another advantage is that except for the initial scanning.procedure, and transitional hardware necessary for the counting and memory transfer procedures, the above described system can be fully implemented in software. A computer program listing which implements the foregoing processing steps is attached as an appendix following this specification. This program is advantageously implemented in a RISC (Reduced Instruction Set Computer) processor, preferably that available from Texas Instruments under the model number TMS320C30, providing still further advantages in accordance with the present invention.
In any event, it will be appreciated that various modifications can be implemented to the above described embodiment and that the foregoing shall be considered illustrative and that various modifications thereto will not depart from the scope and spirit of the present invention.

WO 92/05516 PC~'/US91/~687 APPENDIB

WO 92/05516 ' 39 ' PGT/US91/06876 .::>s:~s:~:***********~:n:as:x:>i:~r.:~o:o~:***************x:****~***~~~~,~~.~' ~~~~ ' tJ<~cir 1~<~mp: (.IC..Ff'.~, -f~ueue;: ~E~ 'F~F2~~
~'.. ) ~w,'U-~ i~l7rrW~ 'ChIT' Server: S'EnJER4 X: , _.

XX . C; :
I>AS;c: r ~i. rt l: i.
d m : I:I~I T.

I:;F.1='TI-'.I~fIiFl~s a ;x ., :I n9G.i l i : iC~ ar; yl .s:>:v:>f:n:n:r~:n:n:n:>xn:~x>s:n:n:>xn:**n:*>r.~c*n:n:~s:n:x:~s:*n;***********
*********************************~

I .r-.1-FED ~-FFFr-' r= FFFF

.J c F r' .J F I= r , J FEEE I=FFF FFFF o ,1~:~'r-,J J ~: F F

..1..).J F'I-'FI-'.E F F

.s:n::*n:n:n:n:n:n:~t:n:n:*n:********:n:n:***::an:x:*******x;******x:**********
*******************~

l: T J:1:1: IJ hJ TTT'T'1' X X X X CCC

:I N IJ 'T X X X X C C tl 1 I~I~! Iv T X X X X C tl t: IJ LI ,N T' X X C ~I

IJ t~t!~~! '(' X X X X . .. C ~ 8 :1 ht l T' X X X X ... C C

a .r a :r x nt Is T x x x x . . . CCC

x k:k:k:k:k:kAc:kAt:k:k*irk:k:k:k:~c*:!c****y**ac***tk***************************
********** ********ti _ RAIEEs int ss.c _ DATE: d9/t4/96 _ PROGR;iIIMERs .feff Shrrpe Df.S(:RIPTItitl: --t/
DRX TFCHROLOGf IIITH DSP-TMS 37AC31 Copyright tc) f99~ Acco-Sort Srstees~ inc. , All rights reserved.
riudp 'conn.lit' elude 'coee.e:t' FUIlCTI08: c intil(f _ RETURNS:
_ DESCRIPTION: -d c intil(I
FUBCTIOIi: cintl2l) RETIIRIi&s ( DEBCRIPTIORs -d c_ieti2t) _ FUIlCTIOIi: t_iati3( 1 RETIIRRSs _ IESCRIPTI01li -t/
f c_inti3() ister int bo:;
asi~r stracf ha: t~ble_xtract thoc_p;
v(' or 2lBBh,st'); /t tbay ed froe 2BIfb I/
-. ti~e~~;
rtbar = f; bor t NAX_BOXE8; bor~i) m _p = (stract 6oi t~6)e struct t)(b(ba:_ctbai7));
ftbns_n-)ts-tat_tiee ) A>
~o:_P-)tt t tine--;
if(bos_p->t: t~c_tine s= bt is rndestbn:f;
~(' rot 2llih~ct'!; /t cbm~ed froe 211th t/
EUNCTIOMs c_iniil(?
RET~iRRS:

utn~m rm un: - - 41 -Il ' ~ intNlll pier union e)enent_union ip?, ist~rt_data, ip3, lend data;
ster int indel, corlnt, len, glen, leg, ipl, old-scan_iodel, st~t_reg_v~l;
;r,r Sran-;tract Iiscan_struct_pl;
- (int iIMFN_MAP_PFR1F_RASE;
- /i -Am global ~:ontrol disable i/
t~~IU) = DNA_DISABIE;
/i -read in stai.us_register I1/I? X/
t_reg-val = i(int IISTATUS_REG;
/i._-save ending Ana address t/
_data = tunion eleeent_union t)(1,(pl~llbl);
/i -cave starting daa address, t/
ri_data = (union eleeent union i)((intlerrd data 6 tint) ( DI(A_START_ADD_fIASI! ) ) ;
/i _-deternin uhirh halt of 1t hloct of internal ran gets /i__ the dea data on the nest scan t/
/i__-flay light off f/
~(' and Ibfh,iof');
(last_I ~= (strt_reg_va1 h 1>tlll) tl (tirst_flag =-- 1)) :n(' or l4Ab,iof'); /i flay lLight on i/
wor_int_11 = X1_X2_SAHE;
t_I = (slal reg_val ~ Islil;
( taSt I ~_ ~) /i _-get neu dea startitg address leg 1!/
plt~9I6) = DHA_START ADD_X1;
lhead == X) eg = t;
ce f(head == SUPER X) leg = ((stat_r'g_val 1 Ir71)/16) ° 2;
tse if(head := H_55) leg - B9 .e /i__-get nee d~a starting address leg ~t/
ntflilhl = DNA ATART_ADD_X2;
if(hoad != SUPER X) 1~S = i3 else leg = ((stat_reg val d Ic7~)/16) - ?;
/i__-iott dea registers t/
~)iA:P) = DNA f.DUNTER Rf.G; /f dna t~raasfer counter register D/
~lsDI1) = DMA_60URCE ADD; /i dna source address constant i/

WO 92/05516 _ ,~ _ PCT/US91/06876 ~ t ~fr4 ) = onA_Elfpel.E; /x enao to 4na a/
i-rM(AtIA_FHARLF.-MASK); i ~a int enahle oust x/
/x_--enable iaterrnpi irf for don x/
n(' nr r9,ie');
(firs!-flan == f) /1---if first scan init for nee read cycle t/ _ irst_fl~p = 8;
~e /i --cave oa)y the scans that have ) or Bore strings aver /x__ KIN_TRAUS_LEtIGTH and turn oa flag light i/
en = end_d~t~ - st~rt_d~ta;
ftlen ) 52f) lnn = len;
nl~n = oleo;
f Ilen )= MIN-TRAMS~LEIi&TH) lea++;
end-dala->r)) = N;
sc~a_siraci-p = (street scan_strnct i)(t(leg-sCleg7Cscan-inde:LIegl7));
;can_strnct_p->sr_aa our, s Bran cnuatCiegl;
p2 ~ Inoioa eteoent daioo tlsc~~-,str~ct_p-)eleeeats;
~7-)al) = f;
,2++;
n3 ; a2;
coot ~ f;
Ilea = f;
forfindea = 6; finds: (leo ; fades++) if t istart data-)fiell.~~r ( MTIV COUIfT) )t Istart_data-lfielLspace ( Itlli COURTI ) ( it Iroont ( MIN_TRAtIS t.F.ItGTH) C
P?aP;'t start data++;
else f aso(~ or f4ih,iof'); /t flag light oa t/
if (ales == f) plea = t;
oleo ~ oleo + roust; _ if((start data-)field. bar != f) )t (stark-data->fieId.space !=f)) t :p2 - ist~rt_dat~;
p7.-)field.npea_type ~ f;
p2++;
oleo++;
.1 pT.~)all = f;
p?++;
n3=p7.;
start data++;
oleo++;

WO 92/05516 _ 43 _ PCT/US91/06876 ~_ount-6;
else 3p2 = istart_date;
p7-)field.opee_trpe = Ai st~rt_d~ti~+;
if((p7->field.rel_pos > sn rt_d~t~->fielA.rel_pos)) if(n'7.t-tl.fieid.rel_pns == 91 ( p9-)field.rel_po~ _ ~t~ri dit~-)field.rel_pos -(start_d~tetl7.field.rel_pos - stert_deti-)field.rel_pos);
l else if((~iari d~t~-)fiPld.har ( MIIt COURT) .1 (stirt_d:t~-)fir)d.space l 8I8_COUIIT)) c p2~)field.rel_pos = p2C-I7.field.rel_pos ;
(pS!f-f7.field.rel_pos - p2C-27.field.rel_pos);

nl5e p2-)field.r~l_p~~ =p2f-lJ.fie~ld.rel_pos +
((stirt_d~t~-?field.rel_pos - p2C-ll.field.rel_pos)/2>;

p2++i c oat++;
i f ( (ai en + count 1 ) l IIAf( FI.FIIFIITS -?
C
tadel = len;
~rror_tot_e~ = scaH_roo_~oNC;
J
) if ~(nlen )= Iflli TRAMS 1E11GTlil old_sc~n_indet = sc~o_ialelClegla;
scan indelllegi vr~ /i tndel into teg ~ array t/
if Isc~o indelClegl >> BA7(_SCAIlSn sr~n_inde~fle~7 = 1; /t ar~p irroasd t/
if Iscm_indlltlegl == proc_scin_indelCleg7) /! field.spate for neo dite ?? >!/
C
scan-inlerttegl = old scen_inda ; /i tbroe eaey nea data tl errnr_int_R~ = fll( I _SCAIIS;
~cen_struct p->I!n = oleo;
sc~n_struct_p-)depth = gdepth;
sc~n_ciruct_p~)f~c tine = t~r_tine;

cen_countCleg7 r+; /t increeeated every !u a i/
(legl(2) use(' or Allb,iof'); /i cart ligbt on Z/
5!
pie(' :nd if~b,iof'); /t tart light off t/

_ ,44 _ _ FUItCTT0ll: c_inti5( ) _ f~f.TURIIg:
DFSCR1PTI0!!: --.3/
d c_intt5() FuNCrIOII: ~ i~cf6() " RETURNS:
_ DESCRIPTIOIt:

d c intf6() FUIICTTOIi: c intf7( ) _ RFTIiRIIS:
_ DESCR1PT10Ms -I/
d c_isEi7() FUBCTIOIi: cietl8() _ Rf TItRIISs ,. DfSCRIPTI08:
t/
9 c_i~tfB( ) FUUCTrOff: c intl9( ) - Rf TIIRIiS s _ DFSCRJPTIOMs -d c ioti9() - FUIiCTI0lls c_intl~( _ RETlIR118s _ DESCRTPTIOIis -i r iettfl) - rUltt.llll!!: c_7111)III
_ RETURNS:
_ o~Sr,R(PT(Otl;

r inlff(>

WO 92/05516 c PCT/US91/06876 ni.J(.Jrn ~n~nl~ ac~crcfi~c"u,cmx.J~ x-x.~?.J.:/(.IAR.TTTT.pTTT.~"~,T~
.~.TTTTTTTTTTw~T~ww"pTw,q, ~ ~
Lls:er Nar,es (.tL.FF <")~t~
(~lueue: C~ 'ER4~~'''~~
-i.7:rs l~l;.~r,~ ; F'F~H:F'FSr , ~: Server: SE. EFt~1 DF~~cr~i.pi:i.caris F'REFROC.C
;~F.NTFhfLjf:F2 :iy :1 ~~9~ 11:10 are >Y.*~l:*~I:*~1:~1:~?:>3:i0:***~f:~y::P:*~:~f:~'***~Q:*~t:~:~:~1.'~i:***********
*********************************
. t fTrEf :. 1= FFFF FFFFF _ .~ r-- F F
..) I- ;- F
..l EEEE F'FFF f= FFF
,J F F F
,.i ,J E F F
.).J..) I=EI-'.FF F F
>I:*~F:**:***k:**
***~1:*****:t:***~!:>lc:P:>kri:>Y**:9:***********~K*******~k*******************
***
PPF~'F'RRFiRE:EEEE:F'Fv'F'F'RFiRFiC)00 CCC CCC

n h' F~ F: ~' r. a a C c G c R F' F, F~' R ~ F F' R a a c C
f' R R

F'Fv'F'F'hrt'FVrvFF:F.T't='F'1='F'IvFiriRt7 C C
O

f'' fi E: F' R a O C C
f~ R

E' F~R f.: F' rvh 0 O . .
C C C C

f' r EEEEEF' R OQO CCC .. . GCC
R R

%kk:K:K
k:K:K:K:K:Ic'k:4ca:lc:k*:k*****:k****:K*:k*************************************
********

WO 92/05516 _ 4~ _ PCT/US91/06876 i__ HA!fE: preproc.c ___ GATE: H9/t~/9A
PROGRAHHER: Jeff Sh~rpe AFSf.RIPTItIH: -L !/
F PRX TFCHNOLOGf UITH DSP-TMS 39OC3g - '' i Copyright (c) 1999 Accn-Sart Systens, inc.
I All ri9ht5 reserved.

inr)ude 'cann.lit' include 'cone.ett' i t__ FUHCTIDH: pr~proc i kf.TttRHB:
t _ DfSCRIPIIDH: -1 t/
aid preprac(leg) ~t leg;
irnrt sr~n_xtruct Isc~n_p, teep_rort xcae;
tract eleeent_siruct tele~tsnt_p, tteep_eleeent_p;
tract claster strnrt lcln5ter_p~
tract strir9 9t act tstring_p;
t act strtag stract teep ~trio~f, ner_strinq, teep_rork_string) correct ttrir9;
are cinst~er_Statas teep_Statas;
nt c)usier_indeir rbect code, haa, i, decodeA_gaod, lea, dare, j, overl~y_recover_cauot, overlnr_recrrce count) :, sua_diff;
nue werlay_respo~ce over Stata~;!
are 6ooleav overl~r_recover, clrftter is_old;
hay rad~ CRAX_C.HARS7;
if(proc aeit_scm(leg, lteep strie~)l /t_.-there are su et to process f/
t ~can_p = (xtract scan struct t)It(leg_sCJeg7Cprac scan_indezfleg77));
/t _-get neat string t/
rbile (get_nert_atring (scan_p, ieleeent_g) ttenp_string)) f if( r)est~r~= tartCle~7 != claxters eadClegl) f r.ln~ter_indei = clusters St~rtCiegl;
clrster_p = (stract cluster stract t1(t(leg cllegltclnster_indeill);
do C
cluster ix old = FALFE;
if( (clesier_p-)ore_striags ( NAX STR1BGS) A1~
(String_ftts_in_clnster(l~rg, elenent n, cluster_p, tteep_strieg, 6string_P)) AA
((clutter is_old = is_clrst~r old(leg, cluster_p, ttring_p)l == FALSEI
t~ (clnster_p-)stuns 1= STATUS_UIIIIIO~tI) ' /t__-string fits iato neat cluster i/
f te~p_rort_string = claster_p-)rort_string;
teey ~nrk_eran.5can_nrn = ciuster_p-)~ork_scm.sc~n_nun;

WO 92/(15516 Pt:.T/US91/06876 »np_eort sraD.~pn = rmster_p-)rnrt_scan.)ert; -for(:=i; :Cclusier_p-)tort s.. ~.)en; m +) t~en_rnrt_sr,an.eientntstzl luster_p-)rart_sraD.elenentsCil;
tellr_~t~tUa = C)llSter_p~)Ct~tll5;
scin._diff = scm_.p-lsc~n_nue - leg-sfIegICstring_p->inde:I.scan_nun;
35tcing_,n++1 3string_p = teep_striD~;
c)uster_p-)nun_stringarr; _ over)ay_recover = FALSE;
nverlay_rocaver_rount = 8;
overtay_recurce-count = 6;
do ( nPr_string = ieep_string;
/t---trig the !string I/
trin(leg, sran_p, r.luster_p., a~~w string, eleeent_p);
if(cluster_p-)string_dir == FORtIARD) f if((cJnster_p~)status == DE;CODEIN6) I6 !nver_statns != DYERLAf RF.CURCE) done = 6;
if(clnsier_p-)rh~nge_reJ_poc == MAX-CHANGF_REl POS) ~=)i else jTt;
rYilr(((ner_strieg.start - terrp_string.start) < H1N OYERIAr) ti (dose == i) -C
if(lr)usier_p-)cart sc~o.~eleaeDts Ccluster-p-)rort_strim;.ead + KIN_HATCH + jl.s'ece ) HIN COUNT) to (r.tu5ttr n-)tort SraD,titlllnt6 'tctuster-p->rort_strin~l.evd + MII(_IIATCN + jl,bar > NIN_COUNT) t cluster ;~-)tort string.endf+;
aer_strtng = terp_strieql, /ty trie the string I/
trie(leg, scrn_p) cluster_p, Leer string) elteent_p);
if((rlutttr_p-)cork SCal.eltlllpt9 Ccluster_p~)rorka ri.n9.end ; HIN_!(ATCN + j7.spece ) NIN_COUNTI i~
(claater_p-)tart sw n.eleeents Ccluster_p-)rort_string.end + RIN MATCH + j L bit ) HIH COUNTf (scaa dfff 1 tlt/
) _ j+ri ~1Se done~l;

else r AADP=t1 l ift(Der sfring.st~rt - te~p_!striDg.st~rt) < H1N OYERLAT) Der_string,start = tenp_qtring.start f IfIN OYERLAT;
if((tes'_strinq.eod ~ Der st~ring.ml) ( HIN HATCH) eer string.eed = is~p_string.en/ - iflN MATCN;
if((claster_p->stitos != DECIIDEIIIG) ii tover status != OYERLAY_RI:CI1RCF_) ~5 mer_ctrmg.eno t ner-ctrmg.ct~tt) - 49 -ner_string.end = ner_string.st~rt;

et,e ( if((t)ncier_p~>staiua == hfCODFIH6) >4i (over status != OYERtAI! RECURCE) ) dono = d;
if(t)wter_p-)rkmqe_te1-,pos == HAX_CHAHGE_REI_POS) J")i !t5!
rhilP(((tPnp_string.end - ner_string.end) ( RIH_OYERIAY) i~
(done == b) if( (rlusier_p->rort_sren.r)eventcfcluster_p->rork_string.stirt - M1N_NATCH -j).spece ) H1R COURT) ti (cluster-p-)rort Scm.eleeantstcluster_p-)rork_string.st~rt - H111_HATCH -jl.6m ) BIB_COUIiT) t)uster_p-)rort_string.stmt--;
mr_string = teep atrin~,g;
/t__-trio the string t/
trinlieg, sc~n_p, clr:tor_p, leer string, eleeert_pl;
ift (claster_p-)rort sm n.eieneetsfcluster_p-)rort_striag.st~rt - MI11_MATCH -jl.spiice 1 tilll COUNT) ii trluster_p-)rort sc;ip.rleeeetsLclrster_p-)rork_string.st~rt - BIN BATCH -j7.b~r ) BIB_COURTI
/t ~i (curt dfff ) I)t/
) -j++~
(~lse deel~I;
llfe done=);
if(tteep_siring.e~d - ner string.e~d) ( NI11 OYERLAT) ner itring.end = tenp_strin9.end - MTiI QYERLAY;
ifttrlr strfeg.st~rt - teAp,_striog.st~rt) ( MIB BATCH) ner ciring.ci~ri = teep_stiring.et~rt + HIB_IfATCH;
ift(cluster_p-)stars != IEhDDEIiIG) r<<
(over StetnR != nYFRIAT RECURCE) iA
lner_string.end ( nee_string.stert) I
ner_string.st~ri = ner_atriag.end;
cluster_p-)old_l~st_~~tck ~ clrster_p-)l~st_ertch;
ifttover_stetus = everlePtscen_p, Aeer_string, cluster_p)I ==TRUE) t /_ _-strin9 overt~ys correctly t/
/i -if stars = POSS OPEk change it to OPEN t/
if(t)uster_p-)status == POSS_OPfi() tlucter_p->st~trs - DPEN;

WO 92/05516 - 50 - pGT/US91/06876 _vc~.uvr as e.tny rnaracier5 t5 po5s~o~r ~~
/I _-if good c '~ call in canphuft/
/I --if last g, character ( l~st hatch m to /r__ last_natch = last good character Il r.loster_p->avr_tac_tine ~~ (cluster n->avr tar. tine i scan_p-Itac_tieel / 2;
der linpar(IPg, cfuctpr_p, sran_pl;
if(ovprlay-recover == tRUEI
r /: _ re avertayed last string, re da current string x/ _ tpnp_ciring = rluster_p->l;tringsfclnxter_p-)nun_strings-l7;
scan_p : bleg_sCleg7ltew~..slriog.inde:l;
el~eent_p = tscan_p-lelen~!ntsCteep_String.startl;
overlay-recover = FALSE;
over ctatuc = OYFRLAT_~FF START-REC;
overlay_recurce_count = i;

else f clusier_p-lold_rort_strtng = tenp_rort_string;
clustpr_p-)nld rock scan.scan_nun = tenp_rort scan.scan_nue;
clrster_p->old_rork_scan.len = tenp_rork_scrn.leo;
for(r=p; z( tpnp_rort scan.lpn; :~~1 cluster_p-loId_rort_scan.!rleneAtsC:7 = tenp ~ort_scan.elenentsC:l;
l p)x!
iftover-statrx =_ pYERbAY RI:COYERI
t _ if((ovlrlar_rerover != TRUIEI ti (uvertay_recover_count < lfAX RECOVER COUIIT11 t - -ovlrl~~_recover = TRUE;
Ovsrlay_r~roVer r.~111tm ;
teep_string = cluster-p-istrip~slctuster_p-)nnn_strings-27;
xran_p = 'Ieg_xfIpgIFten~~ xiring.iwde:7;
elenepi_p = scan-p-leleneetsttenp_string.startl;
nver_Status = OYERCAT OFIF START RFC;
7 _ _ else /I__ corld not re_overlar last string, restore last string and 4ctp_current string i/
cluster_p-)rort_string = tt!ep-tort string;
clnxipr_p-)tort xrap.sria nun = teep_rort cra~.srae_nnn;
clrster_p->rort_scao.leA = teep ~ort_sc~n.len;
for(:=8; :( tenp_rart_4cae.len; :gel clarter_p~)rort scaw.eleeeatsCi7 = tenp_aort_scan.eleneetsC:7;
nver_st~tux = DYF.RI.Ar_ItAD;
tenp_slring = clutter_p-lstringsCclustrr_p-leas strings-11;
clust.r n-)stairs = tenp_st~tus;
scaa_p = ileg_sCleg7Cten'_string.inde:l;
p)pnent_p = txrae_p-lelpner~tsftenp_sfring.start7;

if(Iover._sfatus == OYERLAT_REI:URCE1 ti tovPr)ar_recurce_conot ! nax_RrcNKVt_~:uuW !~ Sl -( /i-_ r.nuld not re_ovei / last string, restore last string and scip_current string t/
r)ucter_p->rnrt_string = teep_rort_string;
r.lu5ter_n-)tort Scan.scan,-nue = te~p_rark sc~n.scm_nue;
cluster.-p->rort_scan.len - te~p_rark_sc~n.len;
fnrlx-d; :( teep_rork_sran.len; rii) cluster_p->rort_scm.elenentstxy = teep_rort_sc~n.eleeentslil;
nvvr_Sr.atus = OVERLAY_HAD;
teep_string = cluster_p-)a~tringsCcluster_p-)nun_strings-17;
scan_p = dleg_afleg7fte«p_.string.indexl;
elenent_p = 6scin-p-)eleeeetsLtenp_string.startl;

else ( overlar_rpcnrce_couni~~;
/F _-over situ!=OVFRLAY_OFF-START--retry rith updated /t rort_siring.end t/
lrhile((nv~r_StatuS == OYFR~.A!f OFF START RECI :S
(uver_status == OYERLAIf_RECURCE));
) else /I _-if strip! does not fit info cluster, should it /t be title) (is_ctuster_otdl i/
if(cluster is old~~
till_rlusterl)eo, cluster.P>;
/: -try next cluster x/
1 rhiI! (glt.-next_clusttrlleg, i~ctuster_i~der, icluster_p));
gill this string open any per clutters !/
:nrrent-string = tenp-string;
In chwt_rode = p;
/I _-'et tree cluster t/
rhite f(get fre~ clesterlleg, brlaster_p, 6string_p)) AL /t free cla:ter t/
(chect_cole l 2f(11AX_CODE-TYPES-11)) f stitch (chest code) ( _ cafe Pr /1 -125 FORIIARD 7tl thlct rodlli;
if(en~bled_code_trpesC1I257 == TES) c c)rsier_p-lo~ee_trpe ~~ 125;
is open_fnrtleg, ctuster_p, scan_p, to«p_string, eleeeet_p, string_pl;
hre~t;
case t:
/t -125 RErERCE i/
chest code~~;
iftemblel_code_trpesCl~tS) == YES) I

if(enaal~d-code_trpeafCl?.8) _= ~fs~ - 52 -t brear;
racy 9:
/I _-C1?8 REYERCE i/
ChArr rrJdell;
if(enabled_code_trp~!sCC1287 == 9E5) t -brt~t;
) while(oet_ne:t_elenent(leleeeat_p) Ateep~string));
/: _~nndate to nit elenent, see if this new string /!-- opens any clasters i/
/t _done pros. ~JI strings in tbis scan return to idlel/
rnr scan_inde:Cleglt~~
f (proc_sc~n indr:IlegJ )= IfAX-SCAlIS) roc_cc~n_inde:f)eo) = p;
iP
/i --if na nen ~srens to process, should am clusters /i be tilled tis claster rold)f/
f(clusters starttlegl != rlusters endtleg7) -luster-index = rasters sisrtflegl;
:lusitr-p = (stract cluster strnct tlli(leg cClegJtcluster inde:J));
string-p = ~(rluet~r_p-)5tringsC(tclwter-p-)wnn-strings)-1)1);
if(is cluster roidileg) cluster-h, stri~g_p)1 till_rlastertleg, claFter_p>;
FOilCTIDNs prat ne:t scar _ RF,TURBS: TRUE/FALSE
_ sets np STRIIli:P for nen string _ DFSI:RIPTllllt: -are there sraas to process for tartest leg t/
~ 4nnteaa pros-nest-scao(leg, teey -strin~_p) ister int leg;
icier ciruci stting_stract iteep_Ftring_p;
(prnc~sran_inde:Cieg1 !_ ~scan_indezClegl) /t is there scans to process i/
~ep_siring-p~)iode:= pror_sn n-inderflegl;/! init string for first string t/
~ep_stting_p-)end= -1;
~ep_strin9-n-)start= ST SP UN><1lOilll;
etnrn IOYERIAT-GOOD);
ae ~tnrn ttIYERLAY_BAD>;
FOIiCTIONr get neat string _ REIIIRIiSs TRiIE/FALSE

cm stPr_p-~oprp_typr = i~o;
is_open_rev(lrg, c~~~ ter_p, scin_p) teep_string, elenent_p, String, current_string);
breat;
case 2:

check_code~+;
if(en~bled_coAe-typ!lsCC391 == YES) ( ( hrPat;
CaSp ~:
case ~:
case 5:
case b:
- rasr 7:
ease 9:
/I -C39 REYERt;E II
rhPrk rPdP+1;
if(enab)ed_code_typesCC397 == YES>
( breat;
/I -GODF._A_BAR FORiIARD t/
cnect coee++;
ifcenin(rA_~oAR_typeocDDF_A_BAR~ _= YEs) c o ustPr_p-)oprn_tyP~~ = f.ODF_A_BAR;
is.o'en_for()eg, c)uster_p, scm_p) to»p_stting) eleeeet_p, strin9~1);
break;

/I -CDDF A BAR RF.YERCF I/
chect code++;
if(enaMled_coA~_typts.ICtlpE A_BAR7 ~~ YES) f cluaiPr_p-)o'rn_typP = CODF_A_HAR;
is_opcn_trv(Irg, c)ostrr_p, scaa_p, teep_strfng, elenent_p) string_p, current_strin~);
bleat;

It -UPCFAI( FORIIARD I/
check_colr++;
if(rnableA_c~de_typesCUPCEAli3 == YES) ( r)astrr_p-I~pPn_trpe = UPCFAN;
is_open_for()rg, clunter_p) scaa_p, teep_string, ele~eot_p, string_p);
breat;
) /I -UPCEAf! REYEkCE f/
cdect cnAe++;
if(en~bled_cole_trpesCUPCEAI(1 == YES) ( clustrt_p-)oprn_trpe = UPCEAB;
i~ apen_rev(leg, ctn~ter_p, scan_p, teep String, ele~ent_p, strin~_p, current_stringl;
hrPat;
/I -C128 FORIIARD t/
rhPrt_rodP++;

WO 92/05516 - 53 - Pt~ IyUgg 1 /06876 _ i~ep_m rmg_,pm ena _ start _ pl!I!~et_!1 _- DESCRIPTION: -get next string in current string _ :/
n boole~n gel-next stringtsc~n__p, eleeent_p, tenp_string_pl urt scan_struct tscan-p;
uct elenent stract tielenent_p;
nri s(ring_sirurt Itenp_string-p; _ gt5ter W t inAez;
gister struct eleeent_etract Ipl; , ile((tenp-siring_p->~nd i 2) l l:cm-p-?lent ndezsteep sfring_p-)start= tenp,.9tring_p-)end f 2;
3eieneot_pl = 6lscin_p-)elenent!~Cindezl);
i = x~l~nent_p;
hile (pl-)rel-pos !:~ p) indez~~;
plrrf rep_strino_p-)end = --index;
fttteep_siring_p-lend - lenp_string_p-)start) >_ _ .
()IIII_9VERLAY r etlt_IfATCN i 2>
f retarn tTRI(F);
tare (FALSE);
_ fUilCTIOM: siring_fit~_in-cluster _ RET~IRi(5r TROE/FAL&E
_ string_p _ 9F.SCRIPTIOIi: -does cnrreat string fit into current cluster tI
n bnatern striny_fits_in_cluster(1'g, eleeent_p) claster_p, teep_string_p, strin!_p) leg;
rct eleeenl_strnct ieleeeei_p;
uct clnit~r strait trlnster_p;
uct strieg_stract tteep_strieg-,p;
rH strinq_sirart Ststring_p;
act eiseent_strnct tts, Sle, tcs, lce;
lt~ ct;
aring_p) = t(c)nst~r_p->stcingsC((cluster_p-)nun-strings>-1)7l;
= (le' sClpgIC(istcing_p>->ieletl.tsc_tinel;
= (stract pl~e~nt strncl t1 (Ieg_sCleg7Ctisirieg-p.l->ials~7.elleeentsl;
= itsC(tstring_p)->evAl;
= tlsCltstriag_p)-lttJrt7; -= is = bclwstar_'->aort_srea,aleneetsfclnster-p-llsst-eetc47;
15 = ilsClest_String_p.Stirtl;

- ()rg_~f)rn7fienp_string_p-)ir~ ~7-.tar_tiea);
= (,truck elnnent 5trurt t) tley_slleg7Ltenp_string_p->indecl.eleeeets);
= bccfienp_~tr~ng_p'lend7;
8csttenp_string_p-)start);
((cp->r~l_nos ( ls->rel_pos - ERROR REt._POS
tfA'K CHARGE_REL_POS) !!
(rs'>rrl_Poc ) le-lrP1_pos + ERROR RF.1._POS +
MA1(_CHAHGE_REL_POS) I.
((r,t - It » t) Pturn (FAI SE>;
SP -aturn tTR~IE);
FUIiCT101l: i r ie RETURNS:
_ teep_string_p~)start ~ ..
_ rl~eeni_P
_ DESCRTPTION: -lrir, cnrreni string according to r!art_strieg t/
d trie(teg) scin_p, claster_p, tirep_string_p, eleeent_p) leo;
uct scae atrnct tscan_p;
uct ctuiker strert ir.lust~r_p;
uct string_strnct ltenp_string_pi uci rleernt_ciraci teleoent~;
r p_Start, nac_rel_pos_over;
change,_rrt_pos) iede:;
uct sran_ctrnrt fold scae-p;
uct ~leeeni siract Il~st_eleeeet_pr told_elenent_p;
uct strieg_strnct tttrin'_p;
riae_p = ~(clasier_p-)rort string!;
d_sc~e_p = Ir(cluster_p- fort scan!;
d eleetnt_n = nld_sran_p->elentets;
Iclnsirr-P-)status == aFC01f.1llG) h~ege_rel_pos = (cluster_p-lclaege_rrl_pos f ERROR CHAkGE REL_P06) t Isr:en_p->scee_nu~ - ol4_scan_p-)sean_onel;
se m n~r_re)_pos = MAX_GHAI(GF_REL_Ppf~ i (scan_p-)scan_ene -old_sun_p-)scan_nne );
(clutter_,n->string_dtr == FORiIARII) _P.start = nlA_Plreent_Pfstring_p-lend7.rel_pos -cb~nge_rel_pos - ERROR_REL_POS;
f(lclasttr_n->statn5 == POS!5_OPER1 ti tclnster"p-)chaoge_rel_pos == M~~X_CHAt(GE_REL_POSI !!
(c)WSter_P-)aiatr!s == OPEIiI
err_re1_po~_ovrr = r_p_stert + (RtFRROR_RF.L_P0S1 + chinge_re1_pos;
lse m:_r~i nns_nver = r_p_start + (ZiERROR_REI._POS);
se a:_rel_pos_over = old_eleseet~Ictrivg_p-)startJ.rel_pos +

~nangP_ret_nus ~ FRRDR REL PuS;
~((clnster-p-)status == POSS_Df~" ;;
(c)uctPr_p-)changP_rP)_pos =- L_CHA!!6E_RE.L_POg) ;;
(cluster_p-)status == OPEN) r_p_start = ~~z_rel_pos_over - ch~age_reI_pos - (4tERR0R REL POS);
i~P
r_p_siari = n~z-rel_pos_over - (?tERROR-REL_PDS);
dez = tenp_string_p~>st~rt;
t_P)Pnent_p = eltnPnt_pi~;
ndez »;
»i P)Peent_p = PIe~Pnt_p~s;
ihile((e)eeent_p-)rel_pos ( r..p-.start) 8h (elenent_p->r~L ins != A) )3 (e)P~Pni_p-)rP)_Poc == AI
~~p_string_p->st~rt = index + ~;
:e cep 3tring_p-)start = index;
,PZ__;
~nent_p--;
~)P((PIP~Pnt_p->rel_pos (= e~: rn)_pos_overl ai6 (eleeeni_p-)bar ) 818 COUNT) tt (eleeent_p-)~psce ) MII( COURT) li (eteeent_p~)rel_pos != i) adeztf;
leeevt_p++;
(elenent_p-)rel_pos != ~1 hi (elenent n-)bnt ) M(R COURT) ii leleeent-p-)space ) Nl8_COUNT) ~dez~~;
aee~t_p~t;
~aeat_p = Iist eleeeni_"
y-striog_P-)end = finder;
EUNCT10!!z is_claster~old _ RETIIRt(S: TR!lE/FALSE
DESCRIPTlO!!:-is cluster old based on proc scan indez(fl~gs) -_ _ ~ 'oo)e~w is_clusirr_old(Ieg, c)azter_p) string_p) leg;
act claster strait 3claster_~;
c1 string-strort ~strinq_p;
~~.t sran stract tsr:~n_p;
laa_till_linit, bigh_ttll_iteit;
'n_p = (sirurt c~~o struct t)(i(leg_sf)eg7~pror_scan_indetClegll));
i_till_lieit = scm_p-)sc~e_nu~ - IIT;

WO 92/05516 56 _ PCT/US91/06876 ;n_kill_linit = scan_p-)SC~n_nrm t 82; _ (rluctrr_p->~ort_~r~n.sr~n_ n ( (Io~_till licit)) I
(cluster_p-)~ort_scm.scae~_nun > (high_kill_linitl) ) eturn(fRUE);
P
. ~turn(FALSE);
FUNCTION: is cluster_ruld _. RET!IRNS; TR(lE/FAISE
_ DESCRIPTION:-is cluster old based an scin_count (scans) E/
boole~n is_clnsier..rold(leg, c~lustrr_p, string_p) ipg;
pct cluster_strnct icluster_p;
-ri ctring_ctruri istring_p;
lna_tiil_li~it, high_till_linit;
~_ti)7_)init = sraa_cnuatflen7 - t7.;
Ib_ktll_linit = scan_cnunttlegl + 12;
( ( (r)ncter_P-)wort sr~n.sw n_~nua ( tloa t311 liaitll II
lclaster_p-)aort_su o.sc:n_iana ) tbigh_till_linit)1 1 atnrntTRUEI;
.e ~turatFALSE);
FUNCTION: till_cluster _. RETURNS:
_ DESCRIPTION:-kill clusters after they are ~eteretnel to 1e ald _x/
till_clnsterlleg, claster_pl Irg;
pct cluster_struct Icluster_p;
nci clnster_struct !leap clasier,-pi conat;
~p cluster_p =tstrect ctaster_struct t)Itlleg_cileg7lclusters_st~rtCleg111f;
rluei~r_p-)sluice != PfISS_tIPFNI
/x -if still b~dl ctnster log K1LL_CLUSTER !/
~g_errartl(ILL_CLUSTER1;
~ster_p-)stitus ~ t;
ant = r.lu~ters StartClegl;
:let (te~p_ciuster_p->st~tus =s I! if (ronnt != rlusisrs_endfleg~) a~p_cluster_p++l pant ~ +;
i (count )= NAX CLUSTERS) WO 92/OSSlti _ S~ _ PfT/US91/06876 count = P;
ienp_c)usier_p ~(sirnct clusier.~ -act t)lrEtleg-ctIeglCAl));
uslere_stertf)eg7 = count;
.- F11;(CTTOt(: get nett cluster _ RETIIRNFr TRItF/FAI SE
_ cluster inlee -_ cluster_p DESCRIPTIOR: -gets nest cluster that is used ~t/
n boole~n get_ne:t clusterlleg, claster_inde:, c)uster_p) inter int leg;
inter int lciuster inde:;
icter ciratt c)nster strurt tte)ucter_p;
r.luSt~r_inAea)~i;
claster_p)rt;
(!cluster-finder )= IIAX_f:LUSTERS) 3clnster_in~le:) = !;
tctuster_p) _ lstruct cluster_strnct lllitleg_cCieg1C911);
(!cluster finder != clusters eadClegl) etarp (tRtIF.);
se etete (fA(SFI;
_ )UIiCTI011: get_free clas~tw __ RFTUR1lRr TRUE/FALSE
_ clastar_P
_ siriag_P
_ DESCRIPTIDYr -get ne:t c).astet that is free !/
w ~aale~n ~et_free clastar(ieg, r~laster_p) strfng_p) icier int Ieg;
islet struct cluster stract i!cinster_p;
inter sttact string sttact ttsiriag.p;
cluster ead;
aster end = clusiers_eedClegl;
aster eadiE;
( clastet and )= MAX_CLUSTERSI
lutaer end s i;
lclnsler_eed 1= cJnsiers_stertCleg)I
iclaster_p) _ (strut! cluster stnact t)(~ileg_cCleglLclasters endClegll));
latrieg_p! = tftlaster_P!->striwl~r;
tclasier_pl-)st~tas = STATUS UIItllllflll;
Irlaitet_nl-)op'n_trpe ' C01E TrPli UII>(IiOUR;
lclustcr_p>->opaa start stop = ST 5P UUrIlOYU;
tc)aster_p)->sirin! dir = DIR UliIi101fU;
tclaster_p!-)aa~ ctriegs = D;
lcluster_pl-)cbcege_rel has ~ i;
etarn (TRUE);
se og_errort~U~.L.CIUSfERS);
~iurn (fAISE);
fUNCTIOA: use_free_clusier _ RETIIRtIS:
_ D6SCRIPTt08: -ase free cluster gotten by get_tree_cluster t/
d use"free cluster(Ieg) aster ant leg;
uci~rs Pnd~lPnJ~iq (clusters endlleg~ )= MAX_CLUSIfERS) lu5ter5_ond~logl=i;
- FURCTIOR: get ne:t el~e~nt RETURNS: iRl)F.lFAI.SE

_ tlele~ent_p _ >tienp_strin9_p-)start _ DESCRIPT10U:-apdates pointer to nect elenent rithin current string i/

w baaieaa elenentleleoeat_p, teep striag_p) get neat_ nri e)ss~oi i!~)eee~t_p;
sirrct uct strieg_ttructlteep_siring,_p;

(find code == TRUE) eep_etriog_p-)startf~;

tei~e~t_p)it;

5e en'_striag_p~)starteit t~)e~eat_p)i~;
rhiletienp_string_p~)start i tenp_striag_p-lend);
lI teen string_p-)start t= teep_s,triag_p-)end) etara ITRUE1;
c!
eturn (f~.LSE);
_ fUNCTIOR: dec_liaear _ RFTURBS:
OESCRIPTIOIIr -t/
d dec_Iineartleg, cla:ter_p) zcan.,p) leg;
nct cluster stract lclaster_p;
on Iran cirnrt tscan_p;
wct eis~eet_stract iteep_ele~eni,_p;
len, z, bo:;
n hnol~an gond_Iinear;

' ~nAe llIAX_I:NARS1;
tcluslPr-p-)string die == FOh~
wp_eleeent_p - 6(cluster-p~)~ort-scan.elenentsClJl;
iP
rep-elenent_p = ilclnster_p->wort-scan.elenentstifAX_ELEBENTS-21);
=~ rla~ter_p->:lort_acan.)en;
tch (clnster_p->open..trpe) use I25:
nud linear = der_i?.5_)inear(cluster-p, )ee, Attep-eleeeet_p);
Pak; F
~ ie 1;
'eat;
~P CODE_A_RAR:
ood linear = dec_cod_lieear(cluster-p, lee, Ateep-eleeeet_p);
eat;
se (Ipff.AN:
ood-lineal = dec_npc._lineaf(clnster_p, leo, J<teep eleeent_pl;
vak;
ae C12R:
cat;
good-linear) us~tet_p~ )codefrluctef_p~lcodrfi7lf11=f;
(rlnster-p-)String die == FORYARII
!ep_s)Pe~ni_p = tl(clasier_p~)~ort crao.ele~eetcf171g en = clnsier_p-)port scae.lee;
:luster_n-)avr rel_pos s i;
~orlt=i; f ( tee; If~) c7~ster_p-)avr-eel-pos = eInster_p-lave rel_posi t teep eteaeet_p->ret_po:;
te~p_eie~eet_pit; -laster_p~>avr eel-pos r claster_p-lavf_rel_pos / I;
-luster n-)avr_tac-tine ~ (rlncter_p-)avr tic tine i sc~o_pwltac_tieel / 2;
se eep~eleeeot_p = ~(clusier-p-l~orl~_~tap.
eleeeotsCMAX-EIENEHTS-27);
en = claster_p~)~ork_scan.len;
IustPr_p-)avf_rP)_po~ = 9;
Of(Irl; I ( IeG; ffi) cinster_p-)avr-eel-pos = claster~p-)avr eel-pos ~
teep eleaeet_p-)rel_poc;
teep eleeent_p--;
r :laeter-p-)avr tet_'os ~ clnster_p-lave-rel_pos / :;
Insilr~->avf-tac-tine ~ (cluster-p-lave tac tine t l;cae_p-)tacH eel / 2;

f Ilc~atmo-fur(rluct~r_pl=-TRIIF) f ((I~or = get_bot(leg, cJusier_p ' !- 255) ~(in-rnnnnuf(bnx) rtuster_p, 3>
- FUIICT1DN: is_upen_for _ RFTIIRNS:
_ DESCRIPTIDN: ->i l d is_open_for(leg, cluster_p, sc~rn_p, teep_string, elenent_p, string_p) tegi act cluster struct tcluster_p;
m 1 sran_strurt isr~n_p;
act string_struci teep_string;
act el~nent ;tract telene~t_p;
act string_struct fstring_p;
Ict string_struci uer_siring;
ten, ~;
a bool~an is_opeo;
x citing = tmp_siring;
itch (cluster-p~lopen_trpel use I25:
is_open = is-i25_~pen_f~r(c)rster,.p) lner_string) eleeent_p);
rest;
ase C.i9:
rest;
ace CI1DF A BAR:
is_open = is_cod_open_for(iluster-,p, tnlr_string, eleeewt_pl;
rr~t; .
ase IIPCf.AIi:
is_opeu - is_upc open_for(clusier-p, liner-string, eleeent_p);
teat;
ace (:128:
rr~t;
(is_openl lI --yes, initiilire and use clN~tte n i/
,tying n = ner_string;
luster-P-Irnrt-cc~n.sr~n_nee = sr~u_p-Iscan_nue;
iuster_p->rart_sc~n.len= teep string. end - teep_4tring.st~rt i 1;
Iuster_p-)tort siring = net-string;
)uster_p->nrn strings~i;
luster_n-Irnrk_Sr.~n.ele~erattG~l.b~r = 1;
luster..p-)rork_sc~n.ele~eitsLf7.sp~ce = 1;
lacier-p-)tort ccm.elenentsli7.re1_pos = 1;
Pn =clrster_p-lrort_scin.len i 1;
oarpr(tcluiter_p->rnrt_srae.elenents(17, eleeent_p) len);

WO 92/05516 - 61 - Pl'T/US91/06876 iuFter_p-Ivork scaa.e)enentsCl:l.open_~trpe = w aster-p-iopen-type;
)uster..p->rork_string.end = hen fring.end -her ing.start +t;
-luster-p->vort string.start Wit;;
iucier_p-)last naich = claster-,p-)York string. end;
luster-p~)old_Iast hatch - c)nrter_p- »ast hatch;
lustpr_n-)change-rel-pns = MAX-.CHANGE-REt._POS;
iusier_p-)avr tac_ti~e = sran_p-)tac_ti~e;
luster-p-)depth = scan_p-)depth;
loafer-p-)n1A_vnrt-String = cinster_p->rork~string; -iusiPr_p-)old York scan. scan-nun = c)nster_p-)tort scan.scaa_nue;
luster_p-)o)d_rort_scan.len = clnster_p->rert_scan.len;
nr(c=A; z( ciu5ter_p-)tort scan.len; :+~) cluster-p-)old-rork_scan.elenentsCr<7 = cluster-p~)vort-scan.eleeentsC:I;
SP 1'rPe-flaSter(1Pg);
ec_Jinear(leg, claster_p, scan_F~);
lniter_e-)r,~Aeffl=9;
_ fUNCTIONs is_open-rev _ RETtIRNS:
pEBCRIPTIONe -I!
d is o~ea_rev(leg, c)nster_p, scin_p, te~p_string, eleeeat_p, string_p, curreat_stri~g) leg;
act r)asier sirnct =clur;ter_p;
act scan slrnct lscao_p;
art strirr' itrnct tenp string;
nct eleeeet_stract leleeeet_p;
art string-struct Istring_p;
ncl siring strnct cnrre~i_slrinp~
nct striag_stract aer_strin~;
lPp, :;
n ~ooleaa is_open;
r string = teep string;
itcb tclaster-p-)opeo-type) ase 1251 ir;_npfla = ix_i?5 open_rev(cluster-p) W er_xtring, eleaent_p);
teak;
as. t;39t rear;
ase COpF A BAR:
is_open = is_cod opee_rev(clnster.-p, t<aev-string, eleaent_p);
teak;
ase ul~cFAN;
is open = is_apc_open_rev(clnster-,p, Gaer-string, elreeat_p);
teak;
asP t:1?Bs WO 92/05516 - 62 - PCT/US91/06t376 rnaYj o G-O~Pn) /t -~rl~~ lnltia))IP lad aSe fla~tPfS
Stf111g_p r n!Y_Stfing;
t45ter_9'lrOfk_iCaa.SCin_aUa = S~aa_p-)SCin_aUllj mstPr_p-)rork_sran.)en= teep_~tring.start -cutrent_string.staft t t;
iu,ter-n-)work ,tying = ner_strtng;
tuster_.p->nue_stri~gs~i;
Pn = r)usfer-p-)rork sran.lert ; );
e~cpy(6clusier-p->rort_scan.elenentsiNAX-ELEMENTS ~
(len t 1)l, ~sran_p->~lenent5tcurrent string. start-t1, lent;
tuster_p-)work-scan.ele~eats~MA~i_ELEI(ENTS-17.6ar = i;
)uatPr_p-)rorc Stan.e)e~sntcfMAl(_FIFMFNTS~l7.sp~re = f;
luster~,p-)rort_scan.eleeent.CMAI( ELEMENTS-ll.rel.,pos = i;
lu5ter_p-)rnrk_scan.eleeentstMAl(_EI_FH~NTS-1-ll.open_type =
clnster_p-)open-type;
)oater_p-)tort ~tring.start = ne~r_ctring,start ~
(NAX_EIEMENTS - her striog.end - 2);
tust~r n-)last ~at~h = ciu5ter_y-)tort string. start;
luster_p-fold last hatch ~ clnsl;er_p->last_eatcA;
m sier_p-laort_string.end = (NAZI' FIEMFNTS ~ ?);
luster_p-)change_rel_pos = 1(AX_CNApGE_REL_POS;
tuSt~r_n-)mr ta~_tine = scan_p~)tac.ti~e;
lrster~~p-)depth = scan_p-)depth;
)oster_p-)old_rort_striag = rlaster_p-)rort_striag;
luster_p-)n1d tort s~an.sr.~n hue = cluster_p-)tort sc~n.tcan-nn~;
trster_p-)oid roft_scan.len = clastef_p->rort_scan.len;
arts=b; :( clustPr_p-)tort sran.lea; :W
cluster_p->old_rort_scas.ele~evtsC:7 = claster_p-)rort_s a n.eleeeatsC:7;
,r fre!-r.luster(leg);
ec liaearlleg, clustef_p, scae_pl;
iuster_p->rodelA7=i;

)f~*)I:*******~C7v:~GlI.F/:~ ~ )p:)F:7~:)XaX*~C*~~(**~(*~,~~(~*~~~ fi~r,~
~)I~illJll./.)RJIIITfiTJIWRTTTTTTT TTTTTTTTTw.TTTT~
User I~h~e,~. ,.tE~FF <;-' Queue: SEF' -FA/1~'FII'IT<~ 0 0 o=v.l.~~ 1'L'.11~Ip~ r)VF~Fyl..rl .: Server: SEf~.c I)N3G r J. ~) f.'t. pTl: OVE.fiLAY. C
SF:1=TI=t'fT~t=fs ;lay :1990 11:1 ate :~:~1:~1:*~f:%:*~l:~F:~W:~t:>5:~::Y.~?:~:*~?:~?:~?:tai:~:~:~p:~f:~l:~:**~!:*~1c *******************************************
.1 f':EF:Cf.' FFFFF' FFFFF
J E F F
.J F F F
.J F_EEE FFFF FFFF -(I F: F F
J ,J E F F
..1. l.~ t=..I= >=FE F F
~1:~::6:~p:~l:>I:~I:al:**at:*>s:**y~:~:*~!:*~i:~Y:>f:******:6:*****************
*****************************
000 V V EEE:EF~FiFVfiL AAA Y Y CCC

f~ V V E R t. A Y Y C C
Fi A

C~ V V E f3 L A Y Y L'.
U R A

0 V V F:f~!-F~~,~1.. AAAAAY C

iJn V V F r~.F;L AA Y .. .C

C~ V V F Fi 1 A Y .. . C C
t~ fi A

UUU V EEEEF_f, LLLLL A Y . . . CCC
R A

:K:K:K:K:K:k~C*:K!K:K:K*:l~:fr.K************:Ic********************************
*************
r _ HANE: nv~rl~r.c OpTF.: a9/td/9!
PROGRpNNER: Jeff Sharps _ DFSf:RIFT)(1H: -il DRX TEGHN01116Y H1TH DSP-TN5 3?iC3f Copyright (c) ,1998 Accu-Sort S~stees, inc.
All rights reserved.
-)ode 'ronn.lil' :lode 'conn.eit' FUNCTION: overlay - RETURNS; cluster_r-)eork_strinn _ rort_scan tast_natch string_p-)end _ AESGRIPT10H: -i/
~ ovm )~r_rPCpance nverlir(scen_Ip, string_p, c)uster_p) mi scan 5iruci tscan_p;
ur.t ,tring_strrct =ctring_p;
uct claster_strnct ~closter_p;
ister strrct elenent strrcf Rpl, tp2, ip3, xpd;
index, ner_rel_pos,i,~) change-rel_pos, q4_eatch, fron start, left i~de:) t iwlex) t_froe_st~rt, jstop, li!~, t ten, scans_skippel) x, ap_nork;
mi el~esnt Ftract 1t1, 1t2, tt3, ~U ;
ict eleeent_siract trark_eleneat_p, l~er_elenent_p) old_p3;
(rtu~ter_n-)5tring_dir == FORiIARI) /i -overlay in for~ard dir i/
t=rort_eleeent_p = (~(clnster_p-)pork scan.
elee~ntiCcloster-p-)nort_strksg.e~l1)1;
?=ner cleneat_p = (t(scan_p-letee~c~tststriag_p->start7));
~x_rel_pac = ccan_P-)eleeentslstr;iog_P-)eedl.rel_pos;
a_~atch = 4;
rnn_start = B;
f(ctring_P-lied >= string_p-)stars:) a /t _-dose prior NiIR_OIIFRLAY P)enents of rart_stting.end /!__ Batch rich eer string t/
~nA~.x = 1;
left fade: = ~;
if( (is_ci~-ridthl(p1-)hay t pl->sparel,(p?-)hay t P2-)spacel))1 do c left indext~;
it()efi index == Nlli 011ERLAY) ( _ _ Pa - P1~
P~ , P24 WO 92/05516 _ 65 _ PGT/US91/06876 rz--;
)rhile( (is_sie ridtAl(pi~>ber p1-)space),tp2->baf + p2-)space))) ii (is_sin ridth((ptCtl.ba nt->space),IpzCt7.bar + p2-)space) » ii ( pt->rel-pas != !) ii t p2-)re)-poc !_ g) );
iftlafk_ind~: >= IftN_OY~RIAr) C
pi = brort eleeent_pfll; -p~ = Ar~er_e)e~eni_pCIJ;
/i --does at )eist the ne:t !!it( NA1CH e)eeents of /t roll string.end watch rith the net string t/ ' rhiin( (is_sie ridtbl(pt-)hat + pt-)spac!),(p2-)bar + p2-)space))) ii lis sie ridthllpt-)bar + ptE-tl.space),(p2-)bar + p2C-l7.space))) ii ( pi->re)-pos !- 8) ii p2-)rel-pos != P) i~
( p7.->haf ) !fill COUMT) ii l p2-)space ) Ntlt_COUIft) t inAe:++~
pt+t.;
p2++;
if( (l left_inde: + indec> ) lqyeatch)) ~6 (lode: )= iflR HATCH) ) _ t )en : clust~r_p-)rort_4tring.~e~d i indei+1;
lYile( ~t pt')rel-pns != i) iJt t ~2-)rei-pos != 1I ti t'2-)hat ) M1U Gf1111fT) ii ( p?->space ) If)M CDUNT) ) t )~Ni;
p1~+;
pz+~~
s qq_e~ich = I<~ft_indet i indet;
tl : pt;
t7. = p7;
t3 = p3;
t~=p~c t finder = inde:;
t~_frae_stmt = fron-~t~rrt;
t_L!p = tlo;
/t-_-updite nt'r tc~ nest e)e~ent, search for best fit t/
froe siart~t;
n~~ eter+ent-p++; ' of = tort eter+eet-p;
~2 = ne! e)eeent_p;
:bile( tp2-)re1_pof; (= n::-r!I_posl ii (pz->reL-pos != B) nd~~ = t indec;
eR ~ t_llp~
f(qq eatth ( MI8 oA) WO 92/05516 PCT/US91/0687ti /t---siring a. not ovlrl~y tl ~f(clusier_p')5titu5 == POSS_OPEII) 1 claster.p-)change-rel_pos = NA,(_CHANGE REL. POS;
r)u~tPr-P- » act mtrh = rluster_p~)~ort_string.end;
cluster-p-)st~lus = DECODEIll6( return(OVERLAY_OFF-START_REC);

~f(r)u~tlr-p-)status == OPEN) ( /i _-if si~tas = DPFN update ~ott string.tand, status =
/i DECODEIil6, return OYERLAr OFF_START REC t/
clUStpr-o->wnrt string.end = cluster_p->l~st_mtch - NTN_NATCN-1;
clastrr_p-)status = DFCODEING;
rliurnlOYFRLAY_DFF_START-REC);
PISP
( /t -else port-string.end ++ t/
ift(clustrr_p-laort_siring.end - cluster-p-)aort-string.start) t (r,lusrer_p-)work-S~an.len - 2 - AIM MATCH)) ..
t r)usiPr_p-lenrt string.lndr+; ..
return(OYERLAr_RECURCEI; ..
) else ( cluster_p-)oId aort string.eed++;
cla5ter n-)aort_String = claster~p-)nld~~art_~tring;
rlustlr_p->unrt_sran.scen_nue = rloster~p-)old fort scen.scin-nue;
cluster~,p~)rrork Sc~n.llp = clnster_p-)old_vott scen.len;
for(:=A; rt cluster-p-)old-work scm .len; :++) cluster_p-)aork_sc~o.eleeents(:l = claster~p-)ald-trort-scep.eleeeetsC:7;
rltsrn(OYF.RI AV_Rf.GOYf.RI;
')f!
;I 1 = t l;
p2 ~ t2;
r; = t a;
P~ _ t~;
if( ( (cluster-p-)aotk striag.end n indeil ( fclaster_p~)list ytch-2) ) )) ( len ( fcluster~n-)~ork_scm.~len-2)) ) . ( up~~ort ~ 9;
. ) else up_~ork = l;
) a~='~;
P~=P~~
/t_--if stiles = POSE OPEN or OPEN set elleeeats used /i in opee patters end c~lcnl~te ch~nge~rel_pos t/
if( t(ciuster-p-)st~tas == POSE OPEIII )l (r)uster-P-)stelus == OPEM)) if, tun_m rt == ~~ - 67 -p) = ~plf( ItIH OVERLAY-t)7;
,n2 = ~pztt ltlft_~liiFRLAIt-C)7;
j=1;
rhilellpl-frel_pos != l;Aa /I set open_trpe in element t/
Ip2->re1_pos != p) ) _ t if( pf-)open-type != Af p2-)open_trpe = p1-)opea_type;
ni--;
p2__~
) It -update cluster information t/
cluster_p-)rort_string.inde: = string_p->inde:;
if(up tort) cluster_p->last_watch = clnst~!r_p->rort_string.end i index;
change_rel_pns = (p3-)rel_Pos ° pl-)rel_p~s);
if(up wnrt) t if(avr tart) t _ o)d_pi = >tp3i ip3 = tp~l; /x set-np net tort i/
pb-)4ar = (olA_p3.har t p3-)har)/2;
p3-)space = (o11_p3.space t p3-)space)l2;
else tp3 = tp~; /t srt-ap n~~ mart t/
) ~Lse t pf = P3i P2 r pli jstap;iNe: a MIk OVERLA1-1;
index = 1;
~r~' do I
ind'tri;
p3~~;
p~~r;
(ftp3-)rel_pos =~ 1) ;step = 1;
iftt~siop !_ !) Ll tp4-)re1_po~s != f)) jstop--~ _ jitt cYmge_se1_pos = cban9e_rel_poc s (pl-)rel_pos - pl-)rel_pos);
iftap ~nrt) iflavr port) I _ old-p3 r tpE;
tp~ _ :p,; /t set-np men port t/
p3-)bar ~ told_p3.6ar ~ p3-;IYar)12;
p3-)space = fald_p3.sparrr v p3-)sparel/2;
I
e)se ip3 r lp~;

else if(oP_rort) Ip3 : tp~~
)IlhilP(p4-)rRl-pA5 != A);
iiI(scans_skippPd = (ccan_p->sran nun - clustPr_p-)rork_scan.scen_nu~l) != i) if(cluster_p->change_rrl-pos == IfAX_CHAHGE_REL PDS) ~.lrster_n->chang~_rel_pos = (t~;hange_rel_pns) / (j)1 / sc~ns_skippel;
else r)ustrr_p->rhange_rel_pos = ((c)uster_p-)change-re)_pos f change_rel_posl (j X11) / scans_skipped;
if(un_rnrk =a D) ( P3 a Pli p4 . p7;
rhile(p3-)rel_pos != 1) p3-)rPl_pos = p3->rel_pos - r)uster_p-)change_re)_pos;
(~3~~;
pl~~.;
)uster_P-)rart_scan.scan_nue = sc~n_p-)scan_nn~;
f(rp_rort) ~:luqter_n-)rork_SCap.len = cluster_p-)rork_string.eod i tH ez - NIII_OVERLAT;
if(rlaster_p->stalus == DFCODEItIGI
/t -if status = DI:COOEDIIiG, update tort strieg.erd !/
if(cluster_p-)tort string.end ( cl,rster_p-)last retch - HIH MATCH ~ 1) c)astsr_p-)rork_sirirg.end = clar;ter_p->lest_netch - H11( MATCH - 1;
return (TRIIF.);
SP
/Z --0Vlrlar 11 reVlfC! dir ~/
t wnrt_eleeent_p = (hlcluster_p-)cork stew.
ele~e~tsCcluster_p->rork-string.start7)>;
?=nPr P)s~ent_p = (6lscan_p-)ete~eetsfstriog_p->st~rtll);
3t-rPl_pos -- scan_p-felenentsCstrieg_p-)tnd7.re1_pos;
~)_~~tch = i;
roe start = i;
f(string_p->Pnd >= string_p-!start) n /i _-does prior ltlH_OYf.Ri.AY ele~ests of rort_strin~.end /!__ hatch rith nnr string t/
inch= = 6;
left indez = 9;
if((is_si~ ridt6((pf~)h~r t p1-)space),(p?->b~r ~ p2-(space)!)) do ( -left inde:~~;
if(lefi_inder == Mlll OVFRLAT) t p3 = pt;
P4 s P21 WO 92/05516 PCT/US91/Ob876 g~rr; _ sg _ ptrr;
%rhiJet tis_sie_ridih((p1-)har J-)spacel,(p?-)bar t p2->cparel)1 4t<
(is_sie_ridthllpl-)bar i p1C-l7.space),fp2-)bar t p2C-J7.space)>) a~
( nt-)ret nns != 81 6i l p2-)rel_pos !_ !) )f if(teft inae: )= MIH OIIFRLAT) -t _ _ p! = ir~rt_e)peenr_pr-17;
p? = lner_lleelnt_pC-I); ' It__-does at lest the ne:t ltlR l(ATCH eleeents of /I tort string.e~d etch rich the net string 1/
rhite( Iis_sie wiath((pt-)bar i pt->space),(p2-)bar t p2-)space))1 ~~
lis sie ridth((ptCil.bar ~ p!-)space),(p2CI7.6ar ~ p2-)space » ) 3Z<
t p1-)rpl_pos != A) it l p2-)rel_pas != 41 ~~
( p2-)bar ) NIN t:J1U11T) ii ( p2-)space ) Mtlt_C~UMT) ) t inae:~i;
pt-_;
) if((I left indl: ~ inde:l )_ (QQ,eatrhll it (i~de: )= !1111 HATCHI
) _ t )e~ = NAX_FIFNFIITS - rlaster-p-~)rort string,statt i 1 i i~der;
rile( ( pt-)rel-pas != fl t<t=
p2-)rel-pos != 81 Ai t p2-)bar ! 1(1R COUIlTI Ai ( p7.-)pace ) lflN COUIiTI
) t le~~i;
pt-.;
p2..~
qq_~aicA = left_indl: f inde:;
tt = pt;
t2 ~ p2;
t3 = !3r t, ~
t_inaei = inae:;
t frog start = froe_start;
i_I!n = lee;
/t_--apdate net in ne:t elenent, search for best fit X/ ' froe ~t~rt~~;
n~.r_eteoent_pi~;
pt = tort lle~ewt_p;
p2 = net eteesnt_p;
rlile( (p?-)rel_pota t= eri_rel_poa) ltE
(p2-)rei.goe != il )I
ndes = t inde:;
e~ s i_le~;

f(qq-nalch ( fiIM.QA) /;__-siring dire not overl~r ~/
if(cluster_p-)status == POSS_OPE)I) r ' Uuster,.p->change_rel-pos = MA1;-CHANGE REL POS;
r)usier_p-))isi eetcb = clusier_p-Irort_string.stirt;
cluster_p-)st~tus = DECODEIIiG;
return(OYERLAY_OFF_START_RFCI;
) ~f(clusfer_p->siatus == OPERI
/i _-if ct~tus a DPER update port string.end, status =
/i DECODE18G, return DYERLAV CFF START REC f1 cluster-n-)tort string.st~rt = rluster_p-)last_mtch ~ Nllt_HATCH f 1;
cluster_p-)status = DECODEIBG;
r~turn(DYERLAr_DFF-START_RfC>;
als!
/t -elsr rPrt-!itrlDg.St7rt -- t/
it((cluster_p-I~ort string.end - cluster-p-)rort_string.st~rt) (r.lu5ter-p-)ynrt_sc~n,l~n - 2 - MI11-IIATCN)) (_ r)ucier_p-)tort siring.ct~rt--;
returntOYERLAY RECURCE);
else f clrster-p-)old-tort sirinl.st~ri.--;
r,lust~r_p-)rrort-string = cluster n-)ald-unrt-strteg;
rlasier_p-)tort scan.sran_nue = cln~ier_p-)old tort st~t,.scan_nun;
clesier_p-)tort sc~o.len = clnsler_p-)old_~ort sc~a.lee;
fur(:=A; :! rtuster_p-)olb tort scsn.len; :rt1 cluster_p-)rort_scsa.eltetetst:l = claster_p->ald fort-su t.elenettsts7;
reloretOYERIAY_RFCOYfR);

ae .1 = tt;
w2 - t2;
3=t;t;
1 = t~l;
f( ( (cluster-p-)~ort strin~.st~r~t - inlev) > (cluster-p-)I~st_n~tcd~2) 1 II
lpn l Icluster_p-)tort-scan.leH 2)) up_rort = b;
~lst up-tort = 1;
~t=p3;
,~-P~i /~ _-if si~tas ~ POSS OPER or OPEII set elleeeats rsed /t__ in open p~tterr~ and calculate cb~~ge_rel_pas t/

WO 92/05516 _ 7~ _ PGT/US91/06876 ~f( ((r)uster-p-)status == POS:~ OPFM) !~
(cluster_.p-)status == OPEN1' ~i (ug_~nrk == t) ) p1 = 8pll( -N1N OYERLAP~11);
n7. = 6n2t( -!(IN-OYFRLAf~lll;
j.di abi)e((p1-)rel-pos != 9>8A /I spt opsn_trpe in elenent t/
ip?.-)ref-pos != 0) C
if( p1-)opPn~irpe != p) p2-)open.,trpe = p1-)open-frP~';
nlrt;
p2~~;
) -apdat~ r)usier iaforeation i/
c)asier_p->rort_strieg.inde: = saring_p-)iade:; -if(ap_rark) claster_p-)last hatch = clnster_p-)rork_striag.start ~ inde:;
cAangr-re)-Pos = (p~-)re)-pos - p3->rel-post;
if(up_~nrt) C
if(avr_aortl C
old_p3 = Ip3i Ip3 = tp4; /t set-ap net tort =/
p3-)bar = (olA_p3.bar t p;->bar)/2;
p3-lspace = (old_p3.space ~ p3-lspac~l/2;
else =P; = =P~t /l set-rp eer tort t/
~1~~
C
P) = Phi P2 s P!i ) jstop~infa: ~ NCM_OYERLAY-i;
~adrt = t;
i ~ 1i ~i n C
iad~w ii p3__~
p4--;
iffp3-lrel_pos == i>
jStop s 6;
if((j:top != A1 ~~ (p~->rel-pos i= 1!) _ jstop_-=
jiii cAaage_re1-pos = cbaoge-reI_pos i (p~->re1_pos - p3-)reI-pos);
-iflop-~nrt1 tf(avr rork) I _ old_p3 = tp3;
AP3 = EP~i /! set-ap oea sort t/
p3-lb~r = lold_p3.bar i p3-)bur)/2;

o.~-~,nace = mn_pa.space r pa-mpicem r.;
i rise IP3 : tV~;
else i f(t~p_rnrt >
tp3 = tp~l;
irhile(p~~>rpl-pns != 9);
if((scans,_stipped = (sc~n_p-)sc~n nun - cluster_p-)rort-sc~n.scin_nun)) != 8) iflr,lu,r.er n->rh~nge_rel_pos == NAX CHANGE RFL_POS) cluster_p-)ch~ngs_rel_pas = ((chinge_rel-pos) / (j)) / sc~ns_skipped;
p)cp c)ustrr_p-)chrnge-re)_pos = ((cluster-p-)ch~nqe_rel_pos r change-rel_pos) / Ij rt>) / sc~ns_vtipped;
if(un_rnrt == A) ~a : r~;
r~ ~ P~;
rhile(p3~>rel_po5 != 9) P3->rpi_pnc . p3~)rPJ-Pos ~ c)u~ster_p-)ch~~ge_rel_pos;
Pz__~
n4~-;
-luster-p~)rort_scin.Fmn_nue a sl'in_p-)scm_nun;
itlup-port) cluster_p-)sort-sran.len = NAX I:LEHENTS - cluster-p-)uort-strin9.ttsrt r i>Ale,r - 1 - 81IN OYERI~AT;
ftclsst~r_p-)siWus == 1EC.OGEING1~
/t -if StltYS = DE.'CODEaINGr undete sort stting.enl !/
if(cluster_p->~ort string.st~rt J' cluster_p-)l~st ~~tcA r NIN HATCH ~ 1) rJusipr-p-)rnrt_strinq.start = clusler_p-))gist-each r NIN-HATCH r 1;
~~turn (TRIIE);

_ ~ _ .

:.rr.o.r,..~,**~x;******x.x.x.rax.rfn.r~.~...x..~n~.rrfi.tc~c*~,~~ ,~"..
(".,... (.. . . , . . .
P~1~TmTn,mmm~hmmn~.w.w , ( , t.J<.::~ r h1a n~~ : ,.Ih 1= f' ( ;°~ ) L~ueue~ : CEr 'ER4/f'F~ 1:
hI'rC7. ~~. .. .,. ~~.=. ~ ..
,- in, r~ ~~I:~rrN~: 'I:IJr XX Server: SE~...~A.
D~~_.~t'.i.oi:7.Uli: 1:1~1T._.XX.C;
;:I-'.F''rl-t.'fI~hC a ,, a ~r'~r t~ 11:10 Sri >i:~:~:~:>7:>l:rl~:~:>S:)1:~:~?:~:~:~I:*~:x:~S::3:****1?:)Y.>I:)Y.>1:~1:****11:
******~!: ********************~B**********:
(I rl=FF_C Ff FFI= FFFFF
J E F F
c= F
J EEF_E HFFF FFFF
,I (= F F
(.1 J E F F
..J. l.,J F FFT-'.E I= (-' n:~:**~:*x:~l::I:~i:*»:~t:~lc~l:*****:I:~I:**x:~:~i:****~f:~l:*~!c*****:f:*****
****~t:***********************s ): hd T'TTT'r X X X X CCC
I h!
.1 T
T

a ht 'T X X X X C C
hl a Ltr~ ~r x x x x C
n 1: h! T' X X C
1!
1~

t: h! 'T' X X X X .. . C
l~tf~1 1 wi T X X X X .. . C.
h C

x w T' x x x x . . CcC
x7 ~t .
zz :k:k:k*:k:kAcYrfc:k:kAt:K*:kk:k:k*Yrk:~lc~lc****:Ic***xc~lc*7k*****************
**********************~I
d WO 92/05516 _ ~4 _ PGT/US91/06876 _ NAtfE: int zi.c OATF; d9/tl/96 PROLRAf111ER: .Jeff Sb~rpe DESfRIPTIDN: -i/
DRX TEGHN01.(IGT 111TH D5P-TNS z?~G31 Copyright (c) 1991 Accu-;5art Systeas, inc.
Att rights reserved.
iuAe 'cna~.)ii' lode 'co~~.ezt' FURCTION: c intlt(1 _ RFTORNS:
_ DESCRIPTI08: -~/
1 c intll() FUilCtt0li: c_intl2() RE TUR)!S:
~EBCRIPTI011: -~t/
i c_1et12(1 FUItCTI0II: c_iatl3( ) RFTURI(S:
~E8CRIPTIOIir -~t/
1 c iatld(1 star int boz;
Bier ~trpci hoz teble_siruct fbaic_p;
~(' or 21116,st'); /t cb:abed frog 211~h t/
tiee~~;
~tboz = f; baz l IfAX-FOXES; 6ozfi I
n _p = l:tract boz tible struci tl(btbot_cLleox7J>;
.'tb~z n-)tz_t~c_ti~e 1 R) ~nz_P-)tz t~~ t3ae--;
f(boz_p-)tz t~c_tiae == I1 :z-rnAet(6ozl;
,(' zor 2111h,st'1; /! cb~a9ed frog 211~h t/
fUliCTlOti: c_iati~(J
RETIlRBS:

WO 92/05516 PfT/US91/06876 nFSCa)PT)nrr: - -f/
~ int91() ~ter union e)Peent_anion Ip?, ISt~rt_drt~, Ip3, tend_data;
stet int index, count, len, a~len, leg, ipl) old_sc~n_indei) st~t_reg_val; _ !ct Scart_struct (facan-atruct,-p);
- tint t)MFII-HAP-PFR)f_AASF;
/I -d~a global control .disable t/ ' (~I:f) = DMA_DISABLE;
/t -read in st~tus_regilaer :1/:? t/
t_re9_v~l = I(iat t)STATUS_REG;
/t__-save ending dea address i/
_Iata _ (union eieeent union i>(I(p1~1:6));
/I -save starting dm ~f~dress, t/
rt_drta = (union eleeent anion a1((intllo~d_data b .lint) (DlIA-START_ADD_MASK)) ;
J! _-dfterein wl4ich half of 1t hlott of internal tae gets JI__ the d~~ dada on the ne:t scan t/
/!__-flag light off t/
~(' ~~d ~bfb,tof');
(last_i == (ctat_req_val i 1:11D1 Ea (first_flag s= 1)) n(' or Hlh,inf'1; /i flag tiqbt on t/
ror_ipt_1~ - X1_X2_SAI(E; .
t : = tstat r!g_Yal b 1:11);
( laSt_: != A) /i _-get nea lea startiaq adiress leg 1t/
p1~1:6) = plfA_BTART RD1_X1;
'(bead == X) eq ° It se f(bead == SUPER X!
leg = ((stat_r~g val h fi71)/t6) - 2;
lse iflhead == H_55) )eg = 1;
:e lt__-get nee dea starting address leg fI/
pl~~:b) = 9MA START_A0D-X2;
if(bead != SUPER_X) )eg = 1; ' else )eg = (lst~t_req_va1 a It7il/1!~) - ~;
Jt~-snit dea registers !/
~)~1:8) = INA COIIRtFR REt; /i dea transfer coaster register t/
~Ii~id) = 11(A_SOURCE_Adl; /I dea sosrce address constant tl WO 92/05516 _ ~6 _ PCT/US91/06876 yl~8rq) = ~NA_ENA8I,E; /: enabl! Ae~ t/
.-rNIDMA-FNARf.f_NASKI; ~ .na int enahle east t/
/i-_-enable interrupt irl for dna t/
n(' n «9,ie');
tfirct-flag == 1) irst_flap = 8;
/t---if first sr~a init for aer read cycle t/
ie /I _-s we only the scans that have I or wore strings over /i__ NIN_TRAN9-LEBGTH amd turn on flag ligbt fl en = end-data - start_dati;
~(len ) v?1) len = len;
~)en : oleo;
' (len >= N(N TRAMS LEIi6TNl en~~;
~nd_da1 ->r)1 = P;
~caa_sirrci_p = tsirrci sca~_sirext tl(ff,(l~eg_sClegICscan~inde:Clegl~ll;
;caa strrrt_p->scav ore ~ scan cn~aotClegl;
~2 ~ (rriea eleaeat_rrios tlscav_strrct_P~)eleeents;
~7-NlI = A;
~2ii;
n = p2i :arrt -- 1;
ilea = 6;
'orliader r 1; lade: (lee ; fadetn~I
i f ( lstart data-)fiell.iar ( lllll_COUIIT1 I i Ici~rt data-ffield.spare < hflN_COtlllTf f if t~nrat t NtN_TRAIiS!.FI1GTH) i P7.=Pi i siart_data~i;
I
~lse ( aial' or fllhfiof'f; /I flag Iight on f/
if (oleo == 11 t oleo = l;
oleo = oleo ~ roost;
if(Istart-dais-ffield.bar != il .1 (start_data-lfield.spue lalfl .
~p2 = lstart data;
p~->field.nper type ~ 1;
p2i~;
nlen~~;
I
p2-fall = f;
p2~~;
n3~p2;
start_data~i;
vler~i;

~_aua(-8;
else i ip2 - lstart_d~ta;
p7-)firld.open_trpe = a;
start_d~t~++;
ifI(p7->field.rel-pos ) ~i~rt-.data-lfield.rel_pos)) ( if(n~C-tl.fielA.rvl_pn5 == 9;1 ( p~-lfie)d.re1_po~ = ctari data->field.rel_pos -(siart-dataLl7.fie1~.rel.-pos - start_data-)field.rel_pos>;

else if((start data->fie)d.har ( 81H COUNT1 11 (start-data-)field. space ( IIIR-COUHf)) p2-)field.rel-pos = p2C-tl.fteld.rel_pos +
(p7f-f7. field.rel_pos - p2(-?7.field.rel-poll;
else t p2-)field.r~l_p~f =p?.f-)J.fi~eld.rel_po~s ~
((start data-)field.rel_pos - p2C-ll.field.rel_pos)/2);
p7++;
coaal~t;
if((alea + roast) 1 (MAX_ELF.NEI(TS -T)1 i ides = lea;
error-itft 11 = SCAN_T00 ItIHG;

) if (ales )= ifIB TRAIiS 1E11GTH) old :can-iadec = scaa_ialecLle~7~;
srea iadecClegl c~; /i tade~c tato leg 5 array t/
if lscaa talecClegl )= NAX SCAN9~) swn-iadecfleg7 = 1; /t trap atroaed i/
if Iscao_ir~decCleg7 == proc_scaa_iadecCleg7) Jt fteld.space for net data ??
:/
scaa-inlecClegl = old scm_iade~c; /a tbtor star net data t!
error"iat_p~ = Fl)Il-SCARS;
Scan_Strnct-p-flea = ales;
su a_stract_p-)depth = gdeptb;
scan_s(rect-p-)tac tiae = trt_tiaet ) _ a a-coaatClegl ~i; /t tacreaeated every sr:aa !/
tleg><2) asst' or lilb,iof'I; /I card light oa t!
Se asst' arid lfbb,iof'); /t carp light otf t/

_ '7g _ FUIICTIOfI: c intf5( 1 (~ETI~RIiS:
DFSCRIPTtOfl: -_ 3/
I c intl5(f FUNCTt08: c_intf6() RETURRS:
)ESCRIPTIOIi: -t/
c tatl6() FUIiCTTDB: c_intl7( ) RFTIIRIiS:
DESCRIPTION: -t/
c i~tf7( ) FUIICTI0Ii: c_intl8( ) Rf Toalls:
pEBCRIPT101l: -tJ
c_intf8t) FUIICTIOIi: c_intl9( ) Rf TI)RdS:
pESCRIPTI011: -~ iptf9() FUIfCTI08: c_inttft) Rf.TIIRRF:
DESCR1PTIOIIt -Z/
c tnttlll ru(tl.IlPn: yuww - RETURNS:
_ OFSCR(PT(ON: -3!
c_i~ltt(~

WO 92/05516 - 80 - pGT/US91106876 >7:)7:)7;>f:***********N:Y,~:~?:WN.>I:r:)7:)XH:***********)7:**)X********..~.1«
K~~It~~fifi~.n.ww.w~wwr.w.w.w,wow.w.w.w..ww l.l~Hyr Name: ,.IEFF r;'"> i'Aueue~ ~°,~ 'ER~/F~RINTn_0 h~ ~i. 1.~ fJoru:,:: F'fif:h'hv. , ~; ;server : BEhVE~4 Drs.r.r~i.c~l:i.on; F'RI=FRQC;.C
<:;h.nr~l.lr.~r.-~:r~ :i ~ y :1 ~~<~Vi 11:10 am )?:7Y.7P:71:>F:*)f:)?:>i:)Y:)S:)X*>f:x:W.)l:H:n:~Y.~l:*~:*)1:~:~:
~:~:~:)Y.******~P:***x;********************************%
Fl 1?EI': r-I= r- ~-r= FFFFI=
,J E F F
..~ r I=
..l EF_EE FFFF f='FFF
,.i (-'. I= F
,.t ,J E F F
.l..l..l rrrr-..>= -r r >}:x:7i:*71:*~l:~I:~:**
***>E:***********~p:*:~:*:>t:********************************************
fvf'fv'f''l~RfsFiEEEEE F'f~'fv'F'r,'Rf~R000 CCC CCC

f'I-'Rrv r-. r-~r~rvR OQ C C CC

F w E F I. o c c F ~ r ~ a FFf'v'E:FW yF:rr;I~~WFr~~r~Rn C C
r: (~

Fv F: E: F R F O C ... C
R O

F' ~~ L--. ~ r.~ o c c ... c c o F' I~ EEE.EEF R R 000 CCC ... CCG
R

:~*:Rac:k:k:x:K:FC:Ic:Ictc:KAc:K************:Ic:*******************************
****************

_ HAKE: preproc.c ,_, GATE: 991t~19B
__ PROGRAItffER: J~ f f Sh~rpe _ AESCR1PTION: -Y/
DRX TFCHHOIOGT 111TH DSP-TlfS 37BC3B
Copyright (c) 1996 Accu-Sort Systens, inc.
Alt rights preserved.
rude 'conn.Iit' Glade 'conn.rrl' FURCT108: preproc _ kFTilR1(S:
_ DESCRIPtIDH: -Z/
d preproc(leg) legi urt cmn_sirucf tsc~n_p, teep_aort cc~o;,;
uct el~nent_stract Ielene~t_p, ftenp_ellenent_p;
wit clast~.r strurt lclaster_p;
act stri~4_stract lstriag_p;
.pct strlag siract tenp_striap,, mr_strinq, tenp ~ort_striag) carre~t_strolag;
a clastsr Statns tenp_ststas;
clusier_inde:, chect code, bat, i, decoded_gnod, lan) doae, ~, ov~rl~y~recover_coaat, overlir~_recarce_conat, :, sc~a_diff;
n nvertar_respoese nver_stsfas;
a hool~~e ov~rl~r~recover, clasf.tr_is_old;
r role fl(AX_f.HARS7;
(proc ac:l_scsatleg, ><teep strfagll %i~ there arc scsas to process t/
raa_p = (ctruct Bran siract tl(i(leg efleg7fproc_scsa_iadeilleg771);
/! = get ae:t slriag !!
hale (g:!t_nert_String Iscsn_p, ieleeaat n" iteap_string)) if( c7uciprc.st~rifl~gJ != clastnrs eedfl~~g7!
( _ cla5ter_tad!= = clusters st~rtt'1t~1;
ciaster_p = (strnct cluster strnct tl(i(le, clleg7tclnster iadai7));
do t _ rlustrr is old = FALSE;
if( (cluster p-lann_striast ( IfAX STRII(GS) ii (~tring_fits_in_ctu5ter(1~g~, eleneat_n, clutter_p, itenp_striag) istriag_p)) ii t(cluster is old = is clast~r old(le~g, c)nster_p) string-p)) _= FALSE) ii (clnster_p-)status != STATUS_UIIINiDUI(1 /i__-string fits into as:t cluster t/
f leap fort siring r claster_p-)rort_striag;
tenp ~nrt_scsn.sraa_nan = ctuster_p-)woirt_sc~n.scen_nan;

tPnp_rort sw n.~en = m aster_Pm tort-s« n.~en;
forte=6; ((cluster-p~)rort <.~r ~~,,Jpn; ci~) tenn_rnrt-,can.elenentsCil luSter_p-)rort_scan.eienentsC:J;
teep_slafus : r)usier_p-)sistus;
sc~n.diff = sc~a_.p->scin_nu~ - )eg_sCJfegJ(string-p-)inde:l.sc~n-nun;
3atring_n~~;
tstring_p = tenp_string;
~)uster_p-)nue-stringci~;
overl~r_recover = FALSE;
nvPrlar_recwer-count = B;
averl~y_recurce_count = A;
do n~r_sirins = ieep caring;
II__-teas the l~lring i/
trie(leg, 5~an_!1~ r,la~ter_p) iR~r Str'Ing! eleeeot_p);
if(clust~r_p-)string_dir == FORiIARD) ( if((cJusier_p-)status == 1)ECODEING) Li (over-status != fIYERI.AT-RECURCEJ
done = 6;
iftcluster_p->cb~ale_rel_pnc == NAX_f.HANGF_REL-PRSI
i=i( ~Ise j=t;
rbilelllner striog.st~tt - teep_stri~ag.stmt) ( IlIM_OYERIAT) ii (done == 1) t if((r)uster_p-)tort scm.el~eents (cluster-p-frort_ctring.eed ! iflN-NATCN f jl.space ) lllN-COUNt) ii (rlaster-n-)tort ~scen.eleeente tclaster_p-)rort_striag.eed f NIiI_NATCN t j7.6ar > NIN_COUNt) claster_p-)sort strin~.ee~lw ;
1!Y ftrtn9 = te~p_strtw~;
/t__-leis the string t/
tri~tieg~ ccia_p) clttsier-,p, asst-strip) eleee~t_pl;
if(lrlust'r n~)eort sces.eleeeats Icluster_p-)eort_string.eed i IfIN_I(AtCH ~ jl.sprce ) NIIf_COUNT) ii (cluster-p-)tort sren.elenents (cluster-p-)rort_ctrisg.end r NJtN-,MATCH s jLber > MIN_COUNT) 11t i i (seen diff ) 1)!/
3;c;
else Iooe~t;

else ~Inec=1;

ifl(eer sitiy.stsrl - te~p st.riag.stirt) < II11( OYERIAY) eer ~tring,~tart = teep-string.stert t IfIN OYERtAY;
ifllte~p_striy .esd - ner_stri,a9.e~d! < lIIN BATCNJ
per stria~.epd = le~p_strieg.e~l - NIN,MATCN;
if((claster_p-)st~tas != IEC01EI1G) it (nver_atatts != OVERLAY REC')1RCEI il<

WO 92/05516 - e~ - PCT/US91/(i6876 taer_4tring.ead t ner_.striag.ctart) t nrr_straag.ead = ner_string.start;
else ( if((r)astsr_p-Istalus == DFCODF1N61 ~l (over_,st~tns != OYERIAT_RECURCE1 ) d0ao = d;
iftr)uci~r_p-Irhaage_rel,-pos == NAX_CHAN6E_REt_POS) j=t;
else j=t;
rhilp(((tsep striag.~nd - ner_string.ead) < NIN_OYFRIATI i~
(dope L= f) ) C
if( (rlasipr p-)~nrt_srm.e)eeeat~~fcluster-p->rort_striog.start N1N NATCH -jl.space ) B1N CIDUNT) Z><
(ctuRt~r p-)tort scm.eleeeet!strlnster_p-)rort_striag.start - M(N_NATCN -jL 6ar ) BIN COUNT) C
r)ucter_p-?aort_string.st~ri--;
re~_string = teep_string;
/t~_'trie the string t/
trie(leg, scan_p, clastnr_p) inea string, eleeeat_p);
if( (clester p-)tort sc,rn.elevent.stclnster_p-)rort_string.start - B1N_BATCH -jl.space ) B1N COUNT) Gfr lclnster p-)sort scae.eleneet.stclaster_p-)tort string. start NIN_MATCH -jl.bar ) NLN_CO~UNT) !t ii (sun cliff ) 1 )!/
) ~+~i rise Ionerl;
else dons=);
s if(tte~p_siriag.ead - eea striog.eedl C BIN OYERLAT) net ~tring.ead = teep_string.end ~ IiTN OYF.RLAT;
ifllaer striog.start - teep striag.start) ( BIN BATCH) wet striog.sfari = teep_striag.stari. + Nlti_BATCH;
if((cJnster_p~)statas != DEC0DE1NG1 1~6 (over status != AYFRLAT ~RECURCE) IU
(aer_string.ead ( ner_strieg.stari:l' I
per_siriag.siart = n~ ctr~!ng.end;

ctaster_p-)eld_tast ~atcr = elsster_p-)last Batch;
if((ovsr_atatns = overlaTtscaa~t >Laea_string, cJaster_pil ==TRUE) C
/t _-string overlays correctly t/
/t ~if states » POfi9_QPEN change it to OPEN t/
it(r)uster_p->statas == P0S8_OPFN) clas~ter_p-)states r OPEN;

WO 92/05516 - B4 - PCTlUS9I/116876 is _vrruvt as nanr ~nar,r~ters as possraie si /3__-if good c~ ~ call :in__conpbuft/
It --if laet g. charactPt l last Batch hate lt__ last_natclr = last g~aod character I/
r,lu,ter_o->avr_tac_tine = tcluster_,~-)avr_tac tine t scan-p-)tac_tinel / 2;
oar Jinear(lPg, cln~ter_pr scan_pl;
if(overl~y_recover := TRUE1 r.
/T _ re overlar~.d last string, re do current string i/
tpnp_string = cluster_p-)stringsfcluster_p-)nun_strin9s~11;
sc~u_p = leg-stleglftenp_slriog.inrlexl;
el~nept_p = itr;an_p->elenentsltenp_,tring.startl;
overlay_recov~r = FALSE;
over ctatrts = OYFRLAY_OFF ;iTART_REC;
overiar_recurce_count = f;

else f clusier_p-)o1d_wort_sfrirg = teep ~ort._string;
cluster_p->nld rort_SC~rn.SCCn_are = tertp_rort scar.scan-nun;
clrster_p-)old_rort scaa.lea = teap_rork_scaa.lea;
forlx=6; x( teep_rort_scan.len; xw > , clearer_p->old_rort_scaa.elenentcLx:1 ~ tenp-rori_sc~a.rireentslx7;

else f iffover_ctetas == OVF.RLA1_RFI:OYfR1 t iflfaverlar_r~erover != TRUE) 1i (overlar_recover_connt (' MAX_RECOYER_COUIfT)) f omtl~r_recover = TRUE;
nverlar_recvver cnrat~~;
teep stri~~ i clutter_p-lstriw~sCctu~trr_p-lnae_sttiags-21;
crcn_p = Aleg_sfleg)fieap_siriag.iadr:7;
eleaeat_p = lsc~a_p-lelee~e~trltee~_.slriag.st~rt7;
rrver_stctus = OYF.RLAT_OFF START REC;

else f /t__ corld aol re_overl~ir I~st string, restore last striag gad srip_cnrrent string !/
ctrster_p~)rort_strin9 = tenp_rort_striag;
r)asier_p-)tort ~cae.sraa_ar~ = te~p_rort ccan.srae_nun;
clrster_p-)uort_su o.ler = teap_rart_scan.lea;
for(x=9; x( teep_rort_tc~e.len; xra) cluster_p-)rort_sc~a.ele~e~tstx7 = tenp_tort-sc~n.eleeentslxl;
over-~lrtus = OIIERI.AT_DAD;
lenp_striag = clu~ter_p-)striugslcluslter_p->nre-strings-17;
clastet_p~>st~trs = te~p_st~tus;
scae_p = ~teg sllellCteep_~triag.iadea7;
rleneni_p = hscau_p-)eleesitofteep_striog.itart7;
J
ifftover states == OItERLAT RECIIRCE1 ii coverlay_rerurce_roant t NAX_RFCQIRGF_f.0UNT1) ( /1_- rnulA not re_ovt..ar last String, restore last string and scip_current string l/
rlustpr_p->rort-ctring = tenp fort.-eiring;
cluaker_n->~nrk scan. scan-nue = tenp_rork scan.scm_nun;
ciuster_p->rort_sran.len = teap wont scan.len;
for(r=A; z( teep rnrt_SC~~a.len; rill- -cluster_p->~ort_sc~n.eleneatstr7 = tenp_aort_sc~n.eleeentslrl;
nver_StatuS = OYF.RLAT BA6;
te~p_striog = clnster_p->~~triagstclaster_p-)nae_strings-17;
~c~o_p = bleg-sfleg7lteep.,ctring.inde:7;
elenen(_p = bscan-p-)eleeentstteep-string.start7;

else f overlir_recurce_coun(~~;

/E__-over_~(atus=OVER(_AY,-OFF_StART--retry pith updated /t Tort st N og.end tl )ebile((nver_status == IIYERLAY OFF STAIR RF.C) ;!
(over_status == OVERLAY RECURCE));

else f /t _-if string .does not 1°dt info cluster, sboald it /t _ be tilled Its cluster old) t/
if(claster is_oldl till_claster(l~g, c)aster_~);

/t -try nert cllnster t/
1 bile (get_ne:t-cluster(leg) l;ctnster_iade:, iclu:ter_p));
sill this string open rer.nea cloisters t/
current-string = teep string;
do ( cbwt_rod~ = 1;
/t~-get free cluster I/
ehiie ((get fre~ rlaster(leg, J,claster-p, dstring_p)) i6 /t free cluster t/
(cbect_code < (2tli(AX CODEtrPES-1))) snitch (chect code) t _ rasp Ar t /t -1?5 FORfIARD t/
s check rndet~;
if(em bted_code typesl:1251 == fES1 c)aster_p-lopea_tr'e = 125;
is open_forltag, cta~.cter_p, sc~e_p, teep_string, eleeest_p, etring_Pfi hr~~t;

case Is It -(2S REYERCE t/
chect codet~E
if(~e~bled cade_trpesl12S7 == TIES1 f W uctPr_p-)open_trpe = )?s;
is_open_rev(leg, cl' ter_p, scan_p, tenp_striog, elenent_p) ,tring_) , carreint_string);
break;
case 2:
/I -f.39 FORilAIRO :/
- chect_code~i;
af(enahled enAe_typesCC391 == fES) ~ nreat;
Case ~:
caae 4:
case 5:
case b:
/i -C39 REYERt;E t/
rhPCt rnde~<;
if(enibled_code_trpesCC39) _= YES) ( treat;
/t -f.ODE A BAR FORiIARD 1./
thect todei~;
if(enabled_cndc_trpesICODF_A_6pR1 =~ YES) f rlacier_p-lnpen_typ~r = f.ODE_A BAR;
is_open_for(leg, c3uster_p, scan_p, tenp_strinB, eleeent_p, 5tftllg_J71;
Great;
) /i ~CODE_A_IAR RFYERCE tJ
check coded;
iflenahled code_trpe~,CCtIIE A_B11R) _= TES) t tlaster_p-)open_trp~ = CODF_A.,BAR;
is_open_revfl~g, c)~stlr_p, scan_p, te~p string, ele~ewt_p) stri4g_p, csrrent,.strieg);
brtat;
/t -UPCFAIt FORIIARD tl cwect codc~~;
if(enabled code_trpcs~tUPCEAItI == TES) rlastcr_p->np'n_type = UPCFAII;
is opew_for(leg, claster_p, sc~e_p, teep_stri~g) ele~ent_p, string_p.l;
breat;
. rese 7:
/t -UPCEAR REYERCE t/
check Cn~let~;
~ if(enabted cede_trp~etUPCEAiII =~= TES) t claster_p~)open_lrpe ~ UPCEAii;
is open_rev(1e9, cia~ter_p, su~n_p, teep_StrieB, eleeent_p) strta~_p, carrent_strtng);
hr~ak;
cmc 9r /t -C128 FORUARI !/
rh~ct_c~d~w ;

WO 92/05516 - 8~ - PCT/US91 /06876 ~rvenamea_rn~e_t~pesll:77.t1J == Tt5?
( breat;
race 9:
/I_ -C1?e REYERCE fi/
chest cndeii;
if(enabled-rode_typesCC12B7 == YE5) ( P
bffit;
) eAile(9et.nezt eleeeni(ielenent_p, ttenp_string));
/x _-npAate t~n nazt eleeent, see if this nee string /x__ opens a m clusters x/
/i done prat" ilI strings in this scan return to idles/
me scan_indeztlegiii;
f (prat scan indezCtegl )= I(AX..SCANS) ror-scin_indezfleg7 = p;
~P
/I _-if nn R!Y 5fin5 to process, should inr clusters /x be tilled lis cluster rald)x/
f(clust:!rq stcrtCiegl != clusters_endClegl) rlucier_iodez = r)usters stirtflegl;
:lustcr_p = (sicuct cluster strnct x)(xll.eg cLIeg7Iclnster indezll);
Strin'_p = i(clnster_p->itringsCt(cle~tter_p-)>tun_strings)-1)71;
iffis cluster roid(les, cinster_p, string_p)1 till_cl~cter(leq, rlnster_p);
. FUIiCTI0lt: prat ne:t scan _ RF,Tt)RRS: TRUE/FALSE
_ sets up STRIIfG P for nee stri>fg DfFCR1PT10R: -ire there scins to process for carrent leg -x/
a bnalean proc_nezi scm(leg, tenp_string_pl inter int le"
icier ciruci ctring_stract steep string,-p; , (prnc_~c~n_inAeztlegl != sc~n_in~AezClegl) /x is there scins to process t/
~np_~tring_p-)indez= Proc_scin_indezfleg3;;/x snit string for first string t/
eep_siring_P')eod= -l;
eep_strin9_p-)start= ST_SP UIlL80UN;
etarn lOYERLAT_GOOD); '' se pturn (OYERLAT_6AD);
FU8CTI0(t: get nezt string _ RETilRIiS: tRtlE/FALSE

WO 92/05516 _ eg _ PGT/US91/06876 .. teep_~tm no_.p->enA
_ start _ pleeent-n DESCRIP1IOH: -get nert string in current string t~
n boo)e~n get_t~ett_string(sc~n__p, elenenll_p, teap_string_p) art .,r.an_,tr~ICt Iscan_p;
act elenent :tract iteienent_p;
o t string_rtrurt tleap_string_p;
. y ,ter int W dR:;
gister :tract ele~ent_struct ipt;
i1e((ienp_siring_p->rnd 1 ?.) ( !:cen_p-»en) ode:steep string_p-)start= keno string_p-)end 1 2;
teleeent_p) = 6(sc~n_p-)e(eaent!cLinde:J);
i = tr)Pnrnt_r;
pile (p)->rel_pos !_' A) inde~m ;
1)IIT
'ep_string_p-)end : --inde:;
f((t~ap_string_p-)end - lenp_siring_p~)st,trt) )=
(tllli ~tIYERI.Ar ~ ttlNMATCH + 7) ;rtura (TRUf);
tare IFAISF);
fUIiCTIOM: striag_fits_i~n_cluster RET4RIiS: TRtIE/FALSE
_ striag_p _ DF8CR1PT10R: -dogs current string fit into cutreat clastet t/
~ 6nnle~a stttng_fits_in_cluster~llsg) elen~ent_p, clnster_p) te~p_sttiag_p, sttta~_p1 lei;
a t eleaent_strnct tele~eni_p;
art clust~r :tract lcluster_p;
rct string :tract itenp_striag.,p;
~r1 sttinq_clruri tisitia9_p;
a t el'nent_struct its, tie, =cs~, tce;
lt, ct;
a tiag_p) = tlcluater_p->striagsf((r)uster,-p-Inua_strings)-1)));
s (leg_SCI~gIC(tstring_p)-)inde:7.t~c_tine);
= (:tract r)enrnt :tract >i) (leg_sflegit(tlstriag_p)-)iadet;l.e)eaeats);
= AlsCltstring_p)~)eadl;
- ttsl(tstriag_p)-)st~rt7;
_ !s ~ ic)aster_'- hort_srea.e)enentsfcluster_p- » est y tci,7;
li = AlsClast_string_p.stsrt7;

_ 89 _ - (leg_cr)pqlrtPep_W ring_n-lip ~xJ:trc_cine);
= (;tract elenent Struct t) tleg_sClegICteep_strtng_p-)inde:I.eleeents);
= bccrie~p_~tring_p-IendJ;
- ~cs(tenp_siring_p-)st~rtJ;
((ce->tel_oos ( le->rel_po5 - ERROR REt._POS
ffllX CHARGE_REL_POS ) f f q (rs->rel_poc ) fe-IrPI_pos ~ f:RROR RFL_POS ~
flEi%_CNAfi~E_REL_P05) ((r,t - lf) ) 1) elurn (fAl.SE);
SP
ptera ITRI;F);
- FUI(CtlON: trio BETURliS:
tenp_striog-p~)start _ elenent_p - DESCR1PTIOli: -Erin cnrnrnt stringy according to wort_string i/
d trin(Ieg) sc~a_p, clnster_p, tenp_stricig_p, eIeetnt_p) leg;
nct scan siraci tscan_p;
nct rl~iter start tctustera;
act strieg_stract itenp_strieg_p;
uc1 tltt:tnt siroci Itlenent_p;
r p start, eai_t~l_pas_aver;
chaagt_rel_pos, fades;
uri sran_stroct fold scaa_p;
act elenent strnct (last tltetwt._p, tald_eleetnt_p;
ect striag_stract titring_p;
rins_p = L(claster_p-)Tort string);
d scaa_p = i(cltster_p-)tort scaal;
A rlenent n = n1A_sran_p-leitne~~ts;
tclasier-p-)stsixs == pECOIfEINf:1 h~~gt_rel_pos r (clnsttr_p-)clangt_rr1_pos + ERROR CNANCE REL_PDS1 t Ieran_p->stan_nue - olA,-scan_p-)scan_nnn);
se Aanne_re)_pos a I(AX CHAIiGF._Rfa._PDS t fscan_p-)sran_nne -01d_scaa_~~lscan_aa~l;
tcleiter o-)string dir == FORLIARD) _p_st~rt = old r)~eeat_pfstringyn-lendJ.rE!1_p~c - ' cltangt_rt1_pos - ERROIR REL_POSI;
f(trl~ster_p-)States == POSS_OPE:M) )t fclaster_p-Ic6aaqe_rel_pas =_ ~MA1(_CNANGf:_RE!_P051 1f (clucier_P->ctatKS == OPEII) nas_rel_pos_over = r_p_start + (~ItERROR_Rf:l._POS) + changt_rel_pos;
1st nrs_rel ~o5_nvrr = r_p_stmt E (~ttFRROR REa._POS);
se ns_rel_pos_over = old elt~eat_pCsariag_p-)start7.rel_pos +

WO 92/05516 _ gp _ PGT/US91/06876 rhange_ret !(us + ERROR-Rkl._YUS;
'itcluster_p-istatus -= POSS_OP~~~ .t ~r)u4tPr_pwrhaooP_rp)_poc -__ ,(_(:HAN6E_RFi.-P05) ~~
tcluster_pw status == OPEN) ~,_p_start = ~a:_rel_pos_over - c:hange_rel_pos - (ItERROR_REL-POS);
c: p _p_start = eail_rel-pos_over - t?tERROR_RI:L-,POS>;
iec = tenp_string_p->stirt;
i_P)PIIPnt_(~ = PIPnpnt_(~++;
ldl:1 r;
ci plenent_p = elenent_p~+;
~hiletleleeeni_p->rel_pos t r.,p_~aartl ii tele~~nt_o->r~l_ons != b) )i e)Pneni_p-)rP)_p~s == A) ~np_strmg_p-)stari = index + 1;
iP
anp_string_p-)start = finder;
Pe--;
eent_p--;
)P(telenPnt_~-)rel_pos (= ea= rel_pos-over) t6 telenent_p-)bar ) Mlli CIUIIT) AL
tlle~snt_p-)space > MIN COURT) ii teleeent_p-)rel_pos !~ 1) ~A~t+ r;
.eee~t_p+~;
(cleeest_p->rel_pos != 1) ~E
teleaeat_p-)bar ) NlR COUNt) li teleeent_p-)space ) Nlli_COUNT) ~de:~+;
.eeent_p++;
nent_p = last e)eeent_p;
~,n_String-p-)~ol = index;
FUIiCTl01(r is cluster oId RETURNS: TRtIE/FALSE
DESCRIPTION:-is tipster old based on proc_scan_inde:tilags) I/
boole~a is_claster_oId(leg, clas~~er_p) string-p) ieg;
Ict claster stract lclnster_p;
rt string_stract tstring_p;
(rt Stan strnrt ZSraa_p;
loa_till_lieit, higb_titt_li~it;
~n-p ~ lstracl scan_strurt t)tbtleg_sflegltpror_scan_inderL1eg11));
r_till_lieit ~ scan_p->scan_nue - 1~?;

h_till_linit = ;~an_p-)scan_nun r 62; - 9Z -( ( (rlaster_p')Y~rt crrn.sran_ ., ( llor-till lieit)1 I1 lcluster_p->rort_scin.scan-nun ) (hi~gh_till_linit)) 1 turn(TRUE1;
P
turntFAlSEI;
q FUNCTION; is_cluster_raJd RET11RNS: TR11E/FAISF
DESCRIPTION:-is cluster ohd based on scrn taunt (scans) i/ -boolem is..cluster..roldileg, cluster_p, string-pl l"9i ct cluster stract tclnster_p;
ri ctring_strurt tstring_p~
io~_till_linit, high_till_lieit;
-till-linit = scan coantf7egl - iiT.;
h_till_linit = Scan cnnntCl~gl + e2;
( ( tclaster_P-)Tort sran.sran_nae ( (Ion till linit)1 ii iclaster_p~)aort scan.scen_nun ) (higA_till 7init)1 ) 1 _ tarnITRUE);
a tara(fACSE);
FUNCT10N; till cluster RETIIRNSa QESCRIPTtONs-tilt clusters after tbe)~ are deterntned to ie old tI
t3I7_claster(Ieg, c7aster~l 1'9i ct clnster_stract fclaster_pi act c7aster_siruct tteep clasfer_p;
count;
p cinster_p =tstract claster_straca t)filleg_cCIeglCclasters st~rtCieg71))i ;lvsier_p-)statue != PtISS_OPF.N) /t -if still bad ciaster log KIIL_CL~1STER t/ ' g errortlll.l CLUSTERIp ster_p-)status = if of = dusters Starttiegll let itenp-cluster_p-)sterns == i) il (count != rlusiers_endflega) ) np claster_p~+;
ant ~ +;
(coast )= MAX CLUSTERS) WO 92/05516 Pt:,T/US91/06876 nant = A; - 92 -tenp_cluster_p =(siruct cluster tract Il~(6(leg_ctleglt9) » ;
:octerc ~tartf)e~) = count;
__ FilNCilOk: get npit clusvter _ kFTI(RkS: 1RUE/FA1 SE
cluster lode:
-_ cluster_p . DE9CRIPTtOk: -gets nest cluster that is used .n boole~n get_nect_clustertleg, c)rster_in~de:) cluater_p) Jester int leg;
;ester int Jcluster indec;
~ister stract clust~r_stmct !tc)uster_p;
tr,luster_inAec)rl;
tcluster_pif+;
ttc)ucter indec )= IIAX fl.U6TERF!
3cluater_inde:) = 1;
fcluster_p) = tstruct cluster_str~uct iltA(l.eg_ctleglt87)I;
ttclnster lade: != cltsters_eodlleg7) wtern tTRllEI;
.st eturn tEalsf);
__ IU8CT10k: lei free :)ester RETURkR: TRUE/FALSE
-_ c l~ster_p ._ tt ri n9_P
._ DESCR1PTIOkc -bet nect clutter thri is free i/
tn ~oole~n bet-free_ciasterlieg) ciuster_p, string_p) icier i M les;
ester siract cluster struct itcluater_p;
litter stract string struct ifstring_pt cla~ter end;
uster_end = clusiers_e~dllel7;
.u~t~lr eRdll;
't citster end >= MAX_CLUSTERS) iutaer end ~ i;
Icluster_end !: clusters_st~rtt)eg:l) ~ Icluster_p) = tstruct cluster strnc;t !f(>4lleg_rClegJCclaaters_endllegl7));
inlriag-P) = ltc)uster_p)-)striega;
tclester_pl->st~taa = STATUS UkIkOU~k;
tcluster_P)-lnp'n_trp~ = C01E_TrPF UBXkOflk;
=cluster_p)-)open st~rt_stap = ST 5P UkLkOilk;
tr)aster_p!-)citing dir ~ DIR Ilk(k0ilk;
trlvster-p)-)oae_strillgs ~ i;
'lrlaster n)-)rhange_ctl_nn~ ~ 1;
-etur~ (TRtlEI;
se og_error(FUt_C.CLUSiERS); .
acorn (FAISE);
FUIiCTI0lt: use_free_c)u!~ler RFTIJRIiS:
_ pFSCRiPTIOIf: -use free cluster gotten by get_free_cluster F/ -d use-free cluster(leg) i5ter~int leg;
aclerc Pndl)eg)rr;
(clusters endCleg7 T= MA%_CLUS1'ERS) lu5ter5_enACt~gl=1;
_ FUMCTI08r get nest e)errent _ RFTURf(S: TRtJE/FALSE
_ lteleeent_p _ xtenP-string-~p-)start _ DESCR1PT10R: -apd~tes pointer to inert elenent within current string tI
w boole~e get ~e:t_eleeent(elee~nt_p) teep_string_p) .!ci e)eeest strr!ct ti~lene~t_p;
rcl siriag_struct tte~p_striog,.p;
(fted_code at TRUE) 'oh_siribg_p-)siert~r;
lcleefet_p)if;
,e anp s mog-p-)st~rt~~;
:eleeest-p)ir;
rhile(teep string_p-!start < te~p_string_p-)end);
(( teep string_p-)start (= tenp_string_p-)end) J
etara (TRUE);
:e aiurn IFALSE);
_ FUNCTIONr dec_lieear _ RF.TIIR(tS:
pESCRIPTi08r -I!
1 dec_Iine~r(leg, clnsier~p, scea..p) leg;
aet cluster stract lclaster~;
~cl scm_sirart tscin_pi act ele~evt_stmct xtsep_eleeeni;-p;
hn, r, bor;
~ hoo)e~n gaod-liner;

WO 92/05516 Pt'T/US91/06876 r CO~o <HAX_~:HANS 1; -;rln~ter_p-)ctrinn dir == FtlRfi. ) enn_eleeent_p - 6lcluster_p~>rovrk_sc~n.ele~ents(1J>;
iP
Pnp_ele~ent_p = 6lctuster_p-)tro~rt_scan.elenentsIMAX_ELENEIiTB-211;
a = r)u~inr_p-)~ort_srm .len;
9tch (cluster_p->open,typel ase I25:
,ood_)inP~r = der_i7.5~linesr(cluster_p, len, t~teep_eleeent_p1i r~~t;
aye ~:.i9:
rest;
~sP CODE A kAR:
food linear = dec_cod_Iine~r(clnster-p, 1~!~, lteMp_eleeent_p1;
rn4t;
use IIfIa:Ati:
~ood_linecr = dec-epc.lieeerlcluster-p, len) Xteap eleeent_pI;
rat;
me C12A:
;eit;
;gend_lineerl ~aster_p->codefrluster_p-lcndefl:lill=1;
f Ictaster_p-)String ~lir == F0RY11R1I
.enp_eleaent_p = 6tcluster_p~lenrt ~cm.eleeentsf171;
.en ~ claster_p->aort_scia.le~;
:taster_r->avr rel_pos = f;
fort:=~; : ( len; ~~~1 clester_p->wr_rei_pos ~ claster_p-)wr rel_pos ~
t er!p_el.eseot_'-> rr l _pes;
te~p_elese~t_p~i;
I
:Issier_p-)mr rel_poc ~ claster_p-lwr_re:l_pos / s;
-tuster_n-)wr_tac_tiee ~ tctaster~-levr tac tree a sue_p->tac tieel I 2;
se vey_eIe!!ent_p = Ltcluster_p->~ort_sc~p.
eteeent!c(IIAX_E1.EMEiiTS-211;
ten = claster_p-l~art_scm.le~;
~lusi~r_p->avr rPl_pn~ = 1;
. ;orti=1; : ( leu; tfal ctuster_p~lwr_rel_pos = ctaster,~p-lwr_rel_pos r teep elaeeat_p-)re1_pos;
te~p_eleeeat_p--;
f.
:lester_p- hvr rei_~os = claster_p-levr_re1_pos / t;
~Irsier_~-livr tar tiee = tclaster_~-lwr ttt tiee ~
sca~_p~~>t~c_ti~e) / 2;

(ln~tano-for(r)ustnr-p)==TFUF;I _ g5 ((hox = get_box(Jeg, alusiPr_p~' !- 255) iin-coennuflbnx, r.luStpr_p, 3)~
FUtICTJUN: is opep_for -RFTpRNS:
DESCRIPTIDIi: -xi is_open_for(Ieg, cinster_p, sc~rn_p, te~p_string, eleeent_p) string_p) t°9i cct ciuster struct lctu~ter_p;
ri cran ct~a~t ts~an_p;
.ct string_struci teep_string;
pct ete~ent Struct Iplene~t_p;
ict string_struct Istring_p;
.ct string_siract ner_striog;
len, x; .
~ booiean is_open;
string = (enp_ciria9i ich (c)nster_p~)open_irpe) use I25:
Vireo ° is_325_oPea_forlclrster_p, inev 'string) eleeent_p);
eat;
as~ r,3p;
-eat;
s~ CttDF A BAR:
s opea = is cod open_for(clrstcr_p, l~eer_r;tring, eleeent_p);
'eat;
.c~ IIpGFAR:
s opea = is upc open_for(clnster,_p, Iper_e~tTing, elenent_p);
-ea fc;
~s~ C128r pat) (is_openJ
li _-yes, initialire iad nse clusters i/
;tring_p = ntr_strtng;
=uster_p->rork_scm.srm_nre = s«~n_p-)scan_nn~; , iuster_p-)rorE-srae.leo= te~p_5tri.~g.end - te~p_String.st~rt ~ 1;
.ust~r_p-)tort sirinq = ner_~triag;
~Irster_p-)nre_strivgs~~;
luster_p-)rnrt_Rraa,eieee>ttsCil.b~r t f;
luster_p->rort_sae.elenestsCl7.spice = f;
)asi~r_p-)tort cc~n.e)ee~ntstiJ.rei_pos = f;
~n =clnsler_p-)rort_su oleo f 1;
eecpY(aE~luiter_p-)rnrt_qcae.elteent5C17) ele~ent_p, len);

WO 92/05516 - 96 - PGT/US91/t168'76 nsrPr-~-)cork-cran.elenentslJJ,spen-type = r)uster_p-~open_trpe;
uster"p~)rork_string.end = her ~ring.end -her . ing.start il;
:uster_p-)rort-string.start =1;
u~ier_p-)la~t hatch = r)uster-p-)tort string. end;
~ustet_p-)old_l~st hatch ~ cluster_p-IJast hatch;
~ust!r-n-)change-rol-pns = NAX_CFIANGE_RFI__p05;
usier_p-)avr tar_tiep = sran_p->tac_tiee;
usier_p-)depth = scan_p-)depth;
ustlr-p-)nirl_rnrk_strtng = cluster_p-)rorlr_string;
osier-p-)n)d tort scan.sran_nr~ = cluster-,p-)tort scan.sran_nun;
uster_p-)old tort-scan.len = claster_p-)ra~tt_scan:len;
~rlr=A; st cluster_p-)rort_S~~n.len; rfr) :lust!r-p->old_rort_sc~n.eleeentsCsl = cluster_p-)tort-scan.eleeentsC:7;
a frPe_r)uster(leg>;
c_linear(leg, cluster_p, scan_p);;
uat!r_n-)coA!f.fl=6;
fUIICTIORs is_o~en_rev RETIlRIIS:
DESCRIPTtOilr -t/
is_open_rev(leg, claster_p, scan_p, teep_:tring, eleeeet_p, string_p) ~urrent_Stringl leg;
rt cluster siract trlaxter_p;
ct scan stract iscaa_p;
,ct ttring_strurt teep_string;
:ct ele~ent stract teleee~t_p=
rt string_cirurf tsttiag_p;
ct string_strrct carreat_striag;
:ct string_stract ~w string;
len, r;
Boolean is_open;
String = teen string;
tcb (clnster_p-)opetr_typel se 125r c_open : ic_i75_open_revlclusi~r_~y laer_striag, ele~ent_p!;
eat;
,s! f,39s ' ~e~tl se GODF A AAR:
s_open = is_cod open-rev(cluster_p, lrner_string, eleeent_p);
'eat;
se lif'CFAti:
s_ope~ _ is_upc_oprla_revlclrster_p, iner_stiring, ele~eat_pl;
'!at;
~s~ fl~R:

~Aaxq (ic oneni li --re<< rnilialire and use clusters t/
string_p = her-string;
taster-p->rork_,~an.sc~n_nun = e~ran_~-)sran-nun;
!osier-p-)cork-sran.len= tenp_ctring.start current string.start + f;
luster-n-)cork ,tying = her-string;
luster_p-)nu~_strings++;
en = rlostPr_p-)rork acan.len i f;
~ncpr(lcluster-p-)cork-scan.eleeentst!!AX-l:LEIlEIlTS -(len + t)1, lccan_p->eleeentstcurrent string. start-tl, len);
luster_p->rork_scan.eie~entsCBAX_ELEMEtiTS-i7.bar = 9;
lucier_p-)tort scan.eleeentsfllAX_FIFNENTS-lJ.space = A;
luster-p~)rort-scan.eleeentsClfAX ELEIfEIiTS~~lJ.rel_pos = A;
luster-p->rnrk_scan.eleeentsCMAX-ELEMENTS-1-tl.open-type =
clnster_p-)open-type;
a sipr_p-)tort strino.start = ne~r_string,s~tart +
(IfAX EIENEIiTS - heir string.end - 2);
taster n-)last Batch = cluster_p-)tort String.st~rt;
luster_p-)old last Batch = clast~er_p-)last hatch;
iust~r_p->rort_string.end = (I(AX FlEMEkTS - ?);
lusler_p-)change-rel_pos = RAX-CIIAIiGE REL_POS;
luster_n-)avr tar_tine = scan_p-;Itac-tiee;
lnster_p-)lepth = SCiR_p- »e~tb;
luster-p-)o1A_rort-caring = clast.er_p->roct-string;
tuster_p-)ntA tort Sran.SCan_nna = claster_p-)tort scan. scan-one;
laster_p-fold rort_su n.len = clusttr_p-)rotk_scan.len;
a (:=A; z( clusier_P-)tort scan.lee; c++) :)rster-p-)old_rort-scan.eleeestst:7 = claster_p-)rort_scan.eleeentsC:7;
ce_fres ~iustertleg);
!c lineartleg, cisster_p, scae_pl~;
Ircter_p-)codefp7=S;

i::7t.~I-*****~TTR'~.~hH.y.l(.lt.I;
x.7t.7!~17~()1C71Cx:JIIY(7f.Jh)j.p.l~cq,JpR.JpJ/tTT?.Ip.PTTT.HT.HTw~TT~nT.nn.."
.v..,..r~ ~~~v.. ... . ..... ... ... ...~.
1I<.:c-!r l~larner. ,-q:.F.F ,:'" ) Clueue: ::iE' 'EFF4/I~'f,.Tl,l'r'(::
.(?l.. - . r 7 ~_, ~.~.m~r..- t')VF'fil..r . C; ~erver : Ef-_.. JGR4 1)m;.c: r'n.c>1:'t.c~r~:: C)VEFcl..flY..C:
;;F:l''T'I=I~Slvl-h a;3.; .1~~~~'N J.1:1CG am 7S:~t:ri:ii:7l:%:7h:N:~i:>i:~k)>:~i:~l:~:N:~:~:~):~?:~:~:H:~:~:71:>>:~:~:*al:N' .>Y.*)!:*~Y.~1;*W~~fcx;******7t;***********~1;*************~
f':I=F:I-_'l= Fi=1=1=f=' f"F'FFF
,J C: F F
..) ~ F F
,.l E EEE != FFF FFFF
(I F F F
.J ,.I E F' F
). ).,) 1.'F.FFE I= F
ri:>t:>a:H:~:*~i:»:*74:71:*~1c**>Y~Y:*~:*7(t.~i:*****~k:d:~l:~:*x:********:1:**
******************************~I
000 y V EEEEEFifvfi'h AAA Y Y CCC
I_ C~ V V E f~ F~ I A A Y Y C C
f~

U V V F h Ft L A A Y Y C
C~

r) V v i'r~rnFi'I.fsr, AAAAA Y C
r) L.

U V V F: Fi Fs L A A Y ... C
f) i y V !: Fi Is L A A Y . . _ C
C

UUO V EI=EEEh h LLLI_l_A A Y .... CCC

:K:K:K*:K:K~K*:K!K:K:k*:Kac:K*!tc:K**;******~ic***:K***************************
***************~

_ - 99 -_ HAKE: uv~rlar.c _ DAiF; 89/l~/9A
_ PROGR9fIAER: Jeff Shiroe _ DfS(:filPflOH:
I/
DRX TECHHOIDf.Y H1TH DSp-THS 3?9C36 Copyright lcf 199A Acca-Sort Systens, inc.
All rights reserved.
Made 'cne~.lii' elude 'conn.ect' -_ FUNCIItIIi: overly _ RF.TURHS: clacter_p->aort string - rort_scan _ last_natch _ string_p-fend _ DESCRIPTION: -~/
ovpr)ry_responce nv~rlaytcc~n_p, String-,p, clnster_p) uct scan struct isc~n_p;
ur,t atring_strart tstring_p;
uct cluster_stract lclaster_p;
inter strnct ele~~at strrct tpl, tp2, t~3, ipl;
in~ie:, nac_re(_pos,i,j, chenge_vrel_pos, qQ_eatch, frvn start, Left iade:, t iwle:) t_fran start, jstap, tea, t len, scans_stipped, c, up fort;
:mt ~l~n~nt ctrart Ill, it2, It3" til;
let eleeeet_stract trort_elee~ot..p, iner_elenent_p, old_p3;
tclaster_P~>string_Air == FORUARItI
/x ~ovc~l~y in forrard d;ir t/
t=rort_elenent_p = tt(claster_p~)rort scao.
elenewtsfcinstet_p->rort_striog.enl7));
t~ner_elenent_p = titscae_p-)eleee~tststring_p-)start7));
~t_re1_pnc = scan_p-)elenrntsfstrieq_p->enel7.re1_pos;
~ Batch = 4;
rne_start = 6;
flstring_p-fenA != string_p-)start!
/t _-Ao~~ prior Iltlk pYFRI.AY pleeents of rort_string.end /t__ hatch rich her string t/
indec = A;
left indec = 9;
ift tia cin_ridihttpf-)har + pl-)!:p~ref,(p9-)her + p?.-fspacel)11 i left indec+E;
ift)nti_indec == N1R_OYf.RLAT) P; = pt;
PI z P29 pl__~

-_;

)rhilE( (is_sin ridth((p1-)bar ~ p1-)spacel,(p2-)bar s p2-)spacelll il cts Stn ridth((ptCtl.b ~ nl->space),(p2Cll.bar ~ p2-)Spacelll ii t pt->rel_pos != 61 ii ( p2->re)_po~ !- 8) );
~F(tafF._inAoi )= if (N-OYFR~-Alfl ( p) = brnrt eleneni_pfl7;
p? = iner_eleneni_p(13;
/f -dm s at least the nets tflH_MATCH elenents of /I tort string.end Batch rith the net string i/
rhile( ti,_Sin_ridth((pt-)bar ~~ pt->space),Ip2-)bar + p2~)spare))) ii (is sip ridth((pl-Ibar n ptL-l3.space),(p2-)bar + p2C-ll.space » 1 ii t pl-)rP1-poc !- 9? i(~
l p2-Yrel_pos != pi ii ( n2-)bar > MIN (aIUNT) ii ( p2-)space ) 111R_COUI11) r c indvr~~;
pl+t;
p2st;
) if( (( )efi ind~r + finder) ) tqq_natrh)) ii (index >_ !118 !LATCH) > _ t len = rlusi~r_p-)r~rt_ctring.end + index+i;
while( ( pt->rel_pns != i) ii I p2-)rel_p0i !s i? ii ( p2-)har > lflN CUItIIT) lti ( p2-)space ) NIN_COUNT) )s~«;
p1+~;
p7++~
qq_eitrh = left_i0de: + indec;
11 = p1;
t7. = p7.;
t3 = p3;
(~t = p4i t_inde: - finder;
t fron_start : froe_start;
t_len = leo;

/t__-update net tv nert elenent, search for best fit 1l fron start++;
net elenent_p+~;
at = tort ~le~ent_p;
,7. = net ele~ent_p;
rbile( (p2-)rel_pos (r wac_rel_posl ii (p2-)rel_p0s != if );
nd~t = t finder;
~n = t_len;
f(qq_0atch ( N1R_oo) /i---string dr.. not ovr~r)ay f/
~ftcluster_p-)status == POSS_OPI_ti) ctustpr_p-)change_ret_pos = H~41(-CHAH6E.REL POS;
cluster-P- » ast hatch = clacter_p->rort_string.end;
cluster_p-)~tatus = DECODElM6;~
returntOYFRI-A1f_OFF_START-REC);I
i f(r)usier-p-)status --= OPEH1 /I _-if statrs = OPf.B uivdate rork string.end, status =
II DECODEIIl6, return iOYERIAr OFF_START REC t!
cluster n-)tort string.end = clu5ter_p-)last-hatch - MTM_MATCH-1;
clrster_p-)status = DECODE186;
r~iurn(OYFRLAY_OFF-START-RFCI;
) '(Se t 1t -else tort-ctring.end it t/
ifttcluster_p-Irort_striog.eed - cluster_p-)tort-string.startl <
(rtuster_p->rort_scan.ien - 2 - Bt8 BATCH)) t ctacier_p-)tort ctriog.~ndsf;
reteraiOYERLAr RECORCE1;

else f clester_p-lold_rort striog.eel~~;
ctaster n-Irort_striog = cluste~r_p-Inld_rort_string;
rlusi'r_p-Irart xcan.scan_oue = claster_h-fold tort scaa.scao_one;
clnsier_p-Irort_scaa.lee = cluster_p-lold_rort scaa.lee;
forti~A; :l ctuster_p-)otd fort Scan.ten; z~i) clester_p-Irort_scae.eleeentstal = cluster_p-laid-rart_scw.eieeentsC:l;
r~taratOYFRIAr_RFf.QYFRI;

s se .t - tt;
~2 .= tz;
=ia;
,~ r t~;
ift I tclester_p-)tort string.end i iode:) < Iclnster_p-llast_a~tch-2l ) )I
4 len ( (cluster e-)rort_sc~n~,len-211 up-tort = 9;
) wise up_rort ~- f;
ft=p3i r2rP~f /t__-if stains = POSE OPEI! air OPEII set elleeeats reed /t__ io opee patters and Calculate chmge_rel,pos t/
tft ttclnster_p-Istatns == POSS OPEN) I1 tclasier_p-)stains == OPFlill ti f WO 92/05516 PGT/US91/0~6876 (un vnrr == t) - 102 -o) = Cpl(( H1H DVERLAY-))J;
n7. = ttn?.fl Hftl_fiVFRI_AY-t»;
j=b;
rhi)Plip1-)rel_pos != 9)144 /i set open_type in e)eeent t/
ip2->rel-.pos != B) ifl pl-)~pen_cype != p!
p2-)open_trpe = pl-)open_trpe;
nt--;
/t -aPdrte c)nster inforn~tion I/
clusler_p-)vort_siring.inde: = string_p~linde:;
if(un vork) cluster_p-)l~st_natch = clustpr_p-)vort_~string.end + index;
-hmgP_rr)_Pos = (p3->rel-pos ~ p~-)rel-pus>;
if(up_vnrt) f iflwt_vnrt> -~ -f o)d_p3 = tp3;
=P3 = tP~; /t set.-up nev vort t/
n3->4ar = lnld p3.har ~ pd-)barl/2;
p3-)space = latl_p3.space + p3°)spase)/1~;

else tp3 = tp~; /t set-up nev vt,rt t/
else f P1 = P3i p2 = '!;

jstop=inl~: E fl(tl_OYERLA1-i;
iede: = 1;
)r~;
do t indpW r;
p3i~;
p~ w;
iffp3->rel_pas == 1) jstnp = B;
if« ;stop != b> ~~ fp4-)rel_pos != 11) c jstop__~
jt+~
cYinge_rel_pos ~ ch~n9e_re)_pos + fp3->re1_pos - p4-)rel_posl;
iflup vnrk) iflwr vort) f old-p3 = lp3;
=P~ _ =pip li set-np nev vort t/
P3-)bar = lold_p3.b~r + ~3- »arl/2;
n3-)space = lolA_p~.tp~c~ ~ pii-~spi~e!/2;
else t13 ! tP! i ) - 103 -else if(uP_rort) rhilP(p4-,,>rel-nns != A1;
f((scans ctippPd = (scan_p-)scan nun - cluster,p-)rort_sc~n.~c~n-nue)) != A) if<cluster_p-)cha~ge_re)_pos ==~ NAX_CHAItGE_REL_P05) ~:lustPr_n-)change-rel_pns = (~;chmge-rPl_pnsl / (~)) / scans-slipped;
else r)uster_p-)change-re)_pas = ((cluster-p-)change-re)_pas t change_rel_pos) / (j tt); / scans_stipped;
f(uo r~rt == 8) P3 = Pf( p4 = ~?;
rhile(n3-)rol oos != f) L
p3->re)_pos = p3-)rel-poF - r)uster_p-)change_re1_pos;
p3ii;
plat;

uster_p-)rort_scan.srm_aue = scrn_p->scan_nne;
(ap_rort) luster_p-)r~rt_Rf~p.len = cluster_p-)rori: string.end ~ index - MIIi_OYERLAr;
f(clasier_p-)status == DFCODEIRI:) - /: _-if stator = I)ECODE~TIfG, uplate rrort strieg.evd t/
f(claster-p-)cart striag.ead ( claster-p-)last Batch - MIR IfAtCR - 1) closter_p-)tort-sirieg.end = r)uster_p~)lrst Batch - Mlll_NATCH - 1; .
etarp (TRUE);
a /t -overlay is reverce dir t/
=tort elenent-n = (ilrlaster_p~J~aort scan.
eleeeetsCclustcr_p-)tort-string.startlll;
=net e)eaeni-p = (t(scan_p-)elen~eatsfstriing,~-)start7));
:-rel_pos = scan_p-)eleeeatsLstriig_p-)en~d7.re1~pos;
_natch = f;
on start = ~;
(string-p~)end )= striRg_p-)start) /i --does Prior tflK OYERI.IIr eleasats of tort string.ead /!__ eaich vith r~ea string i/
ndR: = f;
eft lode: _ ~;
f((ic_sin_aidth(tp1-)bar v p1-)spacel,(p?~~)bar f p2-)space)lf) do t left inde:~~;
if()efi-rode: _= N1N OYERLAT) f p3 = pt;
PI = P21 WO 92/05516 Pt:.T/US91106876 nlt>;

pltt;.
~rhi)e( (m_m n-~idth((p1-)hat )-)space),(p?-)Dar i p2-)space))) 6b (is_sin ridth((p)-)bar ~ p)I-IJ.space),1p2-)bar t p2t-)J.spacel)) 66 ( nt->rel ans !_ 9) 66 ( p1-)ret_pas != 1>
!'r ' ~f(left_index )_ !!IR_OYFRLAT) p) = brnrt e)PnPnt_pr-)J;
p? = 6ner_elenent-pt-)J;
/t -do~c at )e~rsi the nert M1N_1(ATCN elenents of /t tort strim).end m tch rith the net string t/
rhite( (is~sin-ridthl(pl-)bar t pt-)space),(p2-)bar t p2-)space))) 66 (is sin ridth((plClJ.bar ~ pl-)space),(p2C17.bar i p2-)space))) A8 ( pl->r~l_p~c != P) 6i ( p2-)re1_pos != iw) li l n2-)bar ) Ntl( rOUIfT) Lh ( p2-)spice ) MIN_COUItT) f inApx~i;
pt--ft(I )efi index a finder) )= tqq-natchl) lip (index )= NIi! MATCH) ) _ )en = MAX_f'.IFNFIITS - ~)aster_p-;Fort strin9.st~rt 3 I f indlr.!
rhile( t pt-)rel_pos != if 11 p2->re)-Pos !_ ~) il ( p2-)bar ) MIR COUNTI 11 I p7.-)spice ) MIN CDUNT) len~~;
pl~-;
qq-hatch = lefi_inder ~ index;
tl = pl;
t2 ~ p2;
t3 = P3i t~ = P4i tinder = finder;
t froe_st~rt = fron_strrt;
( t-)en = len;
/t_~-apAite nee in nert e)enent, s~arcb far best fit t/
roe st~rt~~;
mr_~lenent_prf;
s tort elenent_p;
2~= nor elee~nt_pi ~6ile( (p?-)rel_po< <_ ~~r_rel_posl 11 Ip2-)rel-poi != 9) )i ~d~r = t finder;
~n ~ t_len;

WO 92/05516 PGTlUS91/06876 f(q9_~atch ( )itH.QO) /f-_-citing did not overlay f/
if(e3uster_p->status == POSS_OPEIt) r cluster..p-)change_rel_pos = MAX-CHANGE REL POS;
rlucier_p-))aFt hatch = cluster_p-)rork_string.st~rt;
clnstet_p-)sialus = DECODEING;
return(OYERLA1! OFF_START-REC);
J
if(c)usier_p-)status == OPEN!
li _-if ctatas = OPEN update tort string.end, status =
/T- DECDDE1NG,, retrrn OYERLAr OFF START REC i/
clu~ter_n-)tort ,tring.st~rt = cluster-p-)last-notch + MIN lLATCH + 1;
clrster_p-)status = DECODEING;
returni0YFRI.Af-OFF-START_REf.);
al5e I
/x -eIS~ tort-Str111g.Start -- t/
ifllclasier_p-)tort siring.erd - claster_p~-)rort_string.st~rtl f (cinstPr n-)tort-SCm .i~!n - 2 - MIN NA1'CH)) (:
r)usier-P-lrort cirirg.start--;
retnrn(OYERL1;1_RECURCE);
) else f claster-p-fold tort strirg.~t~ri:--;
clast'r-p-)tort-string = clnsteir_p-)old ~nrt_strtr9;
clrsier-p->rork_scan.sran_nre = clr~tsr_p->old_rnrt scar.fcin_Rne;
c)rsier_p-)tort scaa.Ier = cltsi.rr~-lold,rort scin.len;
f.nrlr=f; r( rluster_p->n1A-tort uer.ler; :++j clrster_p-)tort-scm.eleeeatsCr.l = clr~ter_p-)old-tort sc~r.eleeentsC:l;
r~i rrrtOYFRI AY_REf.(IYFR );

)F~
pi = il;
p2 = t2;
1~3 = 11;
P~ = tai if( ( (cluster-p-)tort string.st~rt - iede:) ) Iclrster_p~)l~st_e~tch+2> ) 11 ( lPn l (cluster-p-)cork-SC~n.le~+2)) -up, tort = i;
else t up_rort = i;

P1=P3i P ~-'P, i /t-_-if stilas = P05S_OPEN or OPEN set ellerents reed /t-_ it open p~tterr and c~tmci~te ch:rge_rtl-pos t/

rtt ttrlnster_pm:.mu~. _= ru,o urrrtt ~~ - 106 -fcluster_.p-)status == OPEH)t rS8 (un-rnrk == t1 'pl = 8p1(f -H1N OYERLATE1)l;
,n7 = b,n2Cf -HIN-OYER!.AY~i)1;
whiiP((P)-)rel-Poc != A)~8 /t set oppn_trpe in elenent t/
(p?->rel_pos != 8) if( pl-i0PP0-(rpe !: A) p2-)open.,type = pl-)open_type;
ot~r;
pz»~
-update cluster inf~re~tion i/
_luster_p-)rort..string.inde: = string_p-)index;
f(up_rnrt>
ciuster_p-)l~st_~~tch = c(uster_p->rort_string.start - irde:;
h~ogP_re>_po~ _ (p~->re)_pot: - P3-)rol_posi;
.f(up_rnrt) .if(avr rortl ( _ ~1d_pz : ip;i >lp3 = Ip~; /i set-up net tort :/
p3-)bm = (~ld_p3.bar t p;-)bar)~r2;
p3~)space = (ald_p3.spacr ~ p3-)!rpacr)/2;
else !p~ _ =p~; /: set-up net r~rt !/
..
.Pl = P;i P2 s Phi stop=trade: i Htil_OYERLAy-l;
111!PI s !i;

A
IndPl~f;
p p1_-;
if(p3-)rel_pos == A!
jstnp = B;
_ if((jstop != A) 63 lp~l-)rel_pos != ~)) ( jstop--;
jlli chaage_re1-pos = change-rel_pos ~ (p4-)rel:pos - p3-)rel_pasl;
iflrp ~nrt) tf(avr tort) ( _ old_p3 = Ip3;
ip3 = tp~; /t set-rap nee tort t/
p3->bar = (old-p3. bar a p3-)6ar)/2;

OJ-lS~.l~n = W uyYa.ye~e r Ya-yveneui.~ _ P)~e ip3 = Ep~;
1 _ else iflnp_wnrt) Ip3 = tp~;
)~hilelP~->tPl_poc != g);
if((scins__stippc6 = (scin_p-)scan gun - claster_p-)rort-scin.scrn_nun)) != 6) iftriu,ter p->chinge_rei_pos t- JfAX CHAIi!GE RE(._pa5) ciuster_p->chinge-rel_pos = t(chinge_rel_pos) / (j)) / scins_stipped;
P)cP
clustpr_p-)chipge-rel_.pos = Il:cluster_p-)chinge_rel_pos ~ chinge_rel_pos>
/ ij fll) / SrinS-Si<lppel;
if(un_rnrt == 4) f P3 _- PI i P~ L PCi ~hilet~3-)rel_co5 != A) ( p3-)rP)-poi = p3-)rPl-pos t cluster-p->chaage-rel-pos;
_;
-;
) r)uster_p-)rort s~an.s~an_nae = span-p-)scan nae;
if(rp-tort) cta5ter_p-)~nrt scin.ten = NAIf ELEIfENTS - cluster_p-)tort striag.stirt ~
i~de: - i - IJIK OYERLAy;
if(~lasi~r_p-)sfiias =_ ~FCOpF.llil:l t II ~if states = ~OECOOEOTiti~~ apdite tort string.e~d t/
if(cluster_p-)cart etring.stirt ) cluster_p-)list etch t BIR HATCH f 11 rlrstsr-p-)tort string.start = clasier-p-)list-etch t i(I!t-IfATCN ~ 1;
J
r~tarn (TRUE);

Claims (60)

Claims:

1. A scanner for reading machine-readable code on an object, comprising:
scanning means for repetitively scanning said code and for providing a scan signal repetitively corresponding to at least fragments of said code;
data means coupled to said scanning means and responsive to its scan signal for repetitively storing said scan signal;
and registration means coupled to said data means for reconstructing at least a portion of said code from at least two of said fragments of said code including means for identifying matching portions of said two fragments, and means for shifting said two fragments relative to one another until said matching portions are identified in registration.

2. A scanner according to claim 1 wherein said code comprises a plurality of data bits and wherein said data means is operable to store one of said fragments of said code, provided its length exceeds a predetermined number of data bits.

3. A scanner according to claim 2 wherein said scanning means comprises:
a source for producing a beam of light; and deflecting means for tracing said beam across said object in an "X" shaped pattern.

4. A scanner according to claim 3 wherein said "X" shaped pattern is traced at staggered repetitive positions.

5. A scanner according to claim 4 wherein the staggered repetitive positions of said "X" pattern are centered on the vertices of a triangle.

6. A scanner according to claim 2 wherein said data means includes:
common memory means having dual independent ports for transferring data, one of said ports being coupled to said scanning means for receiving and storing data bits in response to said scan signal, the other one of said ports being coupled to said registration means, said registration means being freed from the task of repetitively storing said scan signal in said common memory means.

7. A scanner according to claim 6 wherein said code comprises a plurality of intervals including bars and spaces each having either a narrow or wide interval width, and wherein said data means comprises:
narrow means coupled to said scanning means for measuring said narrow interval width and storing it as a narrow width value, said registration means being operable to shift and compare said fragments of said code, provided each has about the same narrow width value.

8. A scanner according to claim 7 wherein said data means comprises:
position means coupled to said scanning means for measuring within a scan of said code the position of the last valid one of said intervals and storing that position as a scan position value, said registration means being operable to shift and compare said fragments of said code, provided each has about the same scan position value.

9. A scanner according to claim 6 wherein said data means comprises:
register means coupled to said scanning means for sequentially storing said data bits in response to said scan signal;
address means coupled to said common memory means for pointing to a location in said common memory means for storing said data bits; and state means coupled to said address means for indexing it and changing the location to which it points, said state means being operable after a predetermined number of said data bits are validly stored in said register means to transfer said data bits in said register means to said common memory means at the location to which the address means points.

10. A scanner according to claim 9 wherein said code comprises a plurality of intervals including bars and spaces each having either a narrow or wide interval width, and wherein said data means comprises:

narrow means coupled to said scanning means for measuring said narrow interval width and storing it as a narrow width value; and position means coupled to said scanning means for measuring within a scan of said code the position of the last valid one of said intervals and storing that position as a scan position value, said state means being coupled to said narrow means and said position means for transferring said scan position value and said narrow width value to said common memory means at the location to which the address means points in response to the ending of a succession of valid data bits arriving at said register means, said registration means being operable to shift and compare said fragments of said code, provided each has about the same scan position value and about the same narrow width value.

11. A scanner according to claim 1 wherein said code comprises a plurality of intervals including bars and spaces of either narrow or wide interval widths, and wherein said data means comprises:
quantizing means for measuring the interval widths of said intervals and providing a discrete ratio signal signifying whether the ratio of the last measured one of said interval widths to a prior one of said interval widths is about one, one-half or two.

12. A scanner according to claim 11 wherein said quantizing means comprises:
look-up means for providing three pairs of limit values corresponding to predetermined tolerances on said last measured one of said interval widths with respect to three nominal values centered around one (unity), one-half and two times said prior one of said interval widths; and comparison means coupled to said look-up means for providing said discrete ratio signal at a discrete value corresponding to one of said three nominal values in response to the last measured one of said interval widths being within one of the three predetermined tolerances signified by said three pairs of limit values.

13. A scanner according to claim 12 wherein said data means comprises:
pattern means coupled to said comparison means and responsive to its discrete ratio signal, said pattern means having two pluralities of states, each of said two pluralities corresponding to a bit pattern starting with a different binary value, said pattern means being operable to select one of said two pluralities in response to said discrete ratio signal providing a non-unity value; and register means for storing said bit pattern with an initial binary value determined by which one of said two pluralities of states is selected.

14. A scanner according to claim 13 wherein said pattern means is operable to end said bit pattern in response to the last non-unity value of said discrete ratio signal being the same as the immediately preceding non-unity value.

15. A scanner according to claim 14 wherein said data means comprises:
scan means for counting the number of scans of said scanning means and storing that number as a scan number, said registration means being coupled to said scan means and operable to read said scan number.

16. A scanner according to claim 15 wherein said data means comprises:
empty means for counting the number of scans of said scanning means that fail to produce a valid code fragment and storing that number as a bad scan number, said registration means being coupled to said empty means and operable to read said bad scan number.

17. A scanner according to claim 16 wherein said data means comprises:
a first, second and third register coupled together to shift data from said first and second register to said second and third register, respectively, the first register being coupled to said scanning means for storing in response to said scan signal a value corresponding to the interval width of the last one of said intervals, said quantizing means being coupled to at least said first and third register to provide said discrete ratio signal by comparing the states of said first and third register.

18. A scanner according to claim 17 wherein said quantizing means is initially operable for each scan of the scanning means to compare the states of said first and second register before said discrete ratio signal is first validly provided by the quantizing means.

19. A scanner according to claim 1 wherein said scanning means comprises:
a source for producing a beam of light; and deflecting means for tracing said beam across said object in an "X" shaped pattern.

20. A scanner according to claim 19 wherein said scanning means comprises:
a rotating mirror; and a primary pair of non-coplanar mirrors, said non-coplanar mirrors being angularly adjacent from the optical perspective of said rotating mirror:

21. A scanner according to claim 20 wherein said scanning means comprises:
a secondary and tertiary pair of non-coplanar mirrors angularly spaced from said primary pair, said non-coplanar mirrors of each pair of mirrors being angularly adjacent from the optical perspective of said rotating mirror.

22. A scanner according to claim 20 wherein said primary pair of non-coplanar mirrors comprises:
first and second contiguous mirrors positioned to form an obtuse angle as measured on the side facing said rotating mirror.

23. A scanner according to claim 19 comprising:
zone means for measuring the distance between an object and said source and for providing a zone signal signifying said distance; and focusing means optically coupled to said source for focussing it in response to said zone signal.

24. A scanner according to claim 1 wherein said data means comprises:
counting means coupled to said scanning means for developing pluralities of counts responsive to transitions of said scan signal; and means coupled to said counting means for compressing each of said pluralities of counts to defined states for storing and for reconstructing by said registration means.

25. A scanner according to claim 24 wherein said registration means comprises:

means for digitally processing said stored scan signal so that one of said fragments provides a first portion of a digital code and another of said fragments provides a second portion of said digital code, both portions providing a registered middle portion of said digital code.

26. A scanner according to claim 25 which further comprises:
means coupled to said registration means for decoding a reconstructed digital code.

27. A scanner according to claim 1 wherein said data means comprises:
counting means coupled to said scanning means for developing pluralities of counts responsive to transitions of said scan signal for storing and for reconstructing by said registration means.

28. A scanner according to claim 27 wherein said registration means comprises:
means for numerically processing said stored scan signal so that one of said fragments provides a first portion of said code and another of said fragments provides a second portion of said code, both portions providing a registered middle portion of said code.

29. A scanner according to claim 28 which further comprises:
means coupled to said registration means for compressing said registered pluralities of counts to defined states, providing a reconstructed digital code; and means coupled to said compressing means for decoding said reconstructed digital code.

30. A scanner according to claim 1 wherein said code includes start portions at a beginning of said code, stop portions at an end of said code, and data-containing portions between said start portions and said stop portions, and wherein at least one of said fragments of said code is comprised of said data-containing portions.

31. A method according to claim 30 wherein said scan signal includes additional fragments of said code which are comprised of said data-containing portions.

32. A scanner according to claim 30 wherein both of said at least two fragments are comprised of said data-containing portions.

33. A scanner according to claim 32 wherein both of said at least two fragments are comprised only of said data-containing portions.

34. A scanner according to claim 1 wherein said registration means further includes means for combining registered code fragments.

35. A scanner according to claim 34 which further includes means for reconstructing additional portions of said code from at least two fragments, wherein one of said fragments corresponds to said combined registered code fragments.

36. A method for reading machine-readable code on an object, comprising the steps of:
repetitively scanning said code and obtaining at least fragments of said code;
repetitively recording said fragments of said code; and reconstructing said code from at least two of said fragments of said code by identifying matching portions of said two fragments, and shifting said two fragments relative to one another until said matching portions are identified in registration.

37. A method according to claim 36 wherein said scanning of said code is performed by:
repetitively tracing across said object in an "X" shaped pattern at staggered repetitive positions.

38. A method according to claim 37 wherein said code comprises a plurality of intervals including bars and spaces each having either a narrow or wide interval width, said method comprising the step of:
measuring said narrow interval width and recording it as a narrow width value, the step of restoring said code being performed among fragments of said code having about the same narrow width value.

39. A method according to claim 38 comprising the step of:
measuring within a scan of said code the position of the last valid one of said intervals and recording that position as a scan position value, the step of reconstructing said code being performed among fragments of said code having about the same scan position value.

40. A method according to claim 36 wherein said code comprises a plurality of intervals including bars and spaces of either narrow or wide interval widths, said method comprising the step of:
quantizing the interval widths of said intervals when they are within predetermined ranges such that the ratio of the last measured one of said interval widths to a prior one of said interval widths is about one (unity), one-half or two.

41. A scanner according to claim 40 wherein the step of quantizing comprises:
correlating three pairs of limit values corresponding to predetermined tolerances on said last measured one of said interval widths with respect to three nominal values centered around one (unity), one-half and two times said prior one of said interval widths; and declaring a discrete value corresponding to one of said three nominal values in response to the last measured one of said interval widths being within one of the three predetermined tolerances signified by said three pairs of limit values.

42. A method according to claim 41 comprising the steps of:
selecting one of two binary values in response to said discrete value providing either non-unity value; and recording a bit pattern with its initial binary value determined by the first non-unity value occurring in a valid succession of discrete values.

43. A method according to claim 42 wherein said recording of said bit pattern ends in response to the last non-unity value occurring in a valid succession of discrete values being the same as the immediately preceding non-unity value.

44. A method according to claim 40 wherein said method comprises the step of:
recording values corresponding to the interval width of the last three valid ones of said intervals, the step of quantizing being performed by comparing the last and third to last one of said intervals.

45. A method according to claim 44 wherein the step of quantizing is initially performed for each scan by comparing the last and next to last one of said intervals before a third valid one of said intervals is recorded in the step of recording values.

46. A method according to claim 36 wherein the step of repetitively recording the fragments of said code comprises the steps of:
sequentially recording data bits corresponding to the sequence of said code;
indexing and pointing to an address for recording said data bits; and rerecording said data bits at the address after a predetermined number of said data bits are validly recorded.

47. A method according to claim 36 wherein said repetitive recording of said fragments of said code comprises:
developing pluralities of counts responsive to transitions of said repetitive scans of said code; and compressing each of said pluralities of counts to defined states for storing and reconstructing.

48. A method according to claim 47 wherein said reconstructing is performed by:
digitally processing said compressed pluralities of counts so that one of said fragments provides a first portion of digital code and another of said fragments provides a second portion of said digital code, both portions providing a registered middle portion of said digital code.

49. A method according to claim 48 comprising the step of:
decoding a reconstructed digital code.

50. A method according to claim 36 wherein said repetitive recording of said fragments of said code comprises:
developing pluralities of counts responsive to said repetitive scans of said code for storing and transitions of reconstructing.

51. A method according to claim 50 wherein said reconstructing is performed by:
numerically processing said pluralities of counts so that one of said fragments provides a first portion of said code and another of said fragments provides a second portion of said code, both portions providing a registered middle portion of said code.

52. A method according to claim 51 which comprises the step of repetitively processing said pluralities of counts so that additional fragments are combined with said first and second portions of said code.

53. A method according to claim 52 wherein said repetitive processing comprises the step of:
adding fragments to said first and second portions of said code until said code includes a beginning and an ending portion, providing a reconstructed code.

54. A method according to claim 51 which comprises the steps of:
compressing a reconstructed code to defined states, providing a reconstructed digital code; and decoding said reconstructed digital code.

55. A method according to claim 36 wherein said code includes start portions at a beginning of said code, stop portions at an end of said code, and data-containing portions between said start portions and said stop portions, and wherein at least one of said fragments of said code is comprised of said data-containing portions.

56. A method according to claim 55 wherein said scan signal includes additional fragments of said code which are comprised of said data-containing portions.

57. A method according to claim 55 wherein both of said at least two fragments are comprised of said data-containing portions.

58. A method according to claim 57 wherein both of said at least two fragments are comprised only of said data-containing portions.

59. A method according to claim 36 wherein said reconstructing further includes the step of combining registered code fragments.

60. A method according to claim 59 wherein said reconstructing further includes the step of reconstructing additional portions of said code from at least two fragments, wherein one of said fragments corresponds to said combined registered code fragments.