[Back to FAQ SWAG index]  [Back to Main SWAG index]  [Original]


  Q. How do I pass an error level code when my program finishes?              
  A. The halt procedure takes an optional parameter of type word. Thus -      
     terminates the program with an errorlevel of 1.  If halt is used without 
     a parameter it is the same as -                                          
     Note:  When a program is terminated using the halt procedure any exit    
            procedure that has previously been set up is executed.            

  Q. How do I empty the keyboard buffer?                                      
  A. There are several ways that this can be achieved.  However the safest    
     is -                                                                     
        while Keypressed do ch := ReadKey;                                    
     This requires that a variable ch of type char is declared and the crt    
     unit be used.  To do it without using a variable -                       
       while Keypressed do while ReadKey = #0 do;                             
     or if using TP6 with extended syntax enabled -                           
        while KeyPressed do ReadKey;                                          
     If you do not wish to incur the substantial overhead involved with the   
     use of the CRT unit and there is no requirement for the program to run   
     under a multi-tasker -                                                   
          head : byte absolute $40:$1c;                                       
          tail : byte absolute $40:$1e;                                       
        tail := head;                                                         


  Q. When I redirect the screen output of my programs to a file the file is   
     empty and the output still appears on the screen. What am I doing        
  A. You are probably using the CRT unit and its default method of writing    
     to stdout is by direct screen writes.  In order to enable output to be   
     redirected all writes must be done by DOS.  Setting the variable         
     DirectVideo to false has no effect on redirection as all it does is use  
     the BIOS for screen writes - not DOS.                                    
     To enable redirection you must not use the CRT unit                      
     This will make all output go through DOS and thus can be redirected if   
     desired.  To restore the default situation -                             
     AssignCRT(output); rewrite(output);                                      


   Q. How do I make a string that is lower or mixed case all uppercase?
   A. There are several ways to convert lower case characters to upper case.  
      Here are some of them.                                                  
      As a procedure (excluding asm code this is the fastest way)             
        procedure StrUpper(var st: string);                                   
          var x : byte;                                                       
            for x := 1 to length(st) do                                       
              st[x] := UpCase(st[x]);                                         
      As a function (slower but sometimes more convenient) -                  
        function StrUpper(st: string): string;                                
          var x : byte;                                                       
            StrUpper[0] := st[0];                                             
            for x := 1 to length(st) do                                       
              StrUpper[x] := UpCase(st[x]);                                   
      Both the above are suitable for the English language .  However from    
      version 4.0 onwards, DOS has had the facility to do this in a way that  
      is country (language) specific.  I am indebted to Norbert Igl for the   
      basic routine.  I have modified his code slightly.  For the anti-goto   
      purists this is a good example of a goto that is convenient, efficient, 
      self-documenting and structured.  The dos calls would make this method  
      the slowest of all.                                                     
     function StrUpper(s: string): string;                                    
       { Country specific string-to-uppercase conversion. Requires DOS unit } 
         regs : registers;                                                    
         x    : byte;                                                         
         if lo(DosVersion) >= 4 then begin                                    
           with regs do begin                                                 
             ax := $6521;                                                     
             ds := seg(s);                                                    
             dx := ofs(s[1]);                                                 
             cx := length(s);                                                 
             if odd(flags) then { the attempted conversion failed so }        
               goto fail;                                                     
           end; { with }                                                      
         end { if DOS >= 4.0 } else                                           
           for x := 1 to length(s) do                                         
             s[x] := UpCase(s[x]);                                            
         StrUpper := s;                                                       
       end; { StrUpper }                                                      

   Q. When I include ANSI codes in a string and write that string to the      
      screen the actual codes appear on the screen, rather than the results   
      they are supposed to achieve.                                           
   A. In order for ANSI codes to be interpreted, screen writes must be        
      directed through DOS and there must have been a suitable driver loaded  
      via the config.sys file at boot time.  All output can be directed       
      through DOS and the driver by -                                         
      Not using the crt unit                                                  
      OR -                                                                    
      in which case ALL screen writes are "ANSI code sensitive"               
      OR -                                                                    
      You can set up write procedures that will be "ANSI code sensitive".     
      (You will need an initialisation procedure to set this up.)             
        ansi : text;                                                          
      procedure AssignANSI(var ansifile : text);                              
        end; { AssignANSI }                                                   
      procedure WriteANSI(var st: string);                                    
        end; { WriteANSI }                                                    
      procedure WriteLnANSI(var st: string);                                  
        end; { WriteANSI }                                                    
      ObviousLy, if the ANSI.SYS driver (or an equivalent) is not installed   
      none of the above can work.                                             
      Setting the variable DirectVideo in the CRT unit to false will not      
      achieve the desired result as this merely turns off direct screen       
      writes and uses the BIOS for all screen output.                         

   Q. When I try to shell to DOS nothing happens. What am I doing wrong?      
   A. In order to be able to execute any child process there must be          
      sufficient memory available for it to load and execute.  Unless you     
      advise differently at compile time, a Turbo Pascal program grabs all    
      available memory for itself when it is loaded.  To reserve memory for a 
      child process use the compiler memory directive -                       
        {$M 16384,0,0)                                                        
      the default is -                                                        
        {$M 16384,0,655360}                                                   
      The first figure - StackMin - is the amount of memory to be allocated   
      for the stack:                                                          
      Minimum is:    1024                                                     
      Default is:   16384                                                     
      Maximum is:   65520                                                     
      The next figure - HeapMin -is the minumum amount of memory to be        
      allocated for the heap. If there is less memory available than this     
      figure the program will not load.                                       
      Minimum is:          0                                                  
      Default is:          0                                                  
      Maximum is:     655360  In practice it will be the amount of free       
                              memory less the space required for the stack,   
                              less the code space of the program.  You should 
                              set this to 0 unless your program uses the      
                              heap.  In that case, set it to the lowest       
                              possible figure to prevent heap allocation      
                              errors.  In most cases it is best to leave it   
                              at zero and do error checking within the        
                              program for sufficient memory at allocation     
      The last figure is the crucial on as regards child processes.  It       
      should always be low enough to leave memory left over for a child       
      process and high enough not to cause problems for the program when      
      allocating heap memory.                                                 
      Minimum is:  HeapMin                                                    
      Default is:  655360                                                     
      Maximum is:  655360     If less than the requested amount is available  
                              no error is reorted.  Instead all available     
                              memory is allocated for heap use.               

   Q. How do I shell to DOS?                                                  
   A. SwapVectors;                                                            
      Read previous section on memory allocation.                             
      I find that it is a good idea to write my own Exec function which will  
      do everything that is needed for me.  I have it return an integer value 
      that is the DosError code.                                              
      function Exec(p1,p2: string);                                           
          Exec := DosError;                                                   
      This enables me to have a statement such as -                           
      Now you can have an empty ReportError procedure or you can make it      
      report the error - whatever is suitable for you application.            

   Q. When I execute a child process redirection does not work. Why?          
   A. Redirection of a child process's output only works if it is run under   
      another copy of the command processor.  So -                            
      exec('YourProg.exe',' > nul');    will not work but                     
      exec(GetEnv('COMSPEC'),'/c YourProg > nul'); will work.                 


   Q. How do I read an errorlevel from a child process?

   A. After executing a child process the errorlevel returned can be read
      by calling the DosExitCode function which returns a word.  The low
      byte is the errorlevel.  A full description is in the manual.

      If the command interpreter is the child process and it in turn
      executes a child process then the errorlevel of the second child
      process cannot be read without resorting to some trickery.


   Q. When I read a text file that has lines exceeding 255 characters I
      lose all those characters from the 256th one on each time there is a
      line that exceeds that length.  How can I prevent this?

   A. Turbo Pascal's readln procedure reads a line up to the 255th
      character then skips to the next line.  To get around this you
      should declare a buffer at least as large as the longest possible
      line and then use the read procedure.  The best size for the buffer
      is a multiple of 2048 bytes.

        BufferSize = 2048;
        LineLength = 78;
        textbuffer = array[1..BufferSize] of char;
        st          : string;
        f           : text;
        buffer      : textbuffer;

      function ReadTxtLn(var tf: text; var s: string; max: byte): integer;
        { Reads a string of a maximum length from a text file }
          len         : byte absolute s;
          len := 0;
          while (len < max) and not eoln(tf) do begin
          if eoln(tf) then
          ReadTxtLn := IOResult;
        end; { ReadTxtLn }

        while not eof(f) and (ReadTxtLn(f,st,LineLength) = 0) do


   Q. How do I convert nul terminated asciiz strings to Turbo Pascal

   A. Here is a function that will do that -

      function Asc2Str(var s; max: byte): string;
        { Converts an ASCIIZ string to a Turbo Pascal string }
        { with a maximum length of max.                      }
        var starray  : array[1..255] of char absolute s;
            len      : integer;
          len        := pos(#0,starray)-1;              { Get the length }
          if (len > max) or (len < 0) then      { length exceeds maximum }
            len      := max;                         { so set to maximum }
          Asc2Str    := starray;
          Asc2Str[0] := chr(len);                           { Set length }
        end;  { Asc2Str }


   Q. How can I tell if a particular bit of a variable is set or not? How can
      I set it?  How can I turn it off? How can I make a large bit map and
      then determine if a particular bit - say bit 10000 is on/of?

   A. This question, or a variation of it, is one of the most commonly asked
      questions in the echo and there are several ways of doing what is
      wanted.  None are necessarily right or wrong.  The way I will describe
      is designed to take up as little code/data space as possible.  I do not
      attempt to explain the theory behind these functions as this can be
      obtained from any good book. Question 16 also contains valuable extra
      help on the subject of truth tables.

      The use of sets can be the best bit manipulation method if you have
      control over the data being used. Here is an example of a byte variable
      for a BBS program which sets various user access level flags.

         Bit 0 = Registered User
             1 = Twit
             2 = Normal
             3 = Extra
             4 = Privileged
             5 = Visiting Sysop
             6 = Assistant Sysop
             7 = Sysop

         status_type  = (Registered,
          status_level = set of status_type;

         access_flags  : status_level;

      Let us assume you have someone who logs on and you wish to determine
      his user access level.  After reading access_flags from the user data
      file -

           if Sysop in access_flags then ....

      To set the sysop flag -

           access_flags := access_flags + [Sysop];

      To reset the sysop flag -

           access_flags := access_flags - [Sysop];

      However on many occasions using a set may not be a suitable method.
      You may simply need to know if bit 5 is set or not.  Here is the method
      that I consider the best -

        function BitIsSet(var V,  bit: byte): boolean;
            BitIsSet := odd(V shr bit);

      To set a bit -

         procedure SetBit(var V: byte; bit: byte);
             V := V or (1 shl bit);

      To reset a bit -

         procedure ResetBit(var V: byte; bit: byte);
             V := V and not(1 shl bit);

      To toggle (flip) a bit -

         procedure ToggleBit(var V: byte; bit: byte);
             V := V xor (1 shl bit);

      Now a bit map can be made up from an array of bytes.  If stored on the
      heap you can test any bit up to number 524159 (zero based).  Here's

        map = array[0..maxsize] of byte;
        { set maxsize to number of bits div 8 -1 needed in the bit map }

      function BitSetInBitMap(var x; numb : longint): boolean;
        { Tests the numb bit in the bitmap array }
        var m: map absolute x;
          BitSetInBitMap := odd(m[numb shr 3] shr (numb and 7));

      procedure SetBitInBitMap(var x; numb: word);
        { Sets the numb bit in the bitmap array }
        var m: map absolute x;
          m[numb shr 3] := m[numb shr 3] or (1 shl (numb and 7))

      procedure ResetBitInBitMap(var x; numb : longint);
        { Resets the numb bit in the bitmap array }
        var m: map absolute x;
         m[numb shr 3] := m[numb shr 3] and not(1 shl (numb and 7));

      procedure ToggleBitInBitMap(var x; numb : longint);
        { Toggles (flips) the numb bit in the bitmap array }
        var m: map absolute x;
          m[numb shr 3] := m[numb shr 3] xor (1 shl (numb and 7));


   Q. How can I find a particular string in any file - text or binary?

   A. The Boyer-Moore string search algorithm is considered to be the fastest
      method available.  However in a rare worst-case scenario it can be
      slightly slower than a linear brute-force method.  The following
      demonstration program will show how it works and could easily be
      modified to allow for command line paramters etc.

      program BMSearchDemo;

        bigarray = array[0..32767] of byte;
        baptr    = ^bigarray;
        BMTable  = array[0..255] of byte;

        KeyStr : string = 'Put whatever you want found here';
        fname  : string = 'f:\Filename.txt';

        Btable : BMtable;
        buffer : baptr;
        f      : file;
        position : word;
        offset : longint;
        Strfound  : boolean;

      procedure MakeBMTable(var t : BMtable; var s);
        { Makes a Boyer-Moore search table. s = the search string t = the table }
          st  : BMtable absolute s;
          slen: byte absolute s;
          x   : byte;
          for x := slen downto 1 do
            if (t[st[x]] = slen) then
              t[st[x]] := slen - x

      function BMSearch(var buff,st; size : word): word;
        { Not quite a standard Boyer-Moore algorithm search routine }
        { To use:  pass buff as a dereferenced pointer to the buffer}
        {          st is the string being searched for              }
        {          size is the size of the buffer                   }
        { If st is not found, returns $ffff                         }
          buffer : bigarray absolute buff;
          s      : array[0..255] of byte absolute st;
          len    : byte absolute st;
          s1     : string absolute st;
          s2     : string;
          x      : word;
          found  : boolean;
          s2[0] := chr(len);       { sets the length to that of the search string }
          found := false;
          count := pred(len);
          while (not found) and (count < (size - len)) do begin
            if (buffer[count] = s[len]) then { there is a partial match } begin
              if buffer[count-pred(len)] = s[1] then { less partial! } begin
                found := s1 = s2;                   { if = it is a complete match }
                BMSearch := count - pred(len);      { will stick unless not found }
              inc(count);                { bump by one char - match is irrelevant }
              inc(count,Btable[buffer[count]]);   { no match so increment maximum }
          if not found then
            BMSearch := $ffff;
        end;  { BMSearch }

        offset := 0;
          position := BMSearch(buffer^,KeyStr,result);
          finished := (result < sizeof(buffer^)) or (position <> $ffff);
          if position = $ffff then
          Strfound := position <> $ffff;
        until finished;
        if Strfound then
          writeln('Found at offset ',offset)
          writeln('Not found');


   Q. How can I put a apostrophe in a string?

   A. Just put in extra apostrophes.  If you want st to be equal to the
      string -
        The word 'quoted' is in quotes
      do this -
        st := 'The word ''quoted'' is in quotes';

      if you want the following to be written to screen -
        'This is a quoted string'
      do this -
        writeln('''This is a quoted string''');


   Q. What are the best books to purchase to help me learn Turbo Pascal?

   A. There are many good books for learners.  Here are a few -

      Complete Turbo Pascal - Third Edition - Jeff Duntemann
      Mastering Turbo Pascal 6 - Tom Swann
      Turbo Pascal - The Complete Reference - O'Brien.

      For advanced users there are also many good books.  Here are a few
      that I have found useful - (Those marked with an asterisk are not
      purely for Turbo Pascal)

      Turbo Pascal 6 - Techniques and Utilities - Rubenking
      Turbo Pascal Internals - Tischer
      * PC System Programming for Developers - Tischer
      * Undocumented DOS - Schulman

      Any learner would be well advised to obtain a well known library
      such as Technojock's Turbo Toolkit (TTT) which is shareware and
      study the source code.


   Q. hat are "truth tables" and how do they work?

   A. Truth tables are a set of rules that are used to determine the result of
      logical operations.  The logical operators are -


      Here is a brief explanation of truth tables.  When two values are
      logically compared by using a logical operator each bit of one value is
      directly compared to the corresponding bit in the other value and the
      same bit in the returned value is set or reset according to the
      following truth table.

             NOT         AND             OR            XOR
         not 1 = 0    0 and 0 = 0    0 or 0 = 0    0 xor 0 = 0
         not 0 = 1    0 and 1 = 0    0 or 1 = 1    0 xor 1 = 1
                      1 and 0 = 0    1 or 0 = 1    1 xor 0 = 1
                      1 and 1 = 1    1 or 1 = 1    1 xor 1 = 0

      NOT reverses the bit.
      AND sets the returned bit if both compared bits are set.
      OR  sets the returned bit if either of the compared bits are set.
      XOR sets the returned bit if the compared bits are not the same.


   Q. What are pointers and how can I use them?  I have heard that they are
      variables that can be created and discarded as required thus saving
      memory.  Is this true?

   A. A pointer is a variable that contains a memory address.

      The heap is all of that memory allocated by DOS to a program for its
      use that has not been used by the program for its code, global data or

      Dynamic variables are variables that have had space allocated for them
      on the heap.

      Dynamic variables have no identifier (are unnamed).  Because of this
      they need an associated variable that can be used to find where they
      reside in memory. Pointers are ideal for this but need some method to
      define what type of data it is that they are pointing at.  Pascal
      provides this method.

          Str10Ptr = ^string[10];
          { This means Str10Ptr is a pointer that points to data of type }
          { string[10].                                                  }
          S : Str10Ptr;

      In the above example S is a pointer that has been defined as pointing
      to an address in memory that will contain (or should contain) data of
      type string[10].

      However how does S get this value?  How does it know where that data's
      address is supposed to be?  Well until the programmer allocates memory
      for that data S's value is undefined, so it could be literally
      pointing anywhere. So it is *vital* that before we try to use it to
      use/assign data from/to that memory location we give S a memory
      address that is not being used for any other purpose at the moment and
      that is big enough to hold the data that we want to place into it - in
      this case at least 11 bytes.  We do this by -


      Pascal has now allocated at least 11 bytes of heap and has allocated S
      with the address of the FIRST byte of that allocation.

      Ok... so far so good! How do we access that data (remembering that it
      has no name).  Well we "dereference" the pointer. This is done by
      placing a carat sign immediately following the pointer's identifier.

        S^ := 'Joe Bloggs';

      This statement actually means "Place the string 'Joe Bloggs' into the
      memory address that S contains". This is referred to as "derferencing"
      the pointer S.

      To "reference" a dynamic variable we "dereference" its associated
      pointer variable.  We cannot say -

        S := 'Joe Bloggs';

      because S is a pointer and that would be trying to give a pointer a
      string type value - a compiler "type mismatch" would occur. So every
      time we wish to access that dynamic variable we dereference it.

      To delete the dynamic variable once it is of no further use is just a
      matter of -


      What this statement does is release the memory previously used by S^
      and make it available to be used for other purposes by the program.
      Depending on the version of Pascal you are using it may not erase or
      alter the contents of that memory and it may not give S a new value.
      However any attempt to dereference S is an error as the integrity of
      that memory location has been lost - it may have been allocated to
      other data.

      Pointers do not *have* to point to a memory location in the heap or
      even have their value always allocated by using the New procedure. Any
      valid memory address can be assigned to them and then they can be
      dereferenced as shown above.  As a simple example of this lets say you
      want to examine the contents of the 16 byte area at $40:$f0 (the ICA
      area). You could - (TP specific)

           ICA_Ptr = ^array[0..15] of byte;
           B       : byte;
           ICA     : ICA_Ptr;

          ICA := ptr($40,$f0);

      Now ICA points to the address specified and you can dereference it -

          B := ICA^[10];

      Hope that helps get you started into the complex world of memory
      management and manipulation using pointers.  There are countless
      permutations and methods that can be used.


   Q. How do I do word wrap?

   A. The demo program WRAP.PAS in this archive demonstrates both word wrap
      and the justifying of text.

[Back to FAQ SWAG index]  [Back to Main SWAG index]  [Original]