Initial scrape from http://www.phatcode.net/res/224/files/html/

about.html

@@ -0,0 +1,83 @@
+<HTML>
+<HEAD>
+<META name=vsisbn content="1576101746">
+<META name=vstitle content="Michael Abrash's Graphics Programming Black Book, Special Edition">
+<META name=vsauthor content="Michael Abrash">
+<META name=vspublisher content="The Coriolis Group">
+<META name=vspubdate content="07/01/97">
+<META name=vscategory content="Web and Software Development: Game Development,Web and Software Development: Graphics and Multimedia Development">
+
+
+
+
+
+
+<TITLE>Michael Abrash's Graphics Programming Black Book Special Edition: Foreword</TITLE>
+
+<!-- HEADER -->
+<!-- Empty Reference Subhead -->
+
+<!--ISBN=1576101746//-->
+<!--TITLE=Michael Abrash's Graphics Programming Black Book Special Edition//-->
+<!--AUTHOR=Michael Abrash//-->
+<!--PUBLISHER=The Coriolis Group, Inc.//-->
+<!--CHAPTER=Foreword//-->
+<!--PAGES=xxxi-xxxii//-->
+<!--UNASSIGNED1//-->
+<!--UNASSIGNED2//--></HEAD><BODY LINK=#0000FF ALINK=#000099 VLINK=#0000FF BGCOLOR=#FFFFFF>
+
+<CENTER>
+<TABLE BORDER>
+<TR>
+<TD><A HREF="intro.html">Previous</A></TD>
+<TD><A HREF="index.html">Table of Contents</A></TD>
+<TD><A HREF="about_author.html">Next</A></TD>
+</TR>
+</TABLE>
+</CENTER>
+<P><BR></P>
+<H2><A NAME="Heading1"></A><FONT COLOR="#000077">Foreword</FONT></H2>
+<P>I got my start programming on Apple II computers at school, and almost all of my early work was on the Apple platform. After graduating, it quickly became obvious that I was going to have trouble paying my rent working in the Apple II market in the late eighties, so I was forced to make a very rapid move into the Intel PC environment.
+</P>
+<P>What I was able to pick up over several years on the Apple, I needed to learn in the space of a few months on the PC.</P>
+<P>The biggest benefit to me of actually making money as a programmer was the ability to buy all the books and magazines I wanted. I bought a lot. I was in territory that I new almost nothing about, so I read <I>everything</I> that I could get my hands on. Feature articles, editorials, even advertisements held information for me to assimilate.</P>
+<P>John Romero clued me in early to the articles by Michael Abrash. The good stuff. Graphics hardware. Code optimization. Knowledge and wisdom for the aspiring developer. They were even fun to read. For a long time, my personal quest was to find a copy of Michael&#146;s first book, <I>Zen of Assembly Language.</I> I looked in every bookstore I visited, but I never did find it. I made do with the articles I could dig up.</P>
+<P>I learned the dark secrets of the EGA video controller there, and developed a few neat tricks of my own. Some of those tricks became the basis for the Commander Keen series of games, which launched id Software.</P>
+<P>A year or two later, after Wolfenstein-3D, I bumped into Michael (in a virtual sense) for the first time. I was looking around on M&T Online, a BBS run by the Dr. Dobb&#146;s publishers before the Internet explosion, when I saw some posts from the man himself. We traded email, and for a couple months we played tag-team gurus on the graphics forum before Doom&#146;s development took over my life.</P>
+<P>A friend of Michael&#146;s at his new job put us back in touch with each other after Doom began to make its impact, and I finally got a chance to meet up with him in person.</P>
+<P>I talked myself hoarse that day, explaining all the ins and outs of Doom to Michael and an interested group of his coworkers. Every few days afterwards, I would get an email from Michael asking for an elaboration on one of my points, or discussing an aspect of the future of graphics.</P>
+<P>Eventually, I popped the question&#151;I offered him a job at id. &#147;Just think: no reporting to anyone, an opportunity to code all day, starting with a clean sheet of paper. A chance to do <I>the right thing</I> as a programmer.&#148; It didn&#146;t work. I kept at it though, and about a year later I finally convinced him to come down and take a look at id. I was working on Quake.</P>
+<P>Going from Doom to Quake was a tremendous step. I knew where I wanted to end up, but I wasn&#146;t at all clear what the steps were to get there. I was trying a huge number of approaches, and even the failures were teaching me a lot. My enthusiasm must have been contagious, because he took the job.</P>
+<P>Much heroic programming ensued. Several hundred thousand lines of code were written. And rewritten. And rewritten. And rewritten.</P>
+<P>In hindsight, I have plenty of regrets about various aspects of Quake, but it is a rare person that doesn&#146;t freely acknowledge the technical triumph of it. We nailed it. Sure, a year from now I will have probably found a new perspective that will make me cringe at the clunkiness of some part of Quake, but at the moment it still looks pretty damn good to me.</P>
+<P>I was very happy to have Michael describe much of the Quake technology in his ongoing magazine articles. We learned a lot, and I hope we managed to teach a bit.</P>
+<P>When a non-programmer hears about Michael&#146;s articles or the source code I have released, I usually get a stunned &#147;WTF would you do that for???&#148; look.</P>
+<P>They don&#146;t get it.</P>
+<P>Programming is not a zero-sum game. Teaching something to a fellow programmer doesn&#146;t take it away from you. I&#146;m happy to share what I can, because I&#146;m in it for the love of programming. The Ferraris are just gravy, honest!</P>
+<P>This book contains many of the original articles that helped launch my programming career. I hope my contribution to the contents of the later articles can provide similar stepping stones for others.</P>
+<P>&#151;<I>John Carmack</I><BR>id Software</P><P><BR></P>
+<CENTER>
+<TABLE BORDER>
+<TR>
+<TD><A HREF="intro.html">Previous</A></TD>
+<TD><A HREF="index.html">Table of Contents</A></TD>
+<TD><A HREF="about_author.html">Next</A></TD>
+</TR>
+</TABLE>
+</CENTER>
+
+<hr width="90%" size="1" noshade>
+<div align="center">
+<font face="Verdana,sans-serif" size="1">Graphics Programming Black Book &copy; 2001 Michael Abrash</font>
+</div>
+<!-- all of the reference materials (books) have the footer and subfoot reveresed -->
+<!-- reference_subfoot = footer -->
+<!-- reference_footer = subfoot -->
+
+<!-- BEGIN SUB FOOTER -->
+</BODY>
+</HTML>
+
+<!-- END FOOTER -->
+
+

ch03/03-02.html

@@ -0,0 +1,508 @@
+<HTML>
+<HEAD>
+<META name=vsisbn content="1576101746">
+<META name=vstitle content="Michael Abrash's Graphics Programming Black Book, Special Edition">
+<META name=vsauthor content="Michael Abrash">
+<META name=vspublisher content="The Coriolis Group">
+<META name=vspubdate content="07/01/97">
+<META name=vscategory content="Web and Software Development: Game Development,Web and Software Development: Graphics and Multimedia Development">
+
+
+
+
+
+
+<TITLE>Michael Abrash's Graphics Programming Black Book Special Edition: Assume Nothing</TITLE>
+
+<!-- HEADER -->
+<!-- Empty Reference Subhead -->
+
+<!--ISBN=1576101746//-->
+<!--TITLE=Michael Abrash's Graphics Programming Black Book Special Edition//-->
+<!--AUTHOR=Michael Abrash//-->
+<!--PUBLISHER=The Coriolis Group, Inc.//-->
+<!--CHAPTER=03//-->
+<!--PAGES=035-042//-->
+<!--UNASSIGNED1//-->
+<!--UNASSIGNED2//--></HEAD><BODY LINK=#0000FF ALINK=#000099 VLINK=#0000FF BGCOLOR=#FFFFFF>
+
+<CENTER>
+<TABLE BORDER>
+<TR>
+<TD><A HREF="03-01.html">Previous</A></TD>
+<TD><A HREF="../index.html">Table of Contents</A></TD>
+<TD><A HREF="03-03.html">Next</A></TD>
+</TR>
+</TABLE>
+</CENTER>
+<P><BR></P>
+<P><B>LISTING 3.1 PZTIMER.ASM</B></P>
+<!-- CODE //-->
+<PRE>
+; The precision Zen timer (PZTIMER.ASM)
+;
+; Uses the 8253 timer to time the performance of code that takes
+; less than about 54 milliseconds to execute, with a resolution
+; of better than 10 microseconds.
+;
+; By Michael Abrash
+;
+; Externally callable routines:
+;
+;  ZTimerOn: Starts the Zen timer, with interrupts disabled.
+;
+;  ZTimerOff: Stops the Zen timer, saves the timer count,
+;    times the overhead code, and restores interrupts to the
+;    state they were in when ZTimerOn was called.
+;
+;  ZTimerReport: Prints the net time that passed between starting
+;    and stopping the timer.
+;
+; Note: If longer than about 54 ms passes between ZTimerOn and
+;    ZTimerOff calls, the timer turns over and the count is
+;    inaccurate. When this happens, an error message is displayed
+;    instead of a count. The long-period Zen timer should be used
+;    in such cases.
+;
+; Note: Interrupts *MUST* be left off between calls to ZTimerOn
+;    and ZTimerOff for accurate timing and for detection of
+;    timer overflow.
+;
+; Note: These routines can introduce slight inaccuracies into the
+;    system clock count for each code section timed even if
+;    timer 0 doesn&#146;t overflow. If timer 0 does overflow, the
+;    system clock can become slow by virtually any amount of
+;    time, since the system clock can&#146;t advance while the
+;    precison timer is timing. Consequently, it&#146;s a good idea
+;    to reboot at the end of each timing session. (The
+;    battery-backed clock, if any, is not affected by the Zen
+;    timer.)
+;
+; All registers, and all flags except the interrupt flag, are
+; preserved by all routines. Interrupts are enabled and then disabled
+; by ZTimerOn, and are restored by ZTimerOff to the state they were
+; in when ZTimerOn was called.
+;
+
+Code segment word public &#145;CODE&#146;
+     assumecs:    Code, ds:nothing
+     public       ZTimerOn, ZTimerOff, ZTimerReport
+
+;
+; Base address of the 8253 timer chip.
+;
+BASE_8253equ40h
+;
+; The address of the timer 0 count registers in the 8253.
+;
+TIMER_0_8253     equBASE_8253 &#43; 0
+;
+; The address of the mode register in the 8253.
+;
+MODE_8253        equBASE_8253 &#43; 3
+;
+; The address of Operation Command Word 3 in the 8259 Programmable
+; Interrupt Controller (PIC) (write only, and writable only when
+; bit 4 of the byte written to this address is 0 and bit 3 is 1).
+;
+OCW3              equ20h
+;
+; The address of the Interrupt Request register in the 8259 PIC
+; (read only, and readable only when bit 1 of OCW3 = 1 and bit 0
+; of OCW3 = 0).
+;
+IRR               equ20h
+;
+; Macro to emulate a POPF instruction in order to fix the bug in some
+; 80286 chips which allows interrupts to occur during a POPF even when
+; interrupts remain disabled.
+;
+MPOPF macro
+      local p1, p2
+      jmp short p2
+p1:   iret             ; jump to pushed address &amp pop flags
+p2:   push cs          ; construct far return address to
+      call p1          ; the next instruction
+      endm
+
+;
+; Macro to delay briefly to ensure that enough time has elapsed
+; between successive I/O accesses so that the device being accessed
+; can respond to both accesses even on a very fast PC.
+;
+DELAY macro
+      jmp     $&#43;2
+      jmp     $&#43;2
+      jmp     $&#43;2
+      endm
+
+OriginalFlags   db    ?    ; storage for upper byte of
+                           ; FLAGS register when
+                           ; ZTimerOn called
+TimedCount      dw    ?    ; timer 0 count when the timer
+                           ; is stopped
+ReferenceCount  dw         ; number of counts required to
+                           ; execute timer overhead code
+OverflowFlag    db    ?    ; used to indicate whether the
+                           ; timer overflowed during the
+                           ; timing interval
+;
+; String printed to report results.
+;
+OutputStr  label byte
+           db    0dh, 0ah, &#145;Timed count: &#145;, 5 dup (?)
+ASCIICountEnd    labelbyte
+           db    &#145; microseconds&#146;, 0dh, 0ah
+           db    &#145;$&#146;
+;
+; String printed to report timer overflow.
+;
+OverflowStr label byte
+      db    0dh, 0ah
+      db    &#145;****************************************************&#146;
+      db    0dh, 0ah
+      db    &#145;* The timer overflowed, so the interval timed was  *&#146;
+      db    0dh, 0ah
+      db    &#145;* too long for the precision timer to measure.     *&#146;
+      db    0dh, 0ah
+      db    &#145;* Please perform the timing test again with the    *&#146;
+db0dh, 0ah
+      db    &#145;* long-period timer.                               *&#146;    
+      db    0dh, 0ah
+      db    &#145;****************************************************&#146;
+      db    0dh, 0ah
+      db    &#145;$&#146;
+
+; ********************************************************************
+; * Routine called to start timing.                                  *
+; ********************************************************************
+
+ZTimerOn    proc   near
+
+;
+; Save the context of the program being timed.
+;
+   push   ax
+   pushf
+   pop    ax                       ; get flags so we can keep
+                                   ; interrupts off when leaving
+                                   ; this routine
+   mov    cs:[OriginalFlags],ah    ; remember the state of the
+                                   ; Interrupt flag
+   and    ah,0fdh                  ; set pushed interrupt flag
+                                   ; to 0
+   push   ax
+;
+; Turn on interrupts, so the timer interrupt can occur if it&#146;s
+; pending.
+;
+     sti
+;
+; Set timer 0 of the 8253 to mode 2 (divide-by-N), to cause
+; linear counting rather than count-by-two counting. Also
+; leaves the 8253 waiting for the initial timer 0 count to
+; be loaded.
+;
+     mov  al,00110100b               ;mode 2
+     out  MODE_8253,al
+;
+; Set the timer count to 0, so we know we won&#146;t get another
+; timer interrupt right away.
+; Note: this introduces an inaccuracy of up to 54 ms in the system
+; clock count each time it is executed.
+;
+     DELAY
+     sub     al,al
+     out     TIMER_0_8253,al     ;lsb
+     DELAY
+     out     TIMER_0_8253,al     ;msb
+;
+; Wait before clearing interrupts to allow the interrupt generated
+; when switching from mode 3 to mode 2 to be recognized. The delay
+; must be at least 210 ns long to allow time for that interrupt to
+; occur. Here, 10 jumps are used for the delay to ensure that the
+; delay time will be more than long enough even on a very fast PC.
+;
+    rept 10
+    jmp   $&#43;2
+    endm
+;
+; Disable interrupts to get an accurate count.
+;
+     cli
+;
+; Set the timer count to 0 again to start the timing interval.
+;
+      mov  al,00110100b        ; set up to load initial
+      out  MODE_8253,al        ; timer count
+      DELAY
+      sub  al,al
+      out  TIMER_0_8253,al     ; load count lsb
+      DELAY
+      out  TIMER_0_8253,al; load count msb
+;
+; Restore the context and return.
+;
+     MPOPF                   ; keeps interrupts off
+     pop   ax
+     ret
+
+ZTimerOn     endp
+
+;********************************************************************
+;* Routine called to stop timing and get count.                     *
+;********************************************************************
+
+ZTimerOff proc     near
+
+;
+; Save the context of the program being timed.
+;
+     push    ax
+     push    cx
+     pushf
+;
+; Latch the count.
+;
+     mov  al,00000000b     ; latch timer 0
+     out  MODE_8253,al
+;
+; See if the timer has overflowed by checking the 8259 for a pending
+; timer interrupt.
+;
+     mov   al,00001010b        ; OCW3, set up to read
+     out   OCW3,al; Int        errupt Request register
+     DELAY
+     ina   l,IRR; read         Interrupt Request
+                               ; register
+     and   al,1                ; set AL to 1 if IRQ0 (the
+                               ; timer interrupt) is pending
+     mov   cs:[OverflowFlag],al; store the timer overflow
+                               ; status
+;
+; Allow interrupts to happen again.
+;
+      sti
+;
+; Read out the count we latched earlier.
+;
+     in     al,TIMER_0_8253   ; least significant byte
+     DELAY
+     mov    ah,al
+     in     al,TIMER_0_8253   ; most significant byte
+     xchg   ah,al
+     neg    ax                ; convert from countdown
+                              ; remaining to elapsed
+                              ; count
+     mov    cs:[TimedCount],ax
+; Time a zero-length code fragment, to get a reference for how
+; much overhead this routine has. Time it 16 times and average it,
+; for accuracy, rounding the result.
+;
+     mov   cs:[ReferenceCount],0
+     mov   cx,16
+     cli                ; interrupts off to allow a
+                        ; precise reference count
+ RefLoop:
+     call   ReferenceZTimerOn
+     call   ReferenceZTimerOff
+     loop   RefLoop
+     sti
+     add    cs:[ReferenceCount],8; total &#43; (0.5 * 16)
+     mov    cl,4
+     shr    cs:[ReferenceCount],cl; (total) / 16 &#43; 0.5
+;
+; Restore original interrupt state.
+;
+     pop    ax                    ; retrieve flags when called
+     mov    ch,cs:[OriginalFlags] ; get back the original upper
+                                  ; byte of the FLAGS register
+     and    ch,not 0fdh           ; only care about original
+                                  ; interrupt flag...
+     and    ah,0fdh               ; ...keep all other flags in
+                                  ; their current condition
+     or     ah,ch                 ; make flags word with original
+                                  ; interrupt flag
+     push   ax                    ; prepare flags to be popped
+;
+; Restore the context of the program being timed and return to it.
+;
+    MPOPF                      ; restore the flags with the
+                               ; original interrupt state
+    pop    cx
+    pop    ax
+    ret
+
+ZTimerOff  endp
+
+;
+; Called by ZTimerOff to start timer for overhead measurements.
+;
+
+ReferenceZTimerOnproc   near
+;
+; Save the context of the program being timed.
+;
+      push  ax
+      pushf     ; interrupts are already off
+;
+; Set timer 0 of the 8253 to mode 2 (divide-by-N), to cause
+; linear counting rather than count-by-two counting.
+;
+   mov    al,00110100b    ; set up to load
+   out    MODE_8253,al    ; initial timer count
+   DELAY
+;
+; Set the timer count to 0.
+;
+     sub    al,al
+     out    TIMER_0_8253,al; load count lsb
+     DELAY
+     out    TIMER_0_8253,al; load count msb
+;
+; Restore the context of the program being timed and return to it.
+;
+     MPOPF
+     pop    ax
+     ret
+
+ReferenceZTimerOnendp
+
+;
+; Called by ZTimerOff to stop timer and add result to ReferenceCount
+; for overhead measurements.
+;
+
+ReferenceZTimerOff proc     near
+;
+; Save the context of the program being timed.
+;
+      push   ax
+      push   cx
+      pushf
+;
+; Latch the count and read it.
+;
+     mov   al,00000000b        ; latch timer 0
+     out   MODE_8253,al
+     DELAY
+     in    al,TIMER_0_8253     ; lsb
+     DELAY
+     mov   ah,al
+     in    al,TIMER_0_8253     ; msb
+     xchg  ah,al
+     neg   ax                  ; convert from countdown
+                               ; remaining to amount
+                               ; counted down
+     add   cs:[ReferenceCount],ax
+;
+; Restore the context of the program being timed and return to it.
+;
+    MPOPF
+    pop    cx
+    pop    ax
+    ret
+
+ReferenceZTimerOff endp
+
+; ********************************************************************
+; * Routine called to report timing results.                         *
+; ********************************************************************
+
+ZTimerReport procnear
+
+       pushf
+       push  ax
+       push  bx
+       push  cx
+       push  dx
+       push  si
+       push  ds
+;
+       push       cs     ; DOS functions require that DS point
+       pop        ds     ; to text to be displayed on the screen
+       assume     ds     :Code
+;
+; Check for timer 0 overflow.
+;
+     cmp  [OverflowFlag],0
+     jz   PrintGoodCount
+     mov  dx,offset OverflowStr
+     mov  ah,9
+     int  21h
+     jmp  short EndZTimerReport
+;
+; Convert net count to decimal ASCII in microseconds.
+;
+PrintGoodCount:
+     mov   ax,[TimedCount]
+     sub   ax,[ReferenceCount]
+     mov   si,offset ASCIICountEnd - 1
+;
+; Convert count to microseconds by multiplying by .8381.
+;
+     mov   dx, 8381
+     mul   dx
+     mov   bx, 10000
+     div   bx                ;* .8381 = * 8381 / 10000
+;
+; Convert time in microseconds to 5 decimal ASCII digits.
+;
+     mov   bx, 10
+     mov   cx, 5
+CTSLoop:
+     sub   dx, dx
+     div   bx
+      add  dl,&#146;0&#146;
+     mov   [si],dl
+     dec   si
+     loop  CTSLoop
+;
+; Print the results.
+;
+     mov   ah, 9
+     mov   dx, offset OutputStr
+     int   21h 
+;
+EndZTimerReport:
+     pop   ds
+     pop   si
+     pop   dx
+     pop   cx
+     pop   bx
+     pop   ax
+     MPOPF
+     ret
+
+ZTimerReport  endp
+
+Code   ends
+       end
+</PRE>
+<!-- END CODE //-->
+<P><BR></P>
+<CENTER>
+<TABLE BORDER>
+<TR>
+<TD><A HREF="03-01.html">Previous</A></TD>
+<TD><A HREF="../index.html">Table of Contents</A></TD>
+<TD><A HREF="03-03.html">Next</A></TD>
+</TR>
+</TABLE>
+</CENTER>
+
+<hr width="90%" size="1" noshade>
+<div align="center">
+<font face="Verdana,sans-serif" size="1">Graphics Programming Black Book &copy; 2001 Michael Abrash</font>
+</div>
+<!-- all of the reference materials (books) have the footer and subfoot reveresed -->
+<!-- reference_subfoot = footer -->
+<!-- reference_footer = subfoot -->
+
+<!-- BEGIN SUB FOOTER -->
+</BODY>
+</HTML>
+
+<!-- END FOOTER -->
+
+

ch05/05-03.html

@@ -0,0 +1,234 @@
+<HTML>
+<HEAD>
+<META name=vsisbn content="1576101746">
+<META name=vstitle content="Michael Abrash's Graphics Programming Black Book, Special Edition">
+<META name=vsauthor content="Michael Abrash">
+<META name=vspublisher content="The Coriolis Group">
+<META name=vspubdate content="07/01/97">
+<META name=vscategory content="Web and Software Development: Game Development,Web and Software Development: Graphics and Multimedia Development">
+
+
+
+
+
+
+<TITLE>Michael Abrash's Graphics Programming Black Book Special Edition: Crossing the Border</TITLE>
+
+<!-- HEADER -->
+<!-- Empty Reference Subhead -->
+
+<!--ISBN=1576101746//-->
+<!--TITLE=Michael Abrash's Graphics Programming Black Book Special Edition//-->
+<!--AUTHOR=Michael Abrash//-->
+<!--PUBLISHER=The Coriolis Group, Inc.//-->
+<!--CHAPTER=05//-->
+<!--PAGES=118-121//-->
+<!--UNASSIGNED1//-->
+<!--UNASSIGNED2//--></HEAD><BODY LINK=#0000FF ALINK=#000099 VLINK=#0000FF BGCOLOR=#FFFFFF>
+
+<CENTER>
+<TABLE BORDER>
+<TR>
+<TD><A HREF="05-02.html">Previous</A></TD>
+<TD><A HREF="../index.html">Table of Contents</A></TD>
+<TD><A HREF="05-04.html">Next</A></TD>
+</TR>
+</TABLE>
+</CENTER>
+<P><BR></P>
+<P><B>LISTING 5.1 SEARCH.C</B></P>
+<!-- CODE //-->
+<PRE>
+/* Program to search the file specified by the first command-line
+ * argument for the string specified by the second command-line
+ * argument. Performs the search by reading and searching blocks
+ * of size BLOCK_SIZE. */
+
+#include &ltstdio.h&gt
+#include &ltfcntl.h&gt
+#include &ltstring.h&gt
+#include &ltalloc.h&gt   /* alloc.h for Borland compilers,
+                        malloc.h for Microsoft compilers */
+
+#define BLOCK_SIZE  0x4000   /* we&#146;ll process the file in 16K blocks */
+
+/* Searches the specified number of sequences in the specified
+   buffer for matches to SearchString of SearchStringLength. Note
+   that the calling code should already have shortened SearchLength
+   if necessary to compensate for the distance from the end of the
+   buffer to the last possible start of a matching sequence in the
+   buffer.
+*/
+
+int SearchForString(unsigned char *Buffer, int SearchLength,
+   unsigned char *SearchString, int SearchStringLength)
+{
+   unsigned char *PotentialMatch;
+
+   /* Search so long as there are potential-match locations
+      remaining */
+   while ( SearchLength ) {
+     /* See if the first character of SearchString can be found */
+     if ( (PotentialMatch =
+           memchr(Buffer, *SearchString, SearchLength)) == NULL ) {
+        break;   /* No matches in this buffer */
+     }
+      /* The first character matches; see if the rest of the string
+         also matches */
+      if ( SearchStringLength == 1 ) {
+         return(1);  /* That one matching character was the whole
+                        search string, so we&#146;ve got a match */
+      }
+      else {
+         /* Check whether the remaining characters match */
+         if ( !memcmp(PotentialMatch &#43; 1, SearchString &#43; 1,
+               SearchStringLength - 1) ) {
+            return(1);  /* We&#146;ve got a match */
+         }
+      }
+      /* The string doesn&#146;t match; keep going by pointing past the
+         potential match location we just rejected */
+      SearchLength -= PotentialMatch - Buffer &#43; 1;
+      Buffer = PotentialMatch &#43; 1;
+   }
+
+   return(0);  /* No match found */
+}
+
+main(int argc, char *argv[]) {
+   int Done;               /* Indicates whether search is done */
+   int Handle;             /* Handle of file being searched */
+   int WorkingLength;      /* Length of current block */
+   int SearchStringLength; /* Length of string to search for */
+   int BlockSearchLength;  /* Length to search in current block */
+   int Found;              /* Indicates final search completion
+                              status */
+   int NextLoadCount;      /* # of bytes to read into next block,
+                              accounting for bytes copied from the
+                              last block */
+   unsigned char *WorkingBlock; /* Block storage buffer */
+   unsigned char *SearchString; /* Pointer to the string to search for */
+   unsigned char *NextLoadPtr;  /* Offset at which to start loading
+                                   the next block, accounting for
+                                   bytes copied from the last block */
+
+   /* Check for the proper number of arguments */
+   if ( argc != 3 ) {
+      printf(&#147;usage: search filename search-string\n&#148;);
+      exit(1);
+   }
+
+   /* Try to open the file to be searched */
+   if ( (Handle = open(argv[1], O_RDONLY | O_BINARY)) == -1 ) {
+      printf(&#147;Can&#146;t open file: %s\n&#148;, argv[1]);
+      exit(1);
+   }
+   /* Calculate the length of text to search for */
+   SearchString = argv[2];
+   SearchStringLength = strlen(SearchString);
+   /* Try to get memory in which to buffer the data */
+   if ( (WorkingBlock = malloc(BLOCK_SIZE)) == NULL ) {
+      printf(&#147;Can&#146;t get enough memory\n&#148;);
+      exit(1);
+   }
+
+   /* Load the first block at the start of the buffer, and try to
+      fill the entire buffer */
+   NextLoadPtr = WorkingBlock;
+   NextLoadCount = BLOCK_SIZE;
+   Done = 0;      /* Not done with search yet */
+   Found = 0;     /* Assume we won&#146;t find a match */
+   /* Search the file in BLOCK_SIZE chunks */
+   do {
+      /* Read in however many bytes are needed to fill out the block
+         (accounting for bytes copied over from the last block), or
+         the rest of the bytes in the file, whichever is less */
+      if ( (WorkingLength = read(Handle, NextLoadPtr,
+            NextLoadCount)) == -1 ) {
+         printf(&#147;Error reading file %s\n&#148;, argv[1]);
+         exit(1);
+      }
+      /* If we didn&#146;t read all the bytes we requested, we&#146;re done
+         after this block, whether we find a match or not */
+      if ( WorkingLength != NextLoadCount ) {
+         Done = 1;
+      }
+
+      /* Account for any bytes we copied from the end of the last
+         block in the total length of this block */
+      WorkingLength &#43;= NextLoadPtr - WorkingBlock;
+      /* Calculate the number of bytes in this block that could
+         possibly be the start of a matching sequence that lies
+         entirely in this block (sequences that run off the end of
+         the block will be transferred to the next block and found
+         when that block is searched)
+      */
+      if ( (BlockSearchLength =
+               WorkingLength - SearchStringLength &#43; 1) &lt= 0 ) {
+            Done = 1;  /* Too few characters in this block for
+                          there to be any possible matches, so this
+                          is the final block and we&#146;re done without
+                          finding a match
+                       */
+      }
+      else {
+         /* Search this block */
+         if ( SearchForString(WorkingBlock, BlockSearchLength,
+               SearchString, SearchStringLength) ) {
+            Found = 1;     /* We&#146;ve found a match */
+            Done = 1;
+         }
+         else {
+            /* Copy any bytes from the end of the block that start
+               potentially-matching sequences that would run off
+               the end of the block over to the next block */
+            if ( SearchStringLength &gt 1 ) {
+               memcpy(WorkingBlock,
+                  WorkingBlock&#43;BLOCK_SIZE - SearchStringLength &#43; 1,
+                  SearchStringLength - 1);
+            }
+            /* Set up to load the next bytes from the file after the
+               bytes copied from the end of the current block */
+            NextLoadPtr = WorkingBlock &#43; SearchStringLength - 1;
+            NextLoadCount = BLOCK_SIZE - SearchStringLength &#43; 1;
+         }
+      }
+   } while ( !Done );
+
+   /* Report the results */
+   if ( Found ) {
+      printf(&#147;String found\n&#148;);
+   } else {
+      printf(&#147;String not found\n&#148;);
+   }
+   exit(Found);   /* Return the found/not found status as the
+                     DOS errorlevel */
+}
+</PRE>
+<!-- END CODE //-->
+<P><BR></P>
+<CENTER>
+<TABLE BORDER>
+<TR>
+<TD><A HREF="05-02.html">Previous</A></TD>
+<TD><A HREF="../index.html">Table of Contents</A></TD>
+<TD><A HREF="05-04.html">Next</A></TD>
+</TR>
+</TABLE>
+</CENTER>
+
+<hr width="90%" size="1" noshade>
+<div align="center">
+<font face="Verdana,sans-serif" size="1">Graphics Programming Black Book &copy; 2001 Michael Abrash</font>
+</div>
+<!-- all of the reference materials (books) have the footer and subfoot reveresed -->
+<!-- reference_subfoot = footer -->
+<!-- reference_footer = subfoot -->
+
+<!-- BEGIN SUB FOOTER -->
+</BODY>
+</HTML>
+
+<!-- END FOOTER -->
+
+