home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 1 / GoldFishApril1994_CD1.img / d1xx / d153 / dme / src / subs.c < prev   
Encoding:
C/C++ Source or Header  |  1987-06-15  |  4.1 KB  |  243 lines
  1.  
  2. /*
  3.  *  SUBS.C
  4.  *
  5.  *    (C)Copyright 1987 by Matthew Dillon, All Rights Reserved
  6.  *
  7.  *  Subroutines.
  8.  */
  9.  
  10. #include "defs.h"
  11.  
  12. /*
  13.  *  Create DME's text icon.
  14.  */
  15.  
  16. makemygadget(gad)
  17. register struct Gadget *gad;
  18. {
  19.     static unsigned long ga[] = {
  20.     0xFFFFFFFF,    /* 32 pixels across */
  21.     0x80FDCBFD,
  22.     0xFFFDDFFD,
  23.     0x80000001,
  24.     0x80DFDDDF,
  25.     0x80000001,
  26.     0xBC0EF00B,
  27.     0x80000001,
  28.     0xBFC00CDD,
  29.     0x80000001,
  30.     0xA00DF00F,
  31.     0x80000001,
  32.     0x80000001,
  33.  
  34.     0x80000001,
  35.     0x80FDCBFD,
  36.     0xFFFDDFFD,
  37.     0x80000001,
  38.     0x80DFDDDF,
  39.     0x80000001,
  40.     0xBC0EF00B,
  41.     0x80000001,
  42.     0xBFC00CDD,
  43.     0x80000001,
  44.     0xA00DF00F,
  45.     0x80000001,
  46.     0xFFFFFFFF
  47.     };
  48.     static struct Image image = {
  49.     0, 0, 20, sizeof(ga)/4/2, 2, (unsigned short *)ga, 3, 0, NULL
  50.     };
  51.     bzero(gad, sizeof(struct Gadget));
  52.     gad->Width = 20;
  53.     gad->Height = sizeof(ga)/4/2 + 1;
  54.     gad->Flags    = GADGIMAGE|GADGHCOMP;
  55.     gad->GadgetType   = BOOLGADGET;
  56.     gad->Activation = RELVERIFY|GADGIMMEDIATE;
  57.     gad->GadgetRender = (APTR)ℑ
  58. }
  59.  
  60. /*
  61.  * return index of first non space.  Returns 0 if no spaces found.
  62.  */
  63.  
  64. firstns(str)
  65. register char *str;
  66. {
  67.     register short i;
  68.  
  69.     for (i = 0; str[i] && str[i] == ' '; ++i);
  70.     if (str[i] == 0)
  71.     i = 0;
  72.     return(i);
  73. }
  74.  
  75. /*
  76.  *  Return index of last non-space, 0 if no spaces.
  77.  */
  78.  
  79. lastns(str)
  80. register char *str;
  81. {
  82.     register short i;
  83.  
  84.     for (i = strlen(str) - 1; i > 0 && str[i] == ' '; --i);
  85.     if (i < 0)
  86.     i = 0;
  87.     return(i);
  88. }
  89.  
  90. /*
  91.  *  Return length of word under cursor
  92.  */
  93.  
  94. wordlen(str)
  95. register char *str;
  96. {
  97.     register short i;
  98.  
  99.     for (i = 0; *str && *str != ' '; ++i, ++str);
  100.     return(i);
  101. }
  102.  
  103. /*
  104.  *  Find the path from some root device to a specific filename (src), and
  105.  *  stick the result in (dest).  If unable to backtrace along directories,
  106.  *  simply copy (src) into (dest)
  107.  *
  108.  *  Returns (1) if able to backtrace, (0) if not.
  109.  */
  110.  
  111. getpath(src, dest)
  112. char *src, *dest;
  113. {
  114.     register long flock, pflock;
  115.     register short len, total;
  116.     register FIB *fib = (FIB *)malloc(sizeof(FIB));
  117.     char c;
  118.  
  119.     dest[0] = 0;
  120.     total = 1;
  121.     flock = Lock(src, ACCESS_READ);
  122.     if (flock == NULL) {                           /* missing file?    */
  123.     for (len = strlen(src); len >= 0; --len) {
  124.         if (src[len] == '/') {
  125.         --len;
  126.         break;
  127.         }
  128.         if (src[len] == ':')
  129.         break;
  130.     }
  131.     if (c = src[len + 1]) {
  132.         strcpy(dest, src+len+2);
  133.         total = strlen(dest)+1;
  134.     }
  135.     src[len + 1] = 0;
  136.     flock = Lock(src, ACCESS_READ);
  137.     src[len + 1] = c;
  138.     }
  139.     if (flock) {
  140.     do {
  141.         pflock = ParentDir(flock);
  142.         if (Examine(flock, fib) == 0)
  143.         fib->fib_FileName[0] = 0;
  144.         if (fib->fib_FileName[0] == 0)
  145.         strcpy(fib->fib_FileName, "ram");
  146.         len = strlen(fib->fib_FileName);
  147.         bmov(dest, dest + len + 1, total);
  148.         dest[len] = (pflock) ? '/' : ':';
  149.         bmov(fib->fib_FileName, dest, len);
  150.         total += len + 1;
  151.         UnLock(flock);
  152.         flock = pflock;
  153.     } while(pflock);
  154.     len = strlen(dest) - 1;
  155.     if (dest[len] == '/')
  156.         dest[len] = 0;
  157.     return(1);
  158.     }
  159.     strcpy(dest, src);
  160.     return(0);
  161. }
  162.  
  163. /*
  164.  *  Allocation routines and other shortcuts
  165.  */
  166.  
  167. ubyte *
  168. allocb(bytes)
  169. {
  170.     return(AllocMem(bytes, MEMF_CLEAR|MEMF_PUBLIC));
  171. }
  172.  
  173. ubyte *
  174. allocl(lwords)
  175. {
  176.     return(AllocMem(lwords<<2, MEMF_CLEAR|MEMF_PUBLIC));
  177. }
  178.  
  179. bmovl(s,d,n)
  180. char *s,*d;
  181. {
  182.     bmov(s,d,n<<2);
  183. }
  184.  
  185. /*
  186.  *  Remove tabs in a buffer
  187.  */
  188.  
  189. detab(ibuf, obuf, maxlen)
  190. register char *ibuf, *obuf;
  191. {
  192.     register short i, j;
  193.  
  194.     maxlen -= 2;
  195.     for (i = j = 0; ibuf[i] && j < maxlen; ++i) {
  196.     if (ibuf[i] == 9) {
  197.         do {
  198.         obuf[j++] = ' ';
  199.         } while ((j & 7) && j < maxlen);
  200.     } else {
  201.         obuf[j++] = ibuf[i];
  202.     }
  203.     }
  204.     while (j && obuf[j-1] == ' ')
  205.     --j;
  206.     obuf[j] = 0;
  207.     return(j);
  208. }
  209.  
  210. xefgets(xfi, buf, max)
  211. char *buf;
  212. long xfi;
  213. {
  214.     char ebuf[256];
  215.     if (xfgets(xfi, ebuf, max) >= 0)
  216.     return(detab(ebuf, buf, max));
  217.     return(-1);
  218. }
  219.  
  220. ncstrcmp(s1, s2)
  221. register ubyte *s1, *s2;
  222. {
  223.     register ubyte c1, c2;
  224.  
  225.     for (;;) {
  226.     c1 = *s1;
  227.     c2 = *s2;
  228.     if (c1 >= 'A' && c1 <= 'Z') c1 |= 0x20;
  229.     if (c2 >= 'A' && c2 <= 'Z') c2 |= 0x20;
  230.     if (c1 != c2)
  231.         break;
  232.     if ((c1|c2) == 0)
  233.         return(0);
  234.     ++s1;
  235.     ++s2;
  236.     }
  237.     if (c1 < c2)
  238.     return(-1);
  239.     if (c1 > c2)
  240.     return(1);
  241. }
  242.  
  243.