home *** CD-ROM | disk | FTP | other *** search
/ The C Users' Group Library 1994 August / wc-cdrom-cusersgrouplibrary-1994-08.iso / vol_100 / 137_01 / llint.asm < prev    next >
Assembly Source File  |  1985-03-10  |  8KB  |  378 lines
  1. ;
  2. ; llint.asm
  3. ;
  4. ; version of 25-Mar-84
  5. ;
  6. ; a component of lsup.c
  7. ;
  8. ; Copyright 1984 (c) A. Skjellum. All rights reserved.
  9. ; 
  10. ; these routines are setup for Aztec C86 v 1.05i
  11. ;
  12. ; all procedures are "near"
  13. ;
  14.  
  15. dseg    segment para public 'data'
  16. dseg    ends
  17.  
  18. cseg    segment para public 'code'
  19.     assume    cs:cseg,ds:dseg,es:dseg,ss:dseg
  20.  
  21. ;
  22. ; Routines which do not merit calls to portable routines in llsup.asm
  23. ;
  24.  
  25. ;
  26. ; ds = flptr(lptr,sptr)
  27. ; LPTR *lptr;
  28. ; char *sptr;
  29. ;
  30. ; form a long pointer from a "normal" ds relative short pointer (sptr)
  31. ; and store at lptr
  32. ;
  33. ; note: no portable segment (flptr) in llsup.asm since this
  34. ; is such a trivial routine.
  35. ;
  36. ; return value is also ds, should this prove useful
  37. ;
  38.     public    flptr_
  39. flptr_    proc    near
  40.     mov    bx,sp        ; prepare for argument load
  41.     mov    ax,4[bx]    ; get short pointer ds:ax
  42.     mov    bx,2[bx]    ; get address where to store long pointer
  43.     mov    [bx],ax        ; store low order
  44.     mov    ax,ds
  45.     mov    2[bx],ax    ; store high order
  46.     ret            ; return value is also ds
  47. flptr_    endp
  48.  
  49. ;
  50. ; the following four routines are examples of what can
  51. ; be done to supplement general routines with specific
  52. ; (more efficient ones).  Many more variations are
  53. ; possible than the two presented here.  They follow
  54. ; directly from this basic idea:
  55. ;
  56. ;
  57. ; char lchr(lptr)
  58. ; LPTR *lptr;
  59. ;
  60. ; return character pointed to by lptr
  61. ;
  62.     public    lchr_
  63. lchr_    proc    near
  64.     mov    bx,sp        ; prepare for argument load
  65.     push    ds        ; save ds register
  66.     mov    bx,2[bx]    ; get address of lptr
  67.     mov    ax,[bx]        ; 
  68.     mov    ds,2[bx]    ; begin forming pointer
  69.     mov    bx,ax        ; ds:bx now is valid pointer
  70.     sub    ax,ax        ; zero whole acc.
  71.     mov    al,[bx]        ; get the character
  72.     pop    ds
  73.     ret            ; exit with char in ax
  74. lchr_    endp
  75.  
  76. ;
  77. ; int lint(lptr)
  78. ; LPTR *lptr;
  79. ; 
  80. ; return integer or unsigned pointed to by lptr
  81. ;
  82.     public    lint_
  83. lint_    proc    near
  84.     mov    bx,sp        ; prepare for argument load
  85.     push    ds        ; save ds register
  86.     mov    bx,2[bx]    ; get address of lpr
  87.     mov    ax,[bx]        ; 
  88.     mov    ds,2[bx]    ; begin forming pointer
  89.     mov    bx,ax        ; ds:bx now is valid pointer
  90.     mov    ax,[bx]        ; get the integer or unsigned
  91.     pop    ds        ; recover old ds value
  92.     ret            ; and exit with char in ax
  93. lint_    endp
  94.  
  95. ;
  96. ; l_stchr(lptr,chr)
  97. ; LPTR *lptr;
  98. ; char chr;
  99. ;
  100. ; store character chr at address lptr
  101. ;
  102.     public    l_stchr_
  103. l_stchr_ proc    near
  104.     mov    bx,sp        ; prepare for argument load
  105.     mov    cl,4[bx]    ; get character
  106.     mov    bx,2[bx]    ; prepare for load of long pointer
  107.     push    ds        ; save ds segment register
  108.     mov    ax,[bx]        ; 
  109.     mov    ds,2[bx]    ; begin forming pointer
  110.     mov    bx,ax        ; ds:bx now is valid pointer
  111.     mov    [bx],cl        ; store byte
  112.     pop    ds
  113.     ret
  114. l_stchr_ endp
  115.  
  116. ;
  117. ; l_stint(lptr,val)
  118. ; LPTR *lptr;
  119. ; int val;
  120. ;
  121. ; store integer or unsigned at address lptr
  122. ;
  123.     public    l_stint_
  124. l_stint_ proc    near
  125.     mov    bx,sp        ; prepare for argument load
  126.     mov    cx,4[bx]    ; get integer to store
  127.     mov    bx,2[bx]    ; prepare to form ds:bx with correct
  128.                 ; storage address
  129.     push    ds        ; save current ds
  130.     mov    ax,[bx]        ; 
  131.     mov    ds,2[bx]    ; begin forming pointer
  132.     mov    bx,ax        ; ds:bx now is valid pointer
  133.     mov    [bx],cx        ; store the integer
  134.     pop    ds
  135.     ret            ; exit 
  136. l_stint_ endp
  137.  
  138. ;
  139. ; lload(dest,lptr,len)
  140. ; char *dest;
  141. ; LPTR *lptr;
  142. ; unsigned len;
  143. ;
  144. ; general purpose copy routine from long data storage to ds: relative
  145. ; storage
  146. ;
  147. ; we assume es = ds for Aztec C explicitly here
  148. ;
  149. ; due to convenient 8086 instructions, the portable function would
  150. ; consist merely of a "cld", "rep movsb" sequence followed by a return.
  151. ; Therefore, no portable lload is included in llsup.asm
  152. ;
  153.  
  154.     public    lload_
  155. lload_    proc    near
  156.     mov    bx,sp        ; prepare for argument load
  157.     push    ds        ; save Aztec ds segment
  158.     push    si
  159.     push    di        ; save source and destination indices
  160.     ;
  161.     mov    cx,6[bx]    ; get length for move
  162.     mov    di,2[bx]    ; es:di now has the destination address
  163.     mov    bx,4[bx]    ; prepare to load long ptr
  164.     mov    si,[bx]        ; get low order
  165.     mov    ds,2[bx]    ; and then high order
  166.     cld
  167.     rep    movsb        ; do the move
  168.     pop    di
  169.     pop    si
  170.     pop    ds
  171.     ret
  172. lload_    endp
  173.  
  174. ;
  175. ; lstor(lptr,src,len)
  176. ; LPTR *lptr;
  177. ; char *src;
  178. ; unsigned len;
  179. ;
  180. ; Reverse of lload: this routine copies data from ds:src to lptr
  181. ; Once again, there is no llsup analog.
  182. ;
  183.     public    lstor_
  184. lstor_    proc    near
  185.     mov    bx,sp        ; prepare for argument load
  186.     push    es
  187.     push    di
  188.     push    si        ; save registers as required by Aztec C.
  189.     mov    cx,6[bx]    ; get length of move
  190.     mov    si,4[bx]    ; ds:si now contains source index
  191.     mov    bx,2[bx]    ; prepare to form es:di
  192.     mov    di,[bx]
  193.     mov    es,2[bx]
  194.     rep    movsb        ; move the data
  195.     pop    si
  196.     pop    di
  197.     pop    es
  198.     ret            ; restore registers and exit
  199. lstor_    endp
  200.  
  201. ;
  202. ; -----------------------------------------------------
  203. ;
  204. ; routines which call portable subroutines in llsup.asm
  205. ;
  206. ; -----------------------------------------------------
  207. ;
  208. ; linc(lptr)
  209. ; LPTR *lptr;
  210. ;
  211. ; increment a long pointer by 1
  212. ;
  213.     public    linc_
  214. linc_    proc    near
  215.     extrn    linc:near
  216.     mov    bx,sp        ; prepare for argument load
  217.     push    es        ; save es value from caller
  218.     mov    bx,2[bx]
  219.     push    bx        ; address where answer will go
  220.     mov    es,2[bx]    ; get segment
  221.     mov    bx,[bx]        ; and address
  222.     call    linc        ; do the work
  223.     pop    ax
  224.     xchg    ax,bx
  225.     mov    [bx],ax
  226.     mov    2[bx],es    ; store the value
  227.     pop    es        ; recover the old value
  228.     ret            ; and exit
  229. linc_    endp
  230.  
  231. ;
  232. ; ldec(lptr)
  233. ; LPTR *lptr;
  234. ;
  235. ; decrement a long pointer by 1
  236. ;
  237.     public    ldec_
  238. ldec_    proc    near
  239.     extrn    ldec:near
  240.     mov    bx,sp        ; prepare for argument load
  241.     push    es        ; preserve es
  242.     mov    bx,2[bx]    ; get address ds:bx
  243.     push    bx        ; address where answer will go
  244.     mov    ax,[bx]        ;
  245.     mov    es,2[bx]
  246.     mov    bx,ax
  247.     call    ldec        ; do the decrement
  248.     pop    ax
  249.     xchg    ax,bx
  250.     mov    [bx],ax
  251.     mov    2[bx],es    ; store the value
  252.     pop    es        ; recover it for sake of caller
  253.     ret            ; and then exit
  254. ldec_    endp
  255.  
  256. ;
  257. ; ladd(lptr,offset)
  258. ; LPTR *lptr;
  259. ; unsigned offset;
  260. ;
  261. ; add unsigned offset to a long pointer
  262. ;
  263.     public    ladd_
  264. ladd_    proc    near
  265.     extrn    ladd:near
  266.     mov    bx,sp        ; prepare for argument load
  267.     push    es        ; save es value of caller
  268.     mov    ax,4[bx]    ; get the offset to ax
  269.     mov    bx,2[bx]
  270.     push    bx        ; address where answer will go too.
  271.     mov    cx,[bx]
  272.     mov    es,2[bx]
  273.     mov    bx,cx
  274.     call    ladd        ; do the addition
  275.     pop    ax
  276.     xchg    ax,bx
  277.     mov    [bx],ax
  278.     mov    2[bx],es    ; store the value
  279.     pop    es        ; recover old es value
  280.     ret            ; and then exit
  281. ladd_    endp
  282.  
  283. ;
  284. ; lsub(lptr,offset)
  285. ; LPTR *lptr;
  286. ; unsigned offset;
  287. ;
  288. ; subtract unsigned offset from a long pointer
  289. ;
  290.     public    lsub_
  291. lsub_    proc    near
  292.     extrn    lsub:near
  293.     mov    bx,sp        ; prepare for argument load
  294.     push    es        ; preserve es 
  295.     mov    ax,4[bx]    ; get the offset
  296.     mov    bx,2[bx]
  297.     push    bx        ; store answer at this addr. too.
  298.     mov    cx,[bx]
  299.     mov    es,2[bx]
  300.     mov    bx,cx
  301.     call    lsub        ; do the subtraction
  302.     pop    ax
  303.     xchg    ax,bx
  304.     mov    [bx],ax
  305.     mov    2[bx],es    ; store the value
  306.     pop    es        ; restore es
  307.     ret            ; and then exit
  308. lsub_    endp
  309.  
  310. ;
  311. ; lsum(lptr,offset)
  312. ; LPTR *lptr;
  313. ; int offset;
  314. ;
  315. ; add signed offset to a long pointer
  316. ;
  317.     public    lsum_
  318. lsum_    proc    near
  319.     extrn    lsum:near
  320.     mov    bx,sp        ; prepare for argument load
  321.     push    es        ; preserve caller's es
  322.     mov    ax,4[bx]    ; get the signed offset
  323.     mov    bx,2[bx]
  324.     push    bx
  325.     mov    cx,[bx]
  326.     mov    es,2[bx]
  327.     mov    bx,cs
  328.     call    lsum        ; do the signed addition
  329.     pop    ax
  330.     xchg    ax,bx
  331.     mov    [bx],ax
  332.     mov    2[bx],es    ; store the value
  333.     pop    es        ;
  334.     ret            ; exit.
  335. lsum_    endp
  336.  
  337. ;
  338. ; lcopy(dest,src,len)
  339. ; LPTR *dest;
  340. ; LPTR *src;
  341. ; long len;    (treated as a long unsigned quantity)
  342. ;
  343. ;     copy from src to dest, len bytes.
  344. ;
  345. ; note this routine can be used to copy arbitrarily large chunks of memory
  346. ;
  347.     public    lcopy_
  348. lcopy_    proc    near
  349.     extrn    lcopy:near
  350.     mov    bx,sp        ; prepare for argument load
  351.     push    ds
  352.     push    es        ; save segment registers
  353.     push    di
  354.     push    si        ; save these registers for Aztec C
  355.     ;
  356.     mov    cx,6[bx]    ; get length (low order)
  357.     mov    dx,8[bx]    ; high order of length
  358.     mov    ax,2[bx]    ; get ds:ax as pointer to dest.
  359.     xchg    ax,bx
  360.     mov    di,[bx]
  361.     mov    es,2[bx]
  362.     mov    bx,ax
  363.     mov    bx,4[bx]    ; get ds:bx as pointer for dest.
  364.     mov    si,[bx]
  365.     mov    ds,2[bx]    ; get long pointer
  366.     ;
  367.     call    lcopy
  368.     ;
  369.     pop    si
  370.     pop    di
  371.     pop    es
  372.     pop    ds
  373.     ret
  374. lcopy_    endp    
  375.  
  376. cseg    ends
  377.     end
  378.