home *** CD-ROM | disk | FTP | other *** search
/ Mega CD-ROM 1 / megacd_rom_1.zip / megacd_rom_1 / MAGAZINE / DDJMAG / DDJ8910.ZIP / MISCHEL.LST < prev    next >
File List  |  1989-09-07  |  22KB  |  757 lines
  1. _A Global Variable Device Driver for MS-DOS_
  2. by Jim Mischel
  3.  
  4. [LISTING ONE]
  5.  
  6.     name    globals
  7.     page    ,132
  8.     title   'GLOVAR - global variable device driver
  9. ;
  10. ; GLOVAR.ASM
  11. ;
  12. ; Copyright 1989, Jim Mischel
  13. ;
  14. ; This MS-DOS device driver provides true global variables to application
  15. ; programs.
  16. ;
  17. ; Sample make file:
  18. ; #
  19. ; # glovar.mak - build global variable device driver glovar.sys.
  20. ; #
  21. ; glovar.sys: glovar.asm
  22. ;   tasm glovar
  23. ;   link glovar;
  24. ;   exe2bin glovar.exe glovar.sys
  25. ;
  26.     ideal
  27.     locals
  28.  
  29.     model   tiny,pascal
  30.     CodeSeg
  31.  
  32.     org 0       ;device drivers start at offset 0
  33.     
  34. max_cmd     equ 12  ;only 12 functions recognized by the driver
  35. cr      equ 0dh
  36. lf      equ 0ah
  37. buff_size   equ 1024    ;buffer size in bytes
  38. TRUE        equ -1
  39. FALSE       equ 0
  40.  
  41. ;
  42. ; Device Driver Header
  43. ;
  44. header  dd  -1      ;link to next device, -1 = end of list
  45.         dw  8000h       ;simple character device driver
  46.     dw  strat       ;device Strategy entry point
  47.     dw  intr        ;device Interrupt entry point
  48.     db  '$$GVAR$$'  ;Device name
  49.  
  50. rh_ptr  dd  ?       ;saved request header pointer
  51.  
  52. ;
  53. ; Command codes dispatch table.  Only functions 0 (initialize) and 4 (read)
  54. ; are supported.  Other functions go to a stub routine that simple returns
  55. ; a non-error status.
  56. ;
  57. dispatch:
  58.     dw  init        ; 0 = initialize driver
  59.     dw  not_imp     ; not implemented
  60.     dw  not_imp     ; not implemented
  61.     dw  not_imp     ; not implemented
  62.     dw  read        ; 4 = read from device
  63.     dw  not_imp     ; not implemented
  64.     dw  not_imp     ; not implemented
  65.     dw  not_imp     ; not implemented
  66.     dw  not_imp     ; not implemented
  67.     dw  not_imp     ; not implemented
  68.     dw  not_imp     ; not implemented
  69.     dw  not_imp     ; not implemented
  70.     dw  not_imp     ; not implemented
  71.     dw  not_imp     ; not implemented
  72. ;
  73. ; MS-DOS Request Header structure definition
  74. ;
  75. struc   request
  76. rlength db  ?       ;length of request header
  77. unit    db  ?       ;unit number for this request (block devices)
  78. command db  ?       ;request header's command code
  79. status  dw  ?       ;driver's return status word
  80. reserve db  8 dup (?)   ;reserved area
  81. media   db  ?       ;media descriptor byte (block devices)
  82. address dd  ?       ;memory address for transfer
  83. count   dw  ?       ;byte/sector count value
  84. sector  dw  ?       ;starting sector value (block devices)
  85. ends    request         ;end of request header template
  86.  
  87. ; Status codes returned by routines in AX
  88. error       equ 8000h
  89. busy        equ 0200h
  90. done        equ 0100h
  91. unknown_command equ 3
  92.  
  93. ;
  94. ; Device strategy routine -- save address of request header.
  95. ;
  96. strat:  mov [word ptr cs:rh_ptr],bx
  97.     mov [word ptr cs:rh_ptr+2],es
  98.     retf
  99.  
  100. ;
  101. ; Interrupt routine.  Dispatch to the proper routine.
  102. ;
  103. proc    intr    far uses ax bx cx dx ds es di si
  104.     pushf
  105.     push    cs
  106.     pop ds              ;point to local data
  107.     les di,[rh_ptr]         ;ES:DI = Request Header
  108.     mov bl,[es:di+request.command]  ;bx = command code
  109.     xor bh,bh
  110.     cmp bx,max_cmd          ;make sure it's legal
  111.     jle intr1
  112.     mov ax,error+unknown_command    ;Error:  unknown command
  113.     jmp short intr2
  114. intr1:  shl bx,1                ;form index to dispatch table
  115.     call    [word ptr bx+dispatch]      ;and branch to driver routine
  116.     les di,[rh_ptr]         ;ES:DI = request header
  117. intr2:  or  ax,done             ;set Done bit
  118.     mov [es:di+request.status],ax   ;store status in request header
  119.     popf
  120.     ret
  121. endp    intr
  122.  
  123. ;
  124. ; 'stub' routine for un-implemented functions.
  125. ;
  126. not_imp:
  127.     xor ax,ax           ;set good status
  128.     retn
  129.  
  130. ;
  131. ; Read -- return address of 'global_table'
  132. ;
  133. ; This routine assumes that the application program asked for 4 (no less!)
  134. ; bytes (the size of a far pointer).
  135. ;
  136. ; This function is called with ES:DI pointing to the MS-DOS request header.
  137. ;
  138. read:   lds si,[dword ptr es:di+request.address]    ;DS:SI is buffer address
  139.     mov [word ptr ds:si],offset global_table    ;store offset
  140.     mov [word ptr ds:si+2],cs           ;and segment
  141.     mov [word ptr es:di+request.count],4    ;4 bytes transferred
  142.     xor ax,ax                   ;return good status
  143.     ret
  144.  
  145. ;
  146. ; The following three routines (set_var, get_var, flush_vars) are accessed
  147. ; by applications programs through FAR calls.  The addresses of these
  148. ; functions are provided in the 'global_table' structure, the address of
  149. ; which is passed to the application when it does a read on the $$GVAR$$
  150. ; device.
  151. ;
  152.  
  153. ;
  154. ; set_var -- assign a value to the global variable pointed to by the
  155. ; 'varname' parameter.  If the 'vardef' parameter points to the null string,
  156. ; the variable is removed from the table.
  157. ;
  158. ; Returns TRUE (-1) if successful, FALSE (0) if variable table overflows.
  159. ;
  160. proc    set_var far uses si di ds, varname:far ptr, vardef:far ptr
  161.     lds si,[varname]
  162.     call    near ptr remove_var     ;try to remove variable
  163.     les di,[vardef]
  164.     cmp [byte ptr es:di],0      ;check for NULL string
  165.     jnz do_set
  166.     mov ax,-1               ;and if so, just call it quits
  167.     jmp short set_done
  168. do_set: lds si,[varname]            ;otherwise,
  169.     call    near ptr install_var        ;install the new def
  170. set_done:
  171.     ret
  172. endp    set_var
  173.  
  174. ; 
  175. ; Return the definition of the variable pointed to by 'varname' in the
  176. ; space pointed to by 'vardef'.  Returns -1 if the variable exists, 0 if
  177. ; not.  If the variable does not exist the null string is returned in 'vardef'.
  178. ;
  179. proc    get_var far uses si di ds, varname:far ptr, vardef:far ptr
  180.     lds si,[varname]
  181.     call    find_var
  182.     jnc get1            ;if found, continue
  183.     les di,[vardef]     ;otherwise,
  184.     mov [byte ptr es:di],0  ;store NULL string
  185.     xor ax,ax           ;set failure status
  186.     jmp short @@done        ;and exit
  187. get1:   cld             ;variable found, now find '='
  188.     mov al,'='
  189.     mov cx,-1
  190.     repnz   scasb
  191.     mov si,di
  192.     push    es
  193.     pop ds          ;DS:SI now points to first character of definition
  194.     les di,[vardef]     ;ES:DI points to return vardef area
  195. @@loop: lodsb               ;copy the definition to
  196.     stosb               ;the 'vardef' string
  197.     or  al,al
  198.     jnz @@loop
  199.     mov ax,TRUE         ;set status to TRUE
  200. @@done: ret
  201. endp    get_var
  202.  
  203. ;
  204. ; flush all variables from the global variable table.  This is done by placing
  205. ; a NULL byte at the start of the table and updating the 'next_mem' variable
  206. ; so that it also points to the head of the table.
  207. ;
  208. flush_vars:
  209.     mov [word ptr cs:glovars],0
  210.     mov ax,offset glovars
  211.     mov [word ptr cs:next_mem],ax
  212.     retf
  213.  
  214. ;
  215. ; Support routines.
  216. ;
  217. ; Remove the variable (name pointed to by ds:si) and its definition from
  218. ; the global variables table.
  219. ;
  220. remove_var:
  221.     call    find_var            ;find the variable
  222.     jc  @@done
  223.     cld
  224.     mov si,di               ;SI is start of variable name
  225.     mov al,0
  226.     mov cx,-1
  227.     repnz   scasb               ;move past definition
  228.     add [word ptr cs:next_mem],cx   ;update next_mem pointer
  229.     inc [word ptr cs:next_mem]
  230.     xchg    si,di               ;si=next variable, di=old var 
  231.     push    cs
  232.     pop ds
  233.     mov cx,offset end_buff
  234.     sub cx,si               ;cx is byte count
  235.     rep movsb               ;variable has been erased
  236. @@done: ret
  237.  
  238. ;
  239. ; Called with ds:si pointing to variable name, es:di pointing to definition.
  240. ;
  241. install_var:
  242.     push    es
  243.     push    di          ;save 'vardef' address
  244.     cld
  245.     mov al,0
  246.     mov cx,-1
  247.     repnz   scasb           ;get length of definition
  248.     not cx
  249.     mov bx,cx           ;and save
  250.     push    bx          ;will be used to copy the definition
  251.     push    ds
  252.     pop es
  253.     mov di,si
  254.     mov cx,-1
  255.     repnz   scasb           ;get length of variable name
  256.     not cx
  257.     push    cx          ;will be used to copy the variable name
  258.     add bx,cx           ;bx=strlen(varname)+strlen(vardef)+2
  259.     mov ax,buff_size + offset glovars
  260.     sub ax,[word ptr cs:next_mem]
  261.     cmp ax,bx
  262.     jnc inst1           ;if not enough room
  263.     xor ax,ax           ;then fail
  264.     add sp,8            ;clean up stack
  265.     ret
  266. inst1:  push    cs
  267.     pop es
  268.     mov di,[word ptr cs:next_mem]   ;ES:DI points to buffer
  269.     pop cx          ;restore varname length
  270.     dec cx          ;don't want null terminator
  271. @@loop1:
  272.     lodsb
  273.     call    toupper         ;convert char to upper_case
  274.     stosb               ;and store
  275.     loop    @@loop1
  276. inst2:  mov al,'='
  277.     stosb               ;store the '=' separator
  278.     pop cx          ;restore definition length
  279.     pop si          ;restore 'vardef' address
  280.     pop ds
  281.     rep movsb           ;and copy definition to buffer
  282.     mov [word ptr cs:next_mem],di
  283.     stosb               ;store extra null byte for safe keeping
  284.     mov ax,TRUE
  285.     ret
  286.  
  287. ;
  288. ; find_var -- attempt to find the variable pointed to by DS:SI in the
  289. ; global variables buffer.  
  290. ; On success, AX = TRUE (-1), carry is cleared, and ES:DI points to the first
  291. ; character of the variable name in the buffer.
  292. ; If the variable is not found, AX = FALSE (0), carry flag is set, and ES:DI
  293. ; is undefined.
  294. ;
  295. find_var:
  296.     cld
  297.     push    cs
  298.     pop es
  299.     mov di,offset glovars
  300.     mov dx,si           ;save name starting address
  301. find0:  mov bx,di           ;and variable starting address
  302.     mov si,dx
  303.     dec di
  304. find1:  lodsb
  305.     call    toupper
  306.     inc di
  307.     cmp al,[byte ptr es:di]
  308.     jz  find1
  309.     or  al,al           ;didn't match, at end of string?
  310.     jnz get_next_var        ;if not, go for next variable
  311.     cmp [byte ptr es:di],'='    ;at end of varname in buffer?
  312.     jnz get_next_var        ;if not, do next variable
  313.     mov di,bx           ;variable found
  314.     mov ax,TRUE
  315.     ret
  316. get_next_var:
  317.     mov al,0
  318.     mov cx,-1
  319.     repnz   scasb           ;get start of next variable
  320.     cmp [byte ptr es:di],0  ;if not at end of buffer
  321.     jnz find0           ;then do next variable
  322.     xor ax,ax
  323.     stc             ;the variable wasn't found
  324.     ret
  325. ;
  326. ; toupper - convert the character in AL to upper-case.
  327. ;
  328. toupper:
  329.     cmp al,'a'
  330.     jc  tod
  331.     cmp al,'z'+1
  332.     jnc tod
  333.     sub al,32
  334. tod:    ret
  335.  
  336.     even                ;might as well
  337.  
  338. ;
  339. ; The address of this table is passed back to the application whenever
  340. ; a 'read' call is made on the device.
  341. ; The application uses this table to access the memory buffer and the
  342. ; driver functions.
  343. ;
  344. global_table:
  345.     dd  ?           ;address of memory buffer
  346.     dd  ?           ;address of set_var routine
  347.     dd  ?           ;address of get_var routine
  348.     dd  ?           ;address of flush_vars routine
  349.  
  350. next_mem dw offset glovars      ;pointer to end of defined variables
  351.  
  352. glovars:                ;start of glovar buffer
  353.  
  354. ;
  355. ; Initialization code.
  356. ;
  357. ; Initialize the function pointers table and the global data buffer, and 
  358. ; return the address of the first byte of free memory after all the device
  359. ; driver code.  The global variables buffer overlays this initialization code.
  360. ;
  361. ; Upon entry, ES:DI points to the MS-DOS request header.  DS contains the
  362. ; local data segment (same as CS).  This routine makes no attempt to save
  363. ; any registers.
  364. ;
  365. init:   mov ax,cs
  366.     mov es,ax
  367.     mov di,offset dhaddr
  368.     call    hexasc          ;convert load segment address to ASCII
  369.     mov ax,cs
  370.     mov es,ax
  371.     mov di,offset mbaddr
  372.     call    hexasc
  373.     push    cs
  374.     pop es
  375.     mov ax,offset glovars
  376.     mov di,offset mbaddr+5
  377.     call    hexasc
  378.     mov ah,9            ;print sign-on message and
  379.     mov dx,offset ident     ;driver load address
  380.     int 21h
  381.     les di,[rh_ptr]     ;request header address in ES:DI
  382. ;store first usable memory address in request header
  383.     mov [word ptr es:di+request.address],offset end_buff
  384.     mov [word ptr es:di+2+request.address],cs
  385. ;
  386. ; Now set up the 'global_table' structure with proper memory addresses.
  387. ;
  388.     mov [word ptr global_table],offset glovars
  389.     mov [word ptr global_table+2],cs
  390.     mov [word ptr global_table+4],offset set_var
  391.     mov [word ptr global_table+6],cs
  392.     mov [word ptr global_table+8],offset get_var
  393.     mov [word ptr global_table+10],cs
  394.     mov [word ptr global_table+12],offset flush_vars
  395.     mov [word ptr global_table+14],cs
  396.     xor ax,ax               ;return good status
  397.     mov [word ptr glovars],ax       ;and clear glovars buffer
  398.     ret
  399.  
  400. ident   db  cr,lf,lf
  401.     db  'Global variable device driver version 1.0',cr,lf
  402.     db  'Copyright 1989, Jim Mischel',cr,lf
  403.     db  'Device Header at '
  404. dhaddr  db  'XXXX:0000.  '
  405.     db  'Memory buffer at '
  406. mbaddr  db  'SSSS:OOOO',cr,lf,lf,'$'
  407.  
  408. ;
  409. ; hexasc - converts a binary 16-bit number into a hex ASCII string
  410. ;
  411. ; call with AX = value to convert, ES:DI = address to store 4-character
  412. ; string.
  413. ;
  414. hexasc: mov bx,ax       ;save value here
  415.     mov cx,4        ;initialize character counter
  416.     mov dx,cx
  417. hexasc1:
  418.     xchg    cx,dx
  419.     rol bx,cl       ;isolate next 4 bits
  420.     mov al,bl
  421.     and al,0fh
  422.     add al,'0'      ;convert to ASCII
  423.     cmp al,'9'      ;if 0-9
  424.     jbe hexasc2     ;then jump
  425.     add al,'A'-'9'-1    ;otherwise add offset for A-F
  426. hexasc2:
  427.     stosb
  428.     xchg    cx,dx
  429.     loop    hexasc1
  430.     ret
  431.  
  432. ; reserve space for rest of global variable buffer.
  433.     db  buff_size - (offset $ - offset glovars) + 1 dup (0)
  434.  
  435.     even
  436. end_buff:
  437.     end
  438.  
  439.  
  440. [LISTING TWO]
  441.  
  442.  
  443. /*
  444.  * GVAR.C - program to test global device driver interface.
  445.  * Required structure and function definitions are in the file GVAR.H
  446.  *
  447.  * Sample make file.
  448.  *
  449.  * #
  450.  * # tcgvar.mak - make C gvar test program
  451.  * #
  452.  * gvar.exe: gvar.c gvar.h
  453.  *   tcc -ms gvar
  454.  *
  455.  */
  456. #include <stdio.h>
  457. #include <conio.h>
  458. #include <fcntl.h>
  459. #include <io.h>
  460. #include "gvar.h"
  461.  
  462. void main (void) {
  463.     char buff[1024];
  464.     int fhandle;
  465.  
  466.     if ((fhandle = _open ("$$GVAR$$", O_RDONLY)) == -1) {
  467.     puts ("Error:  can't open global variables file");
  468.     return;
  469.     }
  470.     read (fhandle, &gvars, sizeof (char far *));
  471.     printf ("global table at %Fp\n", gvars);
  472.     _close (fhandle);
  473.     if (!set_gvar ("JIMSVAR", "Hi jim.!"))
  474.         puts ("Error setting variable JIMSVAR");
  475.     if (!get_gvar ("jimsvar", buff))
  476.         puts ("JIMSVAR not defined");
  477.     else
  478.         printf ("JIMSVAR=%s\n", buff);
  479.     set_gvar ("jimsvar","");
  480.     if (!get_gvar ("JIMSVAR", buff))
  481.         puts ("JIMSVAR not defined");
  482.     else
  483.         printf ("JIMSVAR=%s\n", buff);
  484. }
  485.  
  486.  
  487. [LISTING THREE]
  488.  
  489. /*
  490.  * gvar.h -- required definitions for C interface to global variable
  491.  * device driver.
  492.  *
  493.  * Copyright 1989, Jim Mischel
  494.  */
  495.  
  496. /*
  497.  * structure of table returned by glovar read call.
  498.  */
  499. typedef struct {
  500.     void far *mem_buff;     /* pointer to memory buffer */
  501. /* function pointers */
  502.     int  far pascal (far *set_var)    (char far *, char far *);
  503.     int  far pascal (far *get_var)    (char far *, char far *);
  504.     void far pascal (far *flush_vars) ();
  505. } GVAR_DEF;
  506.  
  507. GVAR_DEF far *gvars;    /* global pointer to global variables structure */
  508.  
  509. /*
  510.  * function macros
  511.  */
  512. #define set_gvar (*gvars->set_var)
  513. #define get_gvar (*gvars->get_var)
  514. #define flush_gvars (*gvars->flush_vars)
  515.  
  516.  
  517.  
  518. [LISTING FOUR]
  519.  
  520. {*
  521.  *  GVAR.PAS - Test global variable device driver.
  522.  * 
  523.  * This program depends on the routines in TPGVAR.ASM to provide the interface
  524.  * to the device driver.
  525.  *
  526.  * Make sure the file tpgvar.obj is in the current directory 
  527.  * (or Turbo's /Object directory) before compiling this program.
  528.  *
  529.  * Sample make file for compiling this program:
  530.  * #
  531.  * # tpgvar.mak - make pascal gvar test program
  532.  * #
  533.  * gvar.exe: gvar.pas tpgvar.obj
  534.  *   tpc gvar
  535.  *
  536.  * tpgvar.obj: tpgvar.asm
  537.  *   tasm tpgvar
  538.  *
  539.  *}
  540.  
  541. {$F+}           { asm routines require far calls }
  542. {$L tpgvar}
  543. program test_globals;
  544. type
  545.     varstr  = string[255];
  546.  
  547. var
  548.     buff : varstr;
  549.  
  550. function gvar_init : boolean; external;
  551. function set_gvar (varname : varstr; vardef : varstr) : boolean; external;
  552. function get_gvar (varname : varstr; var vardef : varstr) : boolean; external;
  553. procedure flush_gvars; external;
  554.  
  555. begin
  556.     if (not gvar_init) then begin
  557.     writeln ('Can''t open gvars file.  Program aborted.');
  558.     halt;
  559.     end;
  560.     if (not set_gvar ('JIMSVAR', 'HELLO THERE'))
  561.         writeln ('Error setting variable JIMSVAR');
  562.     if (not get_gvar ('jimsvar', buff))
  563.         writeln ('JIMSVAR not defined')
  564.     else
  565.         writeln ('JIMSVAR=', buff);
  566.     trash := set_gvar ('jimsvar','');
  567.     if (not get_gvar ('jimsvar', buff))
  568.         writen ('JIMSVAR not defined')
  569.     else
  570.         writeln ('JIMSVAR=', buff);
  571. end.
  572.  
  573.  
  574. [LISTING FIVE]
  575.  
  576.  
  577.     page    ,132
  578.     name    tpgvar
  579.     title   'TPGVAR -- Turbo Pascal global variable interface routines'
  580. ;
  581. ; TPGVAR.ASM
  582. ; These routines provide the Turbo Pascal interface to the global variable 
  583. ; device driver.
  584. ;
  585. ; The routines provided are:
  586. ; 
  587. ; GVAR_INIT
  588. ; function gvar_init : boolean; external;
  589. ;   Returns TRUE if successful, FALSE otherwise.  MUST be called before using
  590. ;   any of the other functions.
  591. ;
  592. ; SET_GVAR
  593. ; function set_gvar (varname : varstr; vardef : varstr) : boolean; external;
  594. ;   Defines the variable 'varname' with the value 'varstr'.  Returns FALSE
  595. ;   if inserting this variable will over-run the global variables buffer.
  596. ;
  597. ; GET_GVAR
  598. ; function get_gvar (varname : varstr; var vardef : varstr) : boolean; external;
  599. ;   Return the definition of the variable 'varname' in the string 'vardef'.
  600. ;   Returns FALSE if 'varname' doesn't exist.
  601. ;
  602. ; FLUSH_GVARS   procedure flush_gvars; external;
  603. ;   Removes all global variables from the buffer.
  604. ;
  605. ; Copyright 1989, Jim Mischel
  606. ;
  607.     model   tpascal
  608.     ideal
  609.     locals
  610.  
  611. ;
  612. ; global variable interface structure
  613. ; A pointer to this type of structure is returned by the $$GVAR$$ device
  614. ; in response to a read call.
  615. ;
  616. struc gvars
  617. membuff_ptr dd  ?
  618. set_var_ptr dd  ?
  619. get_var_ptr dd  ?
  620. flush_vars_ptr  dd  ?
  621. ends
  622.  
  623.     CodeSeg
  624. ;
  625. ; This has to go into the code segment because 'TPascal' model won't allow
  626. ; initialization in the data segment.
  627. ;
  628. gvar_filename   db  '$$GVAR$$',0    ;global variable device name
  629. gvar_ptr    dd  ?       ;pointer to global variables structure
  630. glovar_name db  256 dup (?) ;passed to driver routines
  631. glovar_def  db  256 dup (?)
  632.  
  633. public  GVAR_INIT
  634. public  SET_GVAR
  635. public  GET_GVAR
  636. public  FLUSH_GVARS
  637.  
  638. ;
  639. ; open the $$GVAR$$ file and read the address of the header into gvar_ptr
  640. ; returns TRUE if successful, FALSE if not.
  641. ;
  642. proc    gvar_init uses ds
  643.     push    cs
  644.     pop ds
  645.     mov dx,offset gvar_filename
  646.     mov ax,3d00h
  647.     int 21h         ;open the file
  648.     jc  @@error         ;error opening file
  649.     push    ax          ;save file handle
  650.     mov bx,ax           ;file handle in BX
  651.     mov dx,offset gvar_ptr
  652.     mov ah,3fh
  653.     mov cx,4
  654.     int 21h         ;read address of gvar structure
  655.     pop bx          ;file handle in BX
  656.     mov ah,3eh
  657.     int 21h         ;close the file
  658.     mov ax,-1
  659.     jmp short @@done
  660. @@error:
  661.     xor ax,ax
  662. @@done: ret
  663. endp    gvar_init
  664.  
  665. ;
  666. ; This macro converts the Turbo Pascal string in the 'from' parameter to an
  667. ; ASCIIZ string in the 'to' parameter.
  668. ;
  669. macro @make_asciiz from, to
  670.     lds si,[&from&]
  671.     push    cs
  672.     pop es
  673.     mov di,offset &to&
  674.     push    cs          ;these values are pushed now, but not
  675.     push    di          ;used until the gvar call below      
  676.     call    near ptr make_asciiz
  677. endm
  678.  
  679. ;
  680. ; Macro calls the specified routine.
  681. ;
  682. macro @gvar_call routine
  683.     les bx,[cs:gvar_ptr]
  684.     call    [dword ptr es:bx+gvars.&routine&]
  685. endm
  686.  
  687. ;
  688. ; Define 'varname' with value 'vardef'.  Returns TRUE if successful, FALSE
  689. ; if the global variables buffer overflows.
  690. ;
  691. proc    set_gvar uses ds, varname:far ptr, vardef:far ptr
  692.     @make_asciiz varname, glovar_name
  693.     @make_asciiz vardef, glovar_def
  694.     @gvar_call set_var_ptr
  695.     ret
  696. endp    set_gvar
  697.  
  698. ;
  699. ; Return definition of 'varname' in 'vardef'.  Returns TRUE if successful,
  700. ; FALSE if 'varname' does not exist.  If 'varname' does not exist, 'vardef'
  701. ; is set to the null string.
  702. ;
  703. ; CAUTION:  if the returned variable definition is longer than 255 characters,
  704. ; many strange and not-so-wonderful things will happen.
  705. ;
  706. proc    get_gvar uses ds, varname:far ptr, vardef:far ptr
  707.     @make_asciiz varname, glovar_name
  708.     push    cs
  709.     mov ax,offset glovar_def
  710.     push    ax
  711.     @gvar_call get_var_ptr      ;get the variable
  712.     push    ax          ;save return status
  713.     push    cs          ;now convert definition to TP string
  714.     pop ds
  715.     mov si,offset glovar_def
  716.     les di,[vardef]
  717.     push    di          ;save to set length
  718.     inc di          ;start string at second byte
  719.     xor cx,cx           ;cx is byte count
  720.     cld             ;better safe than sorry
  721. @@loop: lodsb
  722.     or  al,al
  723.     jz  @@done
  724.     stosb
  725.     inc cx          ;bump length
  726.     jmp short @@loop
  727. @@done: pop di          ;restore pointer to length byte
  728.     mov [byte ptr es:di],cl ;and store length there
  729.     pop ax          ;restore return status
  730.     ret
  731. endp    get_gvar
  732.  
  733. ;
  734. ; flush all global variables
  735. proc    flush_gvars
  736.     @gvar_call flush_vars_ptr
  737.     ret
  738. endp    flush_gvars
  739.  
  740. ;
  741. ; convert Turbo Pascal string into ASCIIZ string.
  742. ; Call with ds:si pointing to source string (TP format)
  743. ;           es:di pointing to destination buffer
  744. ; Make sure this is accessed through a near call.
  745. ;
  746. make_asciiz:
  747.     lodsb               ;get length
  748.     mov cl,al
  749.     xor ch,ch           ;in CX
  750.     cld
  751.     rep movsb           ;move the string
  752.     mov [byte ptr es:di],0  ;and place the null terminator
  753.     retn
  754.     end
  755.  
  756.  
  757.