home *** CD-ROM | disk | FTP | other *** search
/ CP/M / CPM_CDROM.iso / mbug / mbug060.arc / CPM#006.LBR / LOAD-HEX.DOC < prev    next >
Text File  |  1979-12-31  |  9KB  |  325 lines
  1. COPYRIGHT (C) 1984 BY GENE HEAD  ALL RIGHTS RESERVED
  2.  
  3. SCHEDULED TO APPEAR IN THE AUGUST ISSUE OF DDJ
  4.  
  5.  
  6. More dBASE II Programming Techniques    Gene Head    6-13-84
  7.  
  8.  
  9.  
  10.      In my last article (DDJ #92 - JUNE '84) I described a
  11.  
  12. machine language subroutine called ZIP-CHK.ASM that partially
  13.  
  14. validated zip codes and could be used by dBASE II using the
  15.  
  16. LOAD FILE, SET CALL TO ADDRESS, and CALL VARIABLE commands.
  17.  
  18. I now realize that older versions of dBASE II do not support the
  19.  
  20. LOAD FILE command that facilitate the loading of machine language
  21.  
  22. modules from assembled HEX files.  However, most early versions of
  23.  
  24. dBASE II (pre 2.4) WILL support the SET CALL TO ADDRESS and CALL
  25.  
  26. VARIABLE even though these commands may be undocumented in the
  27.  
  28. user's manual.
  29.  
  30.  
  31.  
  32.      In this article I will explain these and some other undocumented
  33.  
  34. features of early versions of dBASE II.  I only have access to versions
  35.  
  36. 2.3 and 2.4 so other versions are untested and should be checked
  37.  
  38. thoroughly to determine the feature actually works as I will
  39.  
  40. describe it.  I would appreciate feed back to my home address or phone
  41.  
  42. number of any results you may have on versions prior to 2.3.
  43.  
  44. I will catalog your findings and pass them on in future articles.
  45.  
  46.  
  47.  
  48.      In addition to the undocumented features I have included a
  49.  
  50. description of the HEX file format and a dBASE II command file that
  51.  
  52. will simulate the LOAD FILE command IF you can get the undocumented
  53.  
  54. PEEK and POKE to work.  After reviewing the format of the HEX file
  55.  
  56. you should be able to write a LOAD simulator in any high level
  57.  
  58. language using LOAD-HEX.CMD as a guideline.
  59.  
  60.  
  61.  
  62. PRE-2.4 UNDOCUMENTED COMMANDS
  63. -----------------------------
  64.  
  65.  
  66. PEEK(aaaaa)        will return the contents of a decimal address.
  67.  
  68. POKE aaaaa,nnn     will fill a decimal address with a decimal value.
  69.  
  70. SET CALL TO aaaaa  will set the call address to a decimal value.
  71.  
  72. CALL VARIABLE      will call the address as defined in the SET CALL TO
  73.  
  74.                command and pass the string VARIABLE as follows:
  75.  
  76.  
  77.     Upon entry of the subroutine the HL register pair will point
  78.  
  79.     to the location of the passed variable.  The variable
  80.  
  81.     is stored in the format LENGTH BYTE followed by the actual
  82.  
  83.     string characters.  For example if the variable ZIP represents
  84.  
  85.     the string '97330' then upon CALLing a subroutine HL would
  86.  
  87.     point to a series of locations with the following data bytes
  88.  
  89.     in hex:  05, 39, 37, 33, 33, 30.  The HL pair points to the
  90.  
  91.     05 and indicates there are five bytes in this string.  The next
  92.  
  93.     39, 37, 33, 33, 30 are the hex bytes that represent the ASCII
  94.  
  95.     string '97330'.  You can modify the string but you must NOT
  96.  
  97.     increase the length of the variable.  If the string becomes
  98.  
  99.     shorter you should fill it with trailing blanks.
  100.  
  101.  
  102.  
  103. TEST(variable)     will test the variable and return the following:
  104.  
  105.     -6  if the value is NUMERIC type
  106.  
  107.      0  if the variable does not exist
  108.  
  109.          1  if the variable is LOGICAL type
  110.  
  111.     nn  (a number between 1 and 255) to indicate the length
  112.  
  113.         of a STRING type variable.    
  114.  
  115.  
  116. LOADING A HEX FILE
  117. ------------------
  118.  
  119.  
  120.      The HEX file is simply an ASCII text file that holds information
  121.  
  122. about what bytes go where.  The LOAD.COM program usually is used with
  123.  
  124. the HEX file to create an executable COM file.  The format of any HEX
  125.  
  126. file is as follows:
  127.  
  128.  
  129. :10A470002356235E22F0A401080021F2A47EFE07E9    <-- line 1
  130. :10A48000CACFA4BACA8BA409C37DA4237EBBCA9633    <-- line 2
  131.  
  132.   (30 lines were deleted in this example)    
  133.  
  134. :10A672005756323437323638574935333035343914    <-- line 33
  135. :09A68200575938323038333100E9               <-- line 34
  136. :0000000000                       <-- line 35    
  137.  
  138.  
  139.      In a HEX file every line ends with a carriage return followed by
  140.  
  141. a line feed and begins with a colon.  In the above example in line
  142.  
  143. one the next two bytes following the colon, '10', are two ASCII characters
  144.  
  145. that represent one HEX value in the range 00-FF (0 to 255 decimal). 
  146.  
  147. I will call this value the NUMBER OF BYTE-PAIRS value.  We will get
  148.  
  149. back to it in just a bit.  (No pun intended.)
  150.  
  151.  
  152.  
  153.      The next four bytes 'A470' are ASCII characters that represent a
  154.  
  155. HEX value in the range of 0000-FFFF (00000 to 65,535 decimal).  I will
  156.  
  157. call this value the FIRST LOAD ADDRESS.
  158.  
  159.  
  160.  
  161.      The next two bytes '00' are ASCII characters that are reserved.
  162.  
  163. That means I don't know what they are for but in every HEX file I
  164.  
  165. have ever looked at these two bytes are always '00' and for the scope
  166.  
  167. of this article I don't think it is necessary to define them exactly.
  168.  
  169. The same can be said for the last two bytes on each line ('E9' in
  170.  
  171. line 1).  A checksum maybe?
  172.  
  173.  
  174.  
  175.      The following bytes 02, 35, 62, 35 etc. should be viewed as 
  176.  
  177. byte-pairs.  Remember the NUMBER OF BYTE-PAIRS mentioned earlier?
  178.  
  179. Well that is exactly the number of these byte-pairs we will load into
  180.  
  181. consecutive memory starting at the FIRST LOAD ADDRESS.  Each of these
  182.  
  183. byte-pairs are ASCII characters that represent a HEX value in the
  184.  
  185. range of 00-FF (0 to 255 decimal).
  186.  
  187.  
  188.  
  189.      From the example of line 1 the address locations should be
  190.  
  191. filled with the corresponding byte values as follows:
  192.  
  193.     A470    23            A478    08
  194.     A471    56            A479    00
  195.     A472    23            A47A    21
  196.     A473    5E            A47B    F2
  197.     A474    22            A47C    A4
  198.     A475    F0            A47D    7E
  199.     A476    A4            A47E    FE
  200.     A477    01            A47F    07
  201.  
  202.      If your high level language does not support a LOAD function
  203.  
  204. you can simulate one if you can read a text file and PEEK at and
  205.  
  206. POKE into memory.  The command file LOAD-HEX.CMD was written for 
  207.  
  208. dBASE II.  dBASE II only understands decimal numbers and
  209.  
  210. most of the code is converting two ASCII bytes to a decimal number
  211.  
  212. to be POKED into memory.  Understanding the format of the HEX file
  213.  
  214. as outlined should enable you to write your own HEX loader simulator
  215.  
  216. in any language.
  217.  
  218.  
  219.  
  220.      Using LOAD-HEX.CMD as guide, process line 1 of the HEX file.
  221.  
  222. Extract the load address (position 4-7 in the string), the number of
  223.  
  224. BYTE-PAIRS to POKE (position 2-3) and the individual BYTE-PAIRS
  225.  
  226. (beginning at position 10).  POKE each BYTE-PAIR then process the next
  227.  
  228. line of the HEX file.  Continue processing sequential lines until the
  229.  
  230. NUMBER OF BYTE-PAIRS is equal to zero.  The HEX file is now loaded
  231.  
  232. into memory and ready to CALL as a machine language subroutine.
  233.  
  234.  
  235.   < < < <    end of manuscript    program listing follows   > > > >
  236.  
  237.  
  238.  
  239.  
  240.  
  241.  
  242. *    LOAD-HEX.CMD
  243. *
  244. *    File to simulate the LOAD feature of dBASE II 2.4 in
  245. *    earlier versions that do not support this feature.
  246. *
  247. *    Verify that PEEK and POKE commands work before typing
  248. *    in this file and watch the syntax especially '(' & ')'.
  249. *
  250. *    From:    Head Quarters
  251. *        2860 NW Skyline Drive
  252. *        Corvallis, Oregon  97330
  253. *        (503)  758-0279
  254. *
  255. *    Copyright 1984 by Gene Head - All rights reserved
  256. *    For private, non-commercial use only.
  257. *
  258. * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  259.  
  260. SET TALK OFF
  261.  
  262. * --->    First time initialization
  263. *
  264. * The following need be done only once
  265. *
  266. * First CREATE a file named HEXDATA.DBF with ONE
  267. * field NAMED DATA of CHARACTER type, forty-four
  268. * (44)  characters in length.
  269. *
  270. * APPEND FROM the SUBROUTINE HEX file using the SDF option.
  271. * If you were going to use the Subroutine ZIP-CHK.HEX file then:
  272. *
  273. *    .
  274. *    .USE HEXLOAD
  275. *    .APPEND FROM ZIP-CHK.HEX SDF
  276. *    .
  277. *
  278. * <---    End of first time initialization
  279.  
  280.  
  281.  
  282.  
  283.  
  284.  
  285.  
  286.  
  287.  
  288.  
  289.  
  290. *  Each line of HEX data will be in the field named DATA
  291. USE HEXDATA
  292.  
  293. *   POSITION IN THIS STRING IS THE DECIMAL VALUE OF THE HEX CHARACTER
  294. *   (SEARCHING FOR A '0' RETURNS 0)
  295. STORE '123456789ABCDEF' TO HEX
  296.  
  297. * --->  COMPUTE THE BASE LOCATION OF THIS LOAD (THIS FUNCTION IS OPTIONAL)
  298. STORE STR(((@($(DATA,4,1),HEX)*16 + @($(DATA,5,1),HEX)) * 256) +;
  299.   (@($(DATA,6,1),HEX)*16 + @($(DATA,7,1),HEX)),5) TO CALL:ADR
  300. SET CALL TO &CALL:ADR
  301. * <---  END OF LOCATION OPTION
  302.  
  303. DO WHILE $(DATA,2,2) <> '00'
  304.   * Compute how many bytes to POKE from this line of the HEX file
  305.   STORE (@($(DATA,2,1),HEX)*16 + @($(DATA,3,1),HEX)) TO COUNT
  306.  
  307.     *  Get the starting POKE address
  308.     STORE ((@($(DATA,4,1),HEX)*16 + @($(DATA,5,1),HEX)) * 256);
  309.      + (@($(DATA,6,1),HEX)*16 + @($(DATA,7,1),HEX)) TO ADDRESS
  310.  
  311.     * We POKE the last BYTE-PAIR on the line of the HEX file
  312.     * and work our way back to the first BYTE-PAIR on the line.
  313.     DO WHILE COUNT
  314.       STORE STR(ADDRESS+COUNT-1,5)+','+STR(@($(DATA,COUNT*2+8,1),;
  315.         HEX)*16+@($(DATA,COUNT*2+9,1),HEX),3) TO BYTE
  316.       POKE &BYTE
  317.       STORE COUNT -1 TO COUNT
  318.     ENDDO WHILE COUNT
  319.  
  320.   * GET NEXT LINE OF HEX DATA
  321.   SKIP
  322.  
  323. ENDDO WHILE $(DATA,2,2) <> '00'
  324. USE
  325.