home *** CD-ROM | disk | FTP | other *** search
/ ftp.freefriends.org / ftp.freefriends.org.tar / ftp.freefriends.org / arnold / Source / mush.rstevens.tar.gz / mush.tar / Patch.solaris.bsdi < prev    next >
Text File  |  1994-07-09  |  22KB  |  810 lines
  1. *** execute.c    Tue Mar 31 16:03:47 1992
  2. --- ../mush-7.2.5/execute.c    Sun Jun 12 16:44:12 1994
  3. ***************
  4. *** 1,7 ****
  5.   /* execute.c     (c) copyright    10/28/86 (Dan Heller) */
  6.   
  7.   #include "mush.h"
  8. ! #if defined(BSD) || defined(IRIX4)
  9.   #include <sys/wait.h>
  10.   #else
  11.   #ifndef SYSV
  12. --- 1,7 ----
  13.   /* execute.c     (c) copyright    10/28/86 (Dan Heller) */
  14.   
  15.   #include "mush.h"
  16. ! #if defined(BSD) || defined(IRIX4) || defined(POSIX)
  17.   #include <sys/wait.h>
  18.   #else
  19.   #ifndef SYSV
  20. ***************
  21. *** 88,98 ****
  22.   execute(argv)
  23.   char **argv;
  24.   {
  25. ! #ifdef SYSV
  26.       int status;
  27.   #else
  28.       union wait status;
  29. ! #endif /* SYSV */
  30.   #ifdef SIGCONT
  31.       SIGRET (*oldstop)(), (*oldcont)();
  32.   #endif /* SIGCONT */
  33. --- 88,98 ----
  34.   execute(argv)
  35.   char **argv;
  36.   {
  37. ! #if defined(SYSV) || defined(POSIX) || defined (BSD44)
  38.       int status;
  39.   #else
  40.       union wait status;
  41. ! #endif /* SYSV || POSIX || BSD44 */
  42.   #ifdef SIGCONT
  43.       SIGRET (*oldstop)(), (*oldcont)();
  44.   #endif /* SIGCONT */
  45. ***************
  46. *** 142,154 ****
  47.   SIGRET
  48.   sigchldcatcher()
  49.   {
  50. ! #ifdef SYSV
  51.       int status;
  52.   #else
  53.       union wait status;
  54. ! #endif /* SYSV */
  55.       int       pid;
  56.   
  57.   #if defined(BSD) || defined(IRIX4)
  58.       while ((pid = wait3(&status, WNOHANG, (struct rusage *)0)) > 0) {
  59.       Debug("%d died...\n", pid);
  60. --- 142,161 ----
  61.   SIGRET
  62.   sigchldcatcher()
  63.   {
  64. ! #if defined(SYSV) || defined(POSIX) || defined(BSD44)
  65.       int status;
  66.   #else
  67.       union wait status;
  68. ! #endif /* SYSV || POSIX || BSD44 */
  69.       int       pid;
  70.   
  71. + #ifdef POSIX /* this could probably be done smarter */
  72. +     while ((pid = waitpid(-1,&status, WNOHANG)) > 0) {
  73. +     Debug("%d died...\n", pid);
  74. +     if (pid == exec_pid)
  75. +         break;
  76. +     }
  77. + #else
  78.   #if defined(BSD) || defined(IRIX4)
  79.       while ((pid = wait3(&status, WNOHANG, (struct rusage *)0)) > 0) {
  80.       Debug("%d died...\n", pid);
  81. ***************
  82. *** 164,169 ****
  83. --- 171,177 ----
  84.       Debug("%d died...\n", pid);
  85.   #endif /* SYSV */
  86.   #endif /* BSD || IRIX4 */
  87. + #endif /* POSIX */
  88.       if (pid == exec_pid && pid > 0) {
  89.       exec_pid = 0;
  90.       longjmp(execjbuf, 1);
  91. *** glob.c    Thu May  3 14:40:15 1990
  92. --- ../mush-7.2.5/glob.c    Mon Jun 13 10:15:41 1994
  93. ***************
  94. *** 340,345 ****
  95. --- 340,436 ----
  96.   }
  97.   
  98.   /*
  99. +  * Match a pattern set {s1,s2,...} followed by any other pattern.
  100. +  * Pattern sets and other patterns may nest arbitrarily.
  101. +  *
  102. +  * If "mat" is not a null pointer, a vector of possible expansions
  103. +  * is generated and placed in *mat; otherwise, the expansions are
  104. +  * matched against str and a truth value is returned ("/" is NOT
  105. +  * treated as a directory separator in this case).  NOTE: The vector
  106. +  * of expansions may still contain nested pattern sets, which must
  107. +  * be expanded separately.  See sxp().
  108. +  *
  109. +  * Currently allows at most 256 alternatives per set.  Enough? :-)
  110. +  */
  111. + static
  112. + sglob(str, pato, mat)
  113. + char *str, *pato, ***mat;
  114. + {
  115. +     char *p, *newpat[256], *oldpat[256], buf[MAXPATHLEN], *b = buf;
  116. +     int copy = 1, nest = 0, i = 0, ret = 0;
  117. +     char *pat,*pat2;
  118. + 
  119. +     if (!pato || !str)
  120. +     return FALSE;
  121. +     pat2 = savestr(pato);
  122. +     if (!pat2)
  123. +     return FALSE;
  124. +     pat = pat2;
  125. +     while (*pat) {
  126. +     if (copy)
  127. +         if (*pat != '{') /*}*/ {
  128. +         if (*pat == '\\' && pat[1])
  129. +             *b++ = *pat++;
  130. +         *b++ = *pat++;
  131. +         continue;
  132. +         } else {
  133. +         copy = 0;
  134. +         pat++;
  135. +         }
  136. +     p = pat;
  137. +     while (*pat && (nest || *pat != ',' && /*{*/ *pat != '}')) {
  138. +         if (*pat == '\\')
  139. +         pat++;
  140. +         else if (*pat == '{')
  141. +         nest++;
  142. +         else if (*pat == '}')
  143. +         nest--;
  144. +         if (*pat)
  145. +         pat++;
  146. +     }
  147. +     if (*pat) {
  148. +         oldpat[i] = pat;
  149. +         newpat[i++] = p;
  150. +         if (*pat != ',') {
  151. +         *pat++ = 0;
  152. +         break;
  153. +         } else
  154. +         *pat++ = 0;
  155. +     }
  156. +     }
  157. +     oldpat[i] = NULL;
  158. +     if (i > 0 && mat) {
  159. +     *mat = (char **)malloc((unsigned)((i + 1) * sizeof(char *)));
  160. +     if (*mat)
  161. +         (*mat)[i] = NULL;
  162. +     else{
  163. +         xfree(pat2);
  164. +         return -1;
  165. +       }
  166. +     ret = i;
  167. +     }
  168. +     while (!mat && i-- > 0)
  169. +     if (ret = glob2(str, newpat[i], pat))
  170. +         break;
  171. +     for (i = 0; oldpat[i]; i++) {
  172. +     if (mat && *mat) {
  173. +         (void) sprintf(b, "%s%s", newpat[i], pat);
  174. +         (*mat)[i] = savestr(buf);
  175. +     }
  176. +     if (oldpat[i + 1])
  177. +         oldpat[i][0] = ',';
  178. +     else
  179. +         oldpat[i][0] = /*{*/ '}';
  180. +     }
  181. +     if (ret == 0 && b > buf && mat) {
  182. +     *b = 0;
  183. +     ret = ((*mat = unitv(buf)) ? 1 : -1);
  184. +     }
  185. +     xfree(pat2);
  186. +     return ret;
  187. + }
  188. + 
  189. + /*
  190.    * The basic globbing matcher.
  191.    *
  192.    * "*"           = match 0 or more occurances of anything
  193. ***************
  194. *** 434,523 ****
  195.       while (*pat == '*')
  196.       pat++;
  197.       return ((*str == '\0') && (*pat == '\0'));
  198. - }
  199. - 
  200. - /*
  201. -  * Match a pattern set {s1,s2,...} followed by any other pattern.
  202. -  * Pattern sets and other patterns may nest arbitrarily.
  203. -  *
  204. -  * If "mat" is not a null pointer, a vector of possible expansions
  205. -  * is generated and placed in *mat; otherwise, the expansions are
  206. -  * matched against str and a truth value is returned ("/" is NOT
  207. -  * treated as a directory separator in this case).  NOTE: The vector
  208. -  * of expansions may still contain nested pattern sets, which must
  209. -  * be expanded separately.  See sxp().
  210. -  *
  211. -  * Currently allows at most 256 alternatives per set.  Enough? :-)
  212. -  */
  213. - static
  214. - sglob(str, pat, mat)
  215. - char *str, *pat, ***mat;
  216. - {
  217. -     char *p, *newpat[256], *oldpat[256], buf[MAXPATHLEN], *b = buf;
  218. -     int copy = 1, nest = 0, i = 0, ret = 0;
  219. - 
  220. -     if (!pat)
  221. -     return FALSE;
  222. - 
  223. -     while (*pat) {
  224. -     if (copy)
  225. -         if (*pat != '{') /*}*/ {
  226. -         if (*pat == '\\' && pat[1])
  227. -             *b++ = *pat++;
  228. -         *b++ = *pat++;
  229. -         continue;
  230. -         } else {
  231. -         copy = 0;
  232. -         pat++;
  233. -         }
  234. -     p = pat;
  235. -     while (*pat && (nest || *pat != ',' && /*{*/ *pat != '}')) {
  236. -         if (*pat == '\\')
  237. -         pat++;
  238. -         else if (*pat == '{')
  239. -         nest++;
  240. -         else if (*pat == '}')
  241. -         nest--;
  242. -         if (*pat)
  243. -         pat++;
  244. -     }
  245. -     if (*pat) {
  246. -         oldpat[i] = pat;
  247. -         newpat[i++] = p;
  248. -         if (*pat != ',') {
  249. -         *pat++ = 0;
  250. -         break;
  251. -         } else
  252. -         *pat++ = 0;
  253. -     }
  254. -     }
  255. -     oldpat[i] = NULL;
  256. -     if (i > 0 && mat) {
  257. -     *mat = (char **)malloc((unsigned)((i + 1) * sizeof(char *)));
  258. -     if (*mat)
  259. -         (*mat)[i] = NULL;
  260. -     else
  261. -         return -1;
  262. -     ret = i;
  263. -     }
  264. -     while (!mat && i-- > 0)
  265. -     if (ret = glob2(str, newpat[i], pat))
  266. -         break;
  267. -     for (i = 0; oldpat[i]; i++) {
  268. -     if (mat && *mat) {
  269. -         (void) sprintf(b, "%s%s", newpat[i], pat);
  270. -         (*mat)[i] = savestr(buf);
  271. -     }
  272. -     if (oldpat[i + 1])
  273. -         oldpat[i][0] = ',';
  274. -     else
  275. -         oldpat[i][0] = /*{*/ '}';
  276. -     }
  277. -     if (ret == 0 && b > buf && mat) {
  278. -     *b = 0;
  279. -     ret = ((*mat = unitv(buf)) ? 1 : -1);
  280. -     }
  281. -     return ret;
  282.   }
  283.   
  284.   /*
  285. --- 525,530 ----
  286. *** hdrs.c    Fri Oct 30 13:55:32 1992
  287. --- ../mush-7.2.5/hdrs.c    Sun Jun 12 15:37:34 1994
  288. ***************
  289. *** 672,679 ****
  290.       if (!unscramble_addr(p, line)) { /* p is safely recopied to line */
  291.           p2 = addr;
  292.           goto BrokenFrom;
  293. !     } else
  294.           p2 = NULL;
  295.   #else /* MSG_SEPARATOR */
  296.       wprint("Warning: unable to find who msg %d is from!\n", n+1);
  297.       p2 = addr;
  298. --- 672,681 ----
  299.       if (!unscramble_addr(p, line)) { /* p is safely recopied to line */
  300.           p2 = addr;
  301.           goto BrokenFrom;
  302. !     } else {
  303. !         p = line;
  304.           p2 = NULL;
  305. +     }
  306.   #else /* MSG_SEPARATOR */
  307.       wprint("Warning: unable to find who msg %d is from!\n", n+1);
  308.       p2 = addr;
  309. *** loop.c    Fri Oct 30 13:55:35 1992
  310. --- ../mush-7.2.5/loop.c    Tue Jun 21 09:13:58 1994
  311. ***************
  312. *** 936,958 ****
  313.   register char *str;
  314.   int *argc;
  315.   {
  316. !     register char    *s = NULL, *p;
  317.       register int    tmp, err = 0, unq_sep = 0;
  318.       char        *newargv[MAXARGS], **argv, *p2, c, buf[BUFSIZ];
  319.   
  320.       if (debug > 3)
  321. !     (void) printf("Working on: %s\n",str);
  322.       /* If final is true, do variable expansions first */
  323.       if (final) {
  324. !     (void) strcpy(buf, str);
  325. !     str = buf;
  326. !     if (!variable_expand(str))
  327.           return DUBL_NULL;
  328.       }
  329.       *argc = 0;
  330. !     while (*str && *argc < MAXARGS) {
  331. !     while (isspace(*str))
  332. !         ++str;
  333.       /* When we have hit an unquoted `;', final must be true,
  334.        * so we're finished.  Stuff the rest of the string at the
  335.        * end of the argv -- do_command will pass it back later,
  336. --- 936,961 ----
  337.   register char *str;
  338.   int *argc;
  339.   {
  340. !     register char    *s = NULL, *p,*str1;
  341.       register int    tmp, err = 0, unq_sep = 0;
  342.       char        *newargv[MAXARGS], **argv, *p2, c, buf[BUFSIZ];
  343.   
  344. +     if((str1=savestr(str)) == NULL)
  345. +       return DUBL_NULL;;
  346.       if (debug > 3)
  347. !     (void) printf("Working on: %s\n",str1);
  348.       /* If final is true, do variable expansions first */
  349.       if (final) {
  350. !     (void) strcpy(buf, str1);
  351. !     free(str1);
  352. !     str1 = buf;
  353. !     if (!variable_expand(str1))
  354.           return DUBL_NULL;
  355.       }
  356.       *argc = 0;
  357. !     while (*str1 && *argc < MAXARGS) {
  358. !     while (isspace(*str1))
  359. !         ++str1;
  360.       /* When we have hit an unquoted `;', final must be true,
  361.        * so we're finished.  Stuff the rest of the string at the
  362.        * end of the argv -- do_command will pass it back later,
  363. ***************
  364. *** 961,1014 ****
  365.        * loop, so unq_sep should always be initialized to 0.
  366.        */
  367.       if (unq_sep && s && *s == ';') {
  368. !         if (*str) { /* Don't bother saving a null string */
  369.           newargv[*argc] = savestr(str);
  370.           (*argc)++;
  371.           }
  372.           break;
  373.       }
  374. !     if (*str) {        /* found beginning of a word */
  375.           unq_sep = 0;    /* innocent until proven guilty */
  376. !         s = p = str;
  377.           do  {
  378.           if (p - s >= sizeof buf-1) {
  379.               print("argument list too long.\n");
  380.               return DUBL_NULL;
  381.           }
  382. !         if (*str == ';' || *str == '|')
  383.               unq_sep = final; /* Mark an unquoted separator */
  384. !         if ((*p = *str++) == '\\') {
  385. !             if (final && (*str == ';' || *str == '|'))
  386.               --p; /* Back up to overwrite the backslash */
  387. !             if (*++p = *str) /* assign and compare to NUL */
  388. !             str++;
  389.               continue;
  390.           }
  391.           if (p2 = index("\"'", *p)) {
  392.               register char c2 = *p2;
  393.               /* you can't escape quotes inside quotes of the same type */
  394. !             if (!(p2 = index(str, c2))) {
  395.               if (final)
  396.                   print("Unmatched %c.\n", c2);
  397.               err++;
  398. !             p2 = str;
  399.               }
  400.               /* This is the intent of the following loop:
  401. !              *  tmp = (int)(p2 - str) + 1;
  402. !              *  (void) strncpy(p + !final, str, tmp);
  403.                * The strncpy() can't be used directly because
  404.                * it may be overlapping, which fails sometimes.
  405.                */
  406.               /* copy up to and including quote */
  407. !             for (tmp = 0; tmp < (int)(p2 - str) + 1; tmp++)
  408. !             p[tmp+!final] = str[tmp];
  409.               p += tmp - 2 * !!final; /* change final to a boolean */
  410. !             if (*(str = p2))
  411. !             str++;
  412.           }
  413. !         } while (++p, *str && (!isdelimeter(*str) || str[-1] == '\\'));
  414. !         if (c = *str) /* set c = *str, check for null */
  415. !         str++;
  416.           *p = 0;
  417.           if (*s) {
  418.           /* To differentiate real separators from quoted or
  419. --- 964,1018 ----
  420.        * loop, so unq_sep should always be initialized to 0.
  421.        */
  422.       if (unq_sep && s && *s == ';') {
  423. !         if (*str1) { /* Don't bother saving a null string */
  424.           newargv[*argc] = savestr(str);
  425.           (*argc)++;
  426.           }
  427.           break;
  428.       }
  429. !     if (*str1) {        /* found beginning of a word */
  430.           unq_sep = 0;    /* innocent until proven guilty */
  431. !         s = p = str1;
  432.           do  {
  433.           if (p - s >= sizeof buf-1) {
  434.               print("argument list too long.\n");
  435. +             free(str1);
  436.               return DUBL_NULL;
  437.           }
  438. !         if (*str1 == ';' || *str1 == '|')
  439.               unq_sep = final; /* Mark an unquoted separator */
  440. !         if ((*p = *str1++) == '\\') {
  441. !             if (final && (*str1 == ';' || *str1 == '|'))
  442.               --p; /* Back up to overwrite the backslash */
  443. !             if (*++p = *str1) /* assign and compare to NUL */
  444. !             str1++;
  445.               continue;
  446.           }
  447.           if (p2 = index("\"'", *p)) {
  448.               register char c2 = *p2;
  449.               /* you can't escape quotes inside quotes of the same type */
  450. !             if (!(p2 = index(str1, c2))) {
  451.               if (final)
  452.                   print("Unmatched %c.\n", c2);
  453.               err++;
  454. !             p2 = str1;
  455.               }
  456.               /* This is the intent of the following loop:
  457. !              *  tmp = (int)(p2 - str1) + 1;
  458. !              *  (void) strncpy(p + !final, str1, tmp);
  459.                * The strncpy() can't be used directly because
  460.                * it may be overlapping, which fails sometimes.
  461.                */
  462.               /* copy up to and including quote */
  463. !             for (tmp = 0; tmp < (int)(p2 - str1) + 1; tmp++)
  464. !             p[tmp+!final] = str1[tmp];
  465.               p += tmp - 2 * !!final; /* change final to a boolean */
  466. !             if (*(str1 = p2))
  467. !             str1++;
  468.           }
  469. !         } while (++p, *str1 && (!isdelimeter(*str1) || str1[-1] == '\\'));
  470. !         if (c = *str1) /* set c = *str, check for null */
  471. !         str1++;
  472.           *p = 0;
  473.           if (*s) {
  474.           /* To differentiate real separators from quoted or
  475. ***************
  476. *** 1031,1041 ****
  477.           *p = c;
  478.       }
  479.       }
  480. !     if (!*argc)
  481.       return DUBL_NULL;
  482.       /* newargv[*argc] = NULL; */
  483.       if (!(argv = (char **)calloc((unsigned)((*argc)+1), sizeof(char *)))) {
  484.       perror("mk_argv: calloc");
  485.       return DUBL_NULL;
  486.       }
  487.       for (tmp = 0; tmp < *argc; tmp++)
  488. --- 1035,1048 ----
  489.           *p = c;
  490.       }
  491.       }
  492. !     if (!*argc){
  493. !         free(str1);
  494.       return DUBL_NULL;
  495. +       }
  496.       /* newargv[*argc] = NULL; */
  497.       if (!(argv = (char **)calloc((unsigned)((*argc)+1), sizeof(char *)))) {
  498.       perror("mk_argv: calloc");
  499. +     free(str1);
  500.       return DUBL_NULL;
  501.       }
  502.       for (tmp = 0; tmp < *argc; tmp++)
  503. ***************
  504. *** 1044,1049 ****
  505. --- 1051,1057 ----
  506.       *argc = -1;
  507.       else if (debug > 3)
  508.       (void) printf("Made argv: "), print_argv(argv);
  509. +     free(str1);
  510.       return argv;
  511.   }
  512.   
  513. *** mail.c    Fri Oct 30 13:55:36 1992
  514. --- ../mush-7.2.5/mail.c    Sun Jun 12 16:51:46 1994
  515. ***************
  516. *** 19,25 ****
  517.   static int killme;
  518.   static u_long flags;
  519.   static SIGRET (*oldterm)(), (*oldint)(), (*oldquit)();
  520. ! static int finish_up_letter(), send_it(), start_file();
  521.   static long add_headers();
  522.   static jmp_buf cntrl_c_buf;
  523.   static char *Hfile, *edfile;
  524. --- 19,25 ----
  525.   static int killme;
  526.   static u_long flags;
  527.   static SIGRET (*oldterm)(), (*oldint)(), (*oldquit)();
  528. ! static int finish_up_letter(), send_it(), start_file(), mail_someone();
  529.   static long add_headers();
  530.   static jmp_buf cntrl_c_buf;
  531.   static char *Hfile, *edfile;
  532. *** /dev/null    Tue Jun 21 08:40:28 1994
  533. --- ../mush-7.2.5/makefile.bsdi    Tue Jun 21 11:02:03 1994
  534. ***************
  535. *** 0 ****
  536. --- 1,74 ----
  537. + # makefile.bsdi 
  538. + #
  539. + HDRS= mush.h config.h-dist strings.h bindings.h options.h version.h glob.h pop.h
  540. + 
  541. + SRCS= main.c init.c misc.c mail.c hdrs.c execute.c commands.c print.c dates.c \
  542. +       signals.c setopts.c msgs.c pick.c sort.c expr.c folders.c \
  543. +       loop.c viewopts.c curses.c curs_io.c bind.c file.c strings.c \
  544. +       lock.c macros.c options.c addrs.c malloc.c glob.c command2.c \
  545. +       pop.c pmush.c xcreat.c 
  546. + OBJS= main.o init.o misc.o mail.o hdrs.o execute.o commands.o print.o file.o \
  547. +       signals.o setopts.o msgs.o pick.o sort.o expr.o strings.o \
  548. +       folders.o dates.o loop.o viewopts.o curses.o curs_io.o bind.o \
  549. +       lock.o macros.o options.o addrs.o malloc.o glob.o command2.o \
  550. +       pop.o pmush.o xcreat.o 
  551. + 
  552. + HELP_FILES= README README-7.0 README-7.1 README-7.2.0 README-7.2.2 \
  553. +     README-7.2.4 mush.1 cmd_help Mushrc Mailrc Gnurc \
  554. +     sample.mushrc advanced.mushrc digestify
  555. + 
  556. + MAKES= makefile.bsdi makefile.bsd makefile.xenix makefile.sys.v makefile.hpux makefile.sun makefile.solaris
  557. + 
  558. + CFLAGS= -g -DCURSES -DBSD -DSIGRET=void -DBSD44 
  559. + LDFLAGS= -g
  560. + LINTFLAGS= -bxah -Dlint -DCURSES -DBSD
  561. + LIBS= -lcurses -ltermlib -lcompat
  562. + OTHERLIBS=
  563. + # Use some variant of this one if you #define MMDF in config.h
  564. + #OTHERLIBS=/usr/src/mmdf/lib/libmmdf.a
  565. + 
  566. + mush: $(OBJS)
  567. +     @echo loading...
  568. +     @$(CC) $(LDFLAGS) $(OBJS) $(LIBS) $(OTHERLIBS) -o mush
  569. + 
  570. + $(OBJS): config.h mush.h
  571. + loop.o: version.h
  572. + 
  573. + tape:
  574. +     @tar cv $(MAKES) $(HDRS) $(SRCS) $(HELP_FILES)
  575. + 
  576. + tar:
  577. +     @tar fcv MUSH $(MAKES) $(HDRS) $(SRCS) $(HELP_FILES)
  578. + 
  579. + tarmail:
  580. +     tar fcv - $(MAKES) $(HDRS) $(SRCS) $(HELP_FILES) | \
  581. +     compress | btoa > mush.tarmail
  582. + 
  583. + lint:
  584. +     lint $(LINTFLAGS) $(SRCS)
  585. + 
  586. + clean:
  587. +     rm -f *.o core mush
  588. + 
  589. + BINDIR= /usr/local/bin
  590. + LIBDIR= /usr/local/lib
  591. + MRCDIR= /usr/share/misc
  592. + MANDIR= /usr/local/man/man1
  593. + MANEXT= 1
  594. + 
  595. + install: mush
  596. +     mv mush $(BINDIR)
  597. +     strip $(BINDIR)/mush
  598. +     chmod 0755 $(BINDIR)/mush
  599. +     cp mush.1 $(MANDIR)/mush.$(MANEXT)
  600. +     chmod 0644 $(MANDIR)/mush.$(MANEXT)
  601. +     cp cmd_help $(LIBDIR)
  602. +     chmod 0644 $(LIBDIR)/cmd_help
  603. +     cp Mushrc $(MRCDIR)/Mushrc
  604. +     chmod 0644 $(MRCDIR)/Mushrc
  605. + 
  606. + 
  607. + glob: glob.c
  608. +     $(CC) $(CFLAGS) -DTEST -DTEST2 glob.c $(LIBS) $(OTHERLIBS) -o glob
  609. + 
  610. + 
  611. *** /dev/null    Tue Jun 21 08:40:28 1994
  612. --- ../mush-7.2.5/makefile.solaris    Mon Jun 13 18:38:21 1994
  613. ***************
  614. *** 0 ****
  615. --- 1,65 ----
  616. + #
  617. + # Mush makefile for Solaris with gcc 2.5.8
  618. + #
  619. + CC=gcc
  620. + HDRS1= mush.h config.h
  621. + HDRS2= strings.h options.h
  622. + HDRS3= bindings.h glob.h
  623. + HDRS4= version.h pop.h
  624. + SRCS1= commands.c dates.c execute.c expr.c folders.c \
  625. +     hdrs.c init.c loop.c mail.c main.c misc.c msgs.c pick.c \
  626. +     print.c setopts.c signals.c sort.c viewopts.c options.c lock.c
  627. + SRCS2= bind.c curs_io.c curses.c file.c strings.c macros.c \
  628. +     addrs.c malloc.c command2.c pop.c pmush.c xcreat.c glob.c
  629. + 
  630. + OBJS1= commands.o dates.o execute.o expr.o folders.o \
  631. +     hdrs.o init.o loop.o mail.o main.o misc.o msgs.o pick.o \
  632. +     print.o setopts.o signals.o sort.o viewopts.o options.o lock.o
  633. + OBJS2= bind.o curs_io.o curses.o file.o strings.o macros.o \
  634. +     addrs.o malloc.o command2.o pop.o pmush.o xcreat.o glob.o
  635. + 
  636. + HELP= README README-7.0 README-7.1 README-7.2.0 README-7.2.2 \
  637. +     README-7.2.4 mush.1 cmd_help Mushrc Mailrc Gnurc \
  638. +     sample.mushrc advanced.mushrc digestify
  639. + #
  640. + #
  641. + #
  642. + CFLAGS=     -g -DSYSV -DUSG -DCURSES -DSIGRET=void -DSVR4 -DREGCMP
  643. + LDFLAGS=    -g
  644. + LIBS=         -L/usr/ccs/lib -lcurses -lgen -ltermlib
  645. + OTHERLIBS=
  646. + # Use some variant of this one if you #define MMDF in config.h
  647. + #OTHERLIBS=/usr/src/mmdf/lib/libmmdf.a
  648. + PROG=        mush
  649. + 
  650. + $(PROG): $(OBJS1) $(OBJS2)
  651. +     @echo loading...
  652. +     @$(CC) $(LDFLAGS) $(OBJS1) $(OBJS2) -o $(PROG) $(LIBS) $(OTHERLIBS)
  653. + 
  654. + $(OBJS1): $(HDRS1) $(HDRS2)
  655. + $(OBJS2): $(HDRS1) $(HDRS2) $(HDRS3)
  656. + loop.o: version.h
  657. + 
  658. + BINDIR= /usr/local/bin
  659. + LIBDIR= /usr/local/lib
  660. + MRCDIR= /usr/local/lib
  661. + MANDIR= /usr/local/man/man1
  662. + MANEXT= 1
  663. + 
  664. + install: mush
  665. +     cp mush $(BINDIR)
  666. +     strip $(BINDIR)/mush
  667. +     chmod 0755 $(BINDIR)/mush
  668. +     cp mush.1 $(MANDIR)/mush.$(MANEXT)
  669. +     chmod 0644 $(MANDIR)/mush.$(MANEXT)
  670. +     cp cmd_help $(LIBDIR)
  671. +     chmod 0644 $(LIBDIR)/cmd_help
  672. +     cp Mushrc $(MRCDIR)/Mushrc
  673. +     chmod 0644 $(MRCDIR)/Mushrc
  674. + 
  675. + 
  676. + clean: 
  677. +     rm -f *.o mush
  678. + 
  679. + glob: glob.c
  680. +     $(CC) $(LDFLAGS) $(CFLAGS) -DTEST -DTEST2 glob.c -o glob $(LIBS) $(OTHERLIBS)
  681. *** sort.c    Sun Oct 21 21:25:03 1990
  682. --- ../mush-7.2.5/sort.c    Sun Jun 12 16:53:21 1994
  683. ***************
  684. *** 12,23 ****
  685.   
  686.   static int depth, order, ignore_case;
  687.   static jmp_buf sortbuf;
  688. ! 
  689.   sort(argc, argv, list)
  690.   register int argc;
  691.   register char *argv[], list[];
  692.   {
  693. -     int msg_cmp();
  694.       SIGRET (*oldint)(), (*oldquit)();
  695.       int n, offset = -1, range = 0;
  696.       long curr_msg_off = msg[current_msg].m_offset;
  697. --- 12,22 ----
  698.   
  699.   static int depth, order, ignore_case;
  700.   static jmp_buf sortbuf;
  701. ! static int msg_cmp();
  702.   sort(argc, argv, list)
  703.   register int argc;
  704.   register char *argv[], list[];
  705.   {
  706.       SIGRET (*oldint)(), (*oldquit)();
  707.       int n, offset = -1, range = 0;
  708.       long curr_msg_off = msg[current_msg].m_offset;
  709. *** strings.c    Wed Jul  4 09:26:33 1990
  710. --- ../mush-7.2.5/strings.c    Sat Jul  2 23:47:33 1994
  711. ***************
  712. *** 69,97 ****
  713.   register char *list1, *list2, *delimiters;
  714.   {
  715.       register char *p, c;
  716.       register int found = 0;
  717.   
  718.       if (!list1 || !list2)
  719.       return 0;
  720. ! 
  721. !     if (p = any(list1, delimiters)) {
  722. !     if (p > list1) {
  723.           c = *p; *p = 0;
  724.           /* Check list2 against the first word of list1.
  725.            * Swap places of list2 and list1 to step through list2.
  726.            */
  727. !         found = chk_two_lists(list2, list1, delimiters);
  728.           *p = c;
  729.       }
  730. !     if (found)
  731.           return 1;
  732.       for (p++; *p && index(delimiters, *p); p++)
  733.           ;
  734. !     if (!*p)
  735.           return 0;
  736. !     } else if (!any(list2, delimiters))
  737.       /* Do the trivial case of single words */
  738.       return !lcase_strncmp(list1, list2, -1);
  739.       else
  740.       p = list1;
  741.   
  742. --- 69,114 ----
  743.   register char *list1, *list2, *delimiters;
  744.   {
  745.       register char *p, c;
  746. +     char *list1a;
  747. +     char *list2a;
  748.       register int found = 0;
  749.   
  750.       if (!list1 || !list2)
  751.       return 0;
  752. !     /* duplicate the lists so we can play with them */
  753. !     if ((list1a = savestr(list1)) == NULL)
  754. !       return 0;
  755. !     if ((list2a = savestr(list2)) == NULL){
  756. !       free(list1a);
  757. !       return 0;
  758. !     }
  759. !     if (p = any(list1a, delimiters)) {
  760. !     if (p > list1a) {
  761.           c = *p; *p = 0;
  762.           /* Check list2 against the first word of list1.
  763.            * Swap places of list2 and list1 to step through list2.
  764.            */
  765. !         found = chk_two_lists(list2a, list1a, delimiters);
  766.           *p = c;
  767.       }
  768. !     if (found){
  769. !         free(list1a);
  770. !         free(list2a);
  771.           return 1;
  772. +       }
  773.       for (p++; *p && index(delimiters, *p); p++)
  774.           ;
  775. !     if (!*p){
  776. !         free(list1a);
  777. !         free(list2a);
  778.           return 0;
  779. !       }
  780. !     } else if (!any(list2a, delimiters)){
  781. !         free(list2a);
  782. !     free(list1a);
  783.       /* Do the trivial case of single words */
  784.       return !lcase_strncmp(list1, list2, -1);
  785. +       }
  786.       else
  787.       p = list1;
  788.   
  789. ***************
  790. *** 100,106 ****
  791.        * rest of list1.  This could be more efficient by using a
  792.        * different function to avoid repeating the any() calls.
  793.        */
  794. !     return chk_two_lists(list2, p, delimiters);
  795.   }
  796.   
  797.   bzero(addr, size)
  798. --- 117,126 ----
  799.        * rest of list1.  This could be more efficient by using a
  800.        * different function to avoid repeating the any() calls.
  801.        */
  802. !     found = chk_two_lists(list2a, p, delimiters);
  803. !     free(list2a);
  804. !     free(list1a);
  805. !     return found;
  806.   }
  807.   
  808.   bzero(addr, size)
  809.  
  810.