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