The World of Computer Software/World_Of_Computer_Software-02-385-Vol-1of3.iso/t/tcsel003.zip/A2FAPQ.TXT

Text File | 1992-12-12 | 38KB | 774 lines

        ANSWERS TO FREQUENTLY ASKED PASCAL QUESTIONS
        ============================================

1...

  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 -

         halt(1);

     terminates the program with an errorlevel of 1.  If halt is used without
     a parameter it is the same as -

         halt(0);

     Note:  When a program is terminated using the halt procedure any exit
            procedure that has previously been set up is executed.


2...

  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 -

        var
          head : byte absolute $40:$1c;
          tail : byte absolute $40:$1e;

        tail := head;

3...

  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
     wrong?

  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

     OR

     assign(output,'');
     rewrite(output);

     This will make all output go through DOS and thus can be redirected if
     desired.  To restore the default situation -

     AssignCRT(output); rewrite(output);


4...

   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;
          begin
            for x := 1 to length(st) do
              st[x] := UpCase(st[x]);
          end;

      As a function (slower but sometimes more convenient) -

        function StrUpper(st: string): string;
          var x : byte;
          begin
            StrUpper[0] := st[0];
            for x := 1 to length(st) do
              StrUpper[x] := UpCase(st[x]);
          end;

      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 }
       label
         fail;
       var
         regs : registers;
         x    : byte;
       begin
         if lo(DosVersion) >= 4 then begin
           with regs do begin
             ax := $6521;
             ds := seg(s);
             dx := ofs(s[1]);
             cx := length(s);
             msdos(regs);
             if odd(flags) then { the attempted conversion failed so }
               goto fail;
           end; { with }
         end { if DOS >= 4.0 } else
       fail:
           for x := 1 to length(s) do
             s[x] := UpCase(s[x]);
         StrUpper := s;
       end; { StrUpper }



5...

   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 -

      assign(output,'');
      rewrite(output);

      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.)

      var
        ansi : text;

      procedure AssignANSI(var ansifile : text);
        begin
          assign(ansifile,'CON');
          rewrite(ansifile);
        end; { AssignANSI }

      procedure WriteANSI(var st: string);
        begin
          write(ansi,st)
        end; { WriteANSI }

      procedure WriteLnANSI(var st: string);
        begin
          writeANSI(st);
          writeln(ansi);
        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.


6...

   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
                              time.

      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.



7...

   Q. How do I shell to DOS?

   A. SwapVectors;
      exec(GetEnv('COMSPEC','');
      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);
        begin
          SwapVectors;
          Dos.Exec(p1,p2);
          SwapVectors;
          Exec := DosError;
        end;

      This enables me to have a statement such as -

      ReportError(Exec(GetEnv('COMPSEC'),''));

      Now you can have an empty ReportError procedure or you can make it
      report the error - whatever is suitable for you application.


8...

   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.


9...

   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.


10...

   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.

      const
        BufferSize = 2048;
        LineLength = 78;
      type
        textbuffer = array[1..BufferSize] of char;
      var
        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 }
        var
          len         : byte absolute s;
        begin
          len := 0;
          {$I-}
          while (len < max) and not eoln(tf) do begin
            inc(len);
            read(tf);
          end;
          if eoln(tf) then
            readln(tf);
          ReadTxtLn := IOResult;
          {$I+}
        end; { ReadTxtLn }

      begin
        assign(f,filename);
        reset(f);
        SetTextBuf(f,buffer);
        while not eof(f) and (ReadTxtLn(f,st,LineLength) = 0) do
          writeln(st);
        close(f);
      end.


11...

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

   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;
        begin
          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 }


12...

   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

       type
         status_type  = (Registered,
                         Twit,
                         Normal,
                         Extra,
                         Privileged,
                         VisitingSysop,
                         AssistantSysop,
                         Sysop);
          status_level = set of status_type;

       var
         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;
          begin
            BitIsSet := odd(V shr bit);
          end;

      To set a bit -

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

      To reset a bit -

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

      To toggle (flip) a bit -

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

      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
      how.

      type
        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;
        begin
          BitSetInBitMap := odd(m[numb shr 3] shr (numb and 7));
        end;

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

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

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


13...

   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;

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

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

      var
        Btable : BMtable;
        buffer : baptr;
        f      : file;
        result,
        position : word;
        offset : longint;
        finished,
        Strfound  : boolean;

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

      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                         }
        var
          buffer : bigarray absolute buff;
          s      : array[0..255] of byte absolute st;
          len    : byte absolute st;
          s1     : string absolute st;
          s2     : string;
          count,
          x      : word;
          found  : boolean;
        begin
          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
                move(buffer[count-pred(len)],s2[1],len);
                found := s1 = s2;                   { if = it is a complete match }
                BMSearch := count - pred(len);      { will stick unless not found }
              end;
              inc(count);                { bump by one char - match is irrelevant }
            end
            else
              inc(count,Btable[buffer[count]]);   { no match so increment maximum }
          end;
          if not found then
            BMSearch := $ffff;
        end;  { BMSearch }


      begin
        new(buffer);
        assign(f,fname);
        reset(f,1);
        offset := 0;
        MakeBMTable(Btable,KeyStr);
        repeat
          BlockRead(f,buffer^,sizeof(buffer^),result);
          position := BMSearch(buffer^,KeyStr,result);
          finished := (result < sizeof(buffer^)) or (position <> $ffff);
          if position = $ffff then
            inc(offset,result);
          Strfound := position <> $ffff;
        until finished;
        close(f);
        if Strfound then
          writeln('Found at offset ',offset)
        else
          writeln('Not found');
      end.

14...

   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''');


15...

   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.

 16.

   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 -

        NOT
        AND
        OR
        XOR.

      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.


 17.

   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
      stack.

      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.

        type
          Str10Ptr = ^string[10];
          { This means Str10Ptr is a pointer that points to data of type }
          { string[10].                                                  }
        var
          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 -

        new(S);

      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 -

        dispose(S);

      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)

         type
           ICA_Ptr = ^array[0..15] of byte;
         var
           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.


 18.

   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.