home *** CD-ROM | disk | FTP | other *** search
/ back2roots/padua / padua.7z / padua / uucp / MPack1_2_1.lha / MPack / src / macpcstr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-01-05  |  6.8 KB  |  372 lines
  1. /* macPCstr.c -- niftyapp library pascal/C combination strings
  2.  *
  3.  * (C) Copyright 1990, 1991 by Christopher J. Newman
  4.  * All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, distribute, and sell this software and its
  7.  * documentation for any purpose is hereby granted without fee, provided that
  8.  * the above copyright notice appear in all copies and that both that
  9.  * copyright notice and this permission notice appear in supporting
  10.  * documentation, and that the name of Christopher J. Newman not be used in
  11.  * advertising or publicity pertaining to distribution of the software without
  12.  * specific, written prior permission.  Christopher J. Newman makes no
  13.  * representations about the suitability of this software for any purpose.  It
  14.  * is provided "as is" without express or implied warranty.
  15.  *
  16.  * CHRISTOPHER J. NEWMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  17.  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT
  18.  * SHALL CHRISTOPHER J. NEWMAN BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  19.  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  20.  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  21.  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  22.  * OF THIS SOFTWARE.
  23.  *
  24.  * Author:    Christopher J. Newman
  25.  * Message:    This is a nifty program.
  26.  *
  27.  *    Created 9/1/88, Assembly Code 6/27/90
  28.  */
  29.  
  30. #ifdef THINK_C
  31. typedef unsigned char PCstr;
  32.  
  33. /* assembler function prototypes */
  34. void PtoPCstrcpy(void);
  35. void CtoPCstrcpy(void);
  36. void PCtoPCstrcpy(void);
  37. void PtoPCstrncpy(void);
  38. void CtoPCstrncpy(void);
  39. void PtoPCstrcat(void);
  40. void CtoPCstrcat(void);
  41. PCstr *PtoPCstr(void);
  42. PCstr *CtoPCstr(void);
  43. void SetPlen(void);
  44. PCstr *longtoPCstr(long);    /* not in assembler */
  45.  
  46. void PtoPCstrcpy( /* PCstr *dest, *src */ )
  47. {
  48.     asm 68000 {
  49.         movea.l    8(sp),a0        ; a0 = src
  50.         movea.l    4(sp),a1        ; a1 = dest
  51.         clr.w    d0
  52.         move.b    (a0),d0
  53.         clr.b    1(a1,d0)
  54.     @loop:
  55.         move.b    (a0)+,(a1)+
  56.         dbf.w    d0,@loop
  57.     }
  58. }
  59.  
  60. void CtoPCstrcpy( /* PCstr *dest, char *src */)
  61. {
  62.     asm 68000 {
  63.         movea.l    8(sp),a0    ; a0 = src
  64.         movea.l    4(sp),a1    ; a1 = dest
  65.         addq.l    #1,a1
  66.         moveq.l    #-1,d0
  67.     @loop:
  68.         addq.w    #1,d0
  69.         move.b    (a0)+,(a1)+
  70.         bne.s    @loop
  71.         movea.l    4(sp),a1    ; a1 = dest
  72.         move.b    d0,(a1)
  73.     }
  74. }
  75.  
  76. void PCtoPCstrcpy( /* PCstr *dest, PCstr *src */)
  77. {
  78.     asm 68000 {
  79.         movea.l    8(sp),a0    ; a0 = src
  80.         movea.l    4(sp),a1    ; a1 = dest
  81.         move.b    (a0)+,(a1)+
  82.     @loop:
  83.         move.b    (a0)+,(a1)+
  84.         bne.s    @loop
  85.     }
  86. }
  87.  
  88. void PtoPCstrncpy( /* PCstr *dest, char *src, short n */)
  89. {
  90.     asm 68000 {
  91.         movea.l    8(sp),a0    ; a0 = src
  92.         movea.l    4(sp),a1    ; a1 = dest
  93.         move.w    12(sp),d0    ; d0 = n
  94.         clr.w    d1
  95.         move.b    (a0)+,d1
  96.         cmp.w    d0,d1
  97.         bcc.s    @skip
  98.         move.w    d1,d0
  99.     @skip:
  100.         move.b    d0,(a1)+
  101.         subq.w    #1,d0
  102.         bcs.s    @exit
  103.     @loop:
  104.         move.b    (a0)+,(a1)+
  105.         dbf        d0,@loop
  106.     @exit:
  107.     }
  108. }
  109.  
  110. void CtoPCstrncpy( /* PCstr *dest, char *src, short n */ )
  111. {
  112.     asm 68000 {
  113.         movea.l    8(sp),a0    ; a0 = src
  114.         movea.l    4(sp),a1    ; a1 = dest
  115.         addq.l    #1,a1
  116.         clr.w    d1
  117.         move.w    12(sp),d0    ; d0 = n
  118.         bra.s    @skip
  119.     @loop:
  120.         addq.w    #1,d1
  121.         move.b    (a0)+,(a1)+
  122.     @skip:
  123.         dbeq.w    d0,@loop
  124.         clr.b    (a1)
  125.         movea.l    4(sp),a1    ; a1 = dest
  126.         move.b    d1,(a1)
  127.     }
  128. }
  129.  
  130. void PtoPCstrcat( /* PCstr *dest, char *src */ )
  131. {
  132.     asm 68000 {
  133.         movea.l    8(sp),a0    ; a0 = src
  134.         movea.l    4(sp),a1    ; a1 = dest
  135.         clr.w    d0
  136.         clr.w    d1
  137.         move.b    (a0)+,d0
  138.         move.b    (a1),d1
  139.         add.b    d0,(a1)
  140.         lea.l    1(a1,d1),a1
  141.         bra.s    @skip
  142.     @loop:
  143.         move.b    (a0)+,(a1)+
  144.     @skip:
  145.         dbf.w    d0,@loop
  146.         clr.b    (a1)
  147.     }
  148. }
  149.  
  150. void CtoPCstrcat( /* PCstr *dest, char *src */ )
  151. {
  152.     asm 68000 {
  153.         movea.l    8(sp),a0    ; a0 = src
  154.         movea.l    4(sp),a1    ; a1 = dest
  155.         clr.w    d0
  156.         move.b    (a1),d0
  157.         lea.l    1(a1,d0),a1
  158.         subq.w    #1,d0
  159.     @loop:
  160.         addq.w    #1,d0
  161.         move.b    (a0)+,(a1)+
  162.         bne.s    @loop
  163.         movea.l    4(sp),a1    ; a1 = dest
  164.         move.b    d0,(a1)
  165.     }
  166. }
  167.  
  168. PCstr *PtoPCstr( /* char *str */ )
  169. {
  170.     asm 68000 {
  171.         movea.l    4(sp),a0    ; a0 = str
  172.         clr.w    d0
  173.         move.b    (a0),d0
  174.         clr.b    1(a0,d0)
  175.         move.l    a0,d0
  176.     }
  177. }
  178.  
  179. PCstr *CtoPCstr( /* char *str */)
  180. {
  181.     asm 68000 {
  182.         movea.l    4(sp),a0    ; a0 = str
  183.         move.b    (a0)+,d0
  184.         lea.l    (a0),a1
  185.     @loop:
  186.         move.b    (a1),d1
  187.         move.b    d0,(a1)+
  188.         move.b    d1,d0
  189.         bne.s    @loop
  190.         move.b    d0,(a1)
  191.         suba.l    a0,a1
  192.         move.l    a1,d0
  193.         move.b    d0,-(a0)
  194.         move.l    a0,d0
  195.     }
  196. }
  197.  
  198. void SetPlen( /* PCstr *pcstr */ )
  199. {
  200.     asm 68000 {
  201.         movea.l    4(sp),a0    ; a0 = str
  202.         lea.l    1(a0),a1
  203.         moveq.l    #-1,d0
  204.     @loop:
  205.         addq.w    #1,d0
  206.     @skip:
  207.         tst.b    (a1)+
  208.         bne.s    @loop
  209.         move.b    d0,(a0)
  210.     }
  211. }
  212. #else
  213. /* C function prototypes in mac_napp.h */
  214. #include "macnapp.h"
  215.  
  216. void PtoPCstrcpy(dest, src)
  217.     register PCstr    *dest;
  218.     register char    *src;
  219. {
  220.     register short    i;
  221.     
  222.     i = Pstrlen(src);
  223.     C(dest)[i] = '\0';
  224.     do {
  225.         *dest++ = *src++;
  226.     } while (i--);
  227. }
  228.  
  229. void CtoPCstrcpy(dest, src)
  230.     register PCstr    *dest;
  231.     register char    *src;
  232. {
  233.     register short    i;
  234.     register char    *cpy;
  235.  
  236.     cpy = C(dest);
  237.     for (i = 0; *cpy++ = *src++; i++);
  238.     *dest = i;
  239. }
  240.  
  241. void PCtoPCstrcpy(dest, src)
  242.     register PCstr    *dest;
  243.     register PCstr    *src;
  244. {
  245.     *dest++ = *src++;
  246.     while (*dest++ = *src++);
  247. }
  248.  
  249. void PtoPCstrncpy(PCstr *dest, char *src, short n)
  250. {
  251.     if (Pstrlen(src) < n) n = Pstrlen(src);
  252.     *dest++ = n;
  253.     src++;
  254.     while (n--) *dest++ = *src++;
  255.     *dest++ = '\0';
  256. }
  257.  
  258. void CtoPCstrncpy(PCstr *dest, char *src, short n)
  259. {
  260.     register char    *tmp;
  261.     register short    i;
  262.     
  263.     tmp = C(dest);
  264.     for (i = 0; n-- && (*tmp++ = *src++); i++);
  265.     *tmp = '\0';
  266.     *dest = i;
  267. }
  268.  
  269. void PtoPCstrcat(dest, src)
  270.     register PCstr    *dest;
  271.     register char    *src;
  272. {
  273.     register short    i;
  274.     register short    j;
  275.     
  276.     i = *dest;
  277.     *dest += (j = (unsigned char) *src++);
  278.     dest += i + 1;
  279.     while (j--) *dest++ = *src++;
  280.     *dest = '\0';
  281. }
  282.  
  283. void CtoPCstrcat(dest, src)
  284.     register PCstr    *dest;
  285.     register char    *src;
  286. {
  287.     register short    i;
  288.     register char    *tmp;
  289.     
  290.     tmp = (char *) dest + (i = *dest) + 1;
  291.     while (*tmp++ = *src++) i++;
  292.     *dest = i;
  293. }
  294.  
  295. PCstr *PtoPCstr(str)
  296.     register char    *str;
  297. {
  298.     SetClen((PCstr*) str);
  299.  
  300.     return ((PCstr*) str);
  301. }
  302.  
  303. PCstr *CtoPCstr(str)
  304.     register char    *str;
  305. {
  306.     register PCstr    i;
  307.     register char    c, d;
  308.     register char    *tmp;
  309.     
  310.     i = 0;
  311.     tmp = str;
  312.     tmp++;
  313.     c = *tmp++;
  314.     do {
  315.         d = *tmp;
  316.         *tmp++ = c;
  317.         i++;
  318.     } while (c = d);
  319.     (*(PCstr*)str) = i;
  320.         
  321.     return ((PCstr*) str);
  322. }
  323.  
  324. void SetPlen(pcstr)
  325.     register PCstr    *pcstr;
  326. {
  327.     register short    i = -1;
  328.     register char    *len = C(pcstr);
  329.     
  330.     do {
  331.         i++;
  332.     } while (*len++);
  333.     
  334.     *pcstr = i;
  335. }
  336. #endif
  337.  
  338. /* simple procedure to convert decimal number of 
  339.  * less than 20 digits to a PC string.
  340.  * Compiling with 68020 option makes this quite a bit more efficient.
  341.  */
  342. PCstr *longtoPCstr(i)
  343.     register long i;
  344. {
  345.     static PCstr               sbuf[21];
  346.     register Boolean           negflag;
  347.     register unsigned long     val, ten = 10;
  348.     register PCstr             *pos = sbuf + sizeof (sbuf) - 1;
  349.     register PCstr             *posst;
  350.  
  351.     *pos = '\0';
  352.     posst = --pos;
  353.     negflag = false;
  354.     val = i;
  355.     if (i < 0) {
  356.         negflag = true;
  357.         val = -i;
  358.     }
  359.     do {
  360.         *pos = (unsigned short) (val % ten) + '0';
  361.         pos--;
  362.     } while (val /= ten);
  363.     if (negflag) {
  364.         *pos = '-';
  365.         pos--;
  366.     }
  367.     *pos = posst - pos;
  368.  
  369.     return (pos);
  370. }
  371.  
  372.