home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1992 #27 / NN_1992_27.iso / spool / comp / mail / elm / 3355 < prev    next >
Encoding:
Internet Message Format  |  1992-11-17  |  53.4 KB
  1. Xref: sparky comp.mail.elm:3355 comp.sources.bugs:273
  2. Newsgroups: comp.mail.elm,comp.sources.bugs
  3. Path: sparky!uunet!ukma!cs.widener.edu!dsinc!syd
  4. From: syd@dsinc.DSI.COM (Syd Weinstein)
  5. Subject: elm 2.4 Patch #9
  6. Message-ID: <1992Nov17.191856.8050@DSI.COM>
  7. Followup-To: poster
  8. Summary: This is an official patch for elm 2.4 system.  Please apply it.
  9. Sender: syd@DSI.COM (Syd Weinstein)
  10. Priority: HIGH
  11. Organization: Datacomp Systems, Inc., Huntingdon Valley, PA 19006
  12. Date: Tue, 17 Nov 1992 19:18:56 GMT
  13. Lines: 1977
  14.  
  15. part 1 of a 2 part patch
  16.  
  17. I think that the code in 'newmbox.c' which handles bad 'Content-length'
  18. entries is incomplete. The file-ptr for the mail file is
  19. backed up, but the file-ptr of the temp file WAS LEFT UNMODIFIED !
  20. From langesw.ssw.de!root Wed Nov 11 14:28:57 1992
  21.  
  22. When elm copies the temp mailbox back to the mail spool to resync or
  23. quit, it changes to the mailgroup before attempting to diddle in the
  24. mail spool, but when it copies the temp mailbox back to the mail spool
  25. after editing, it forgets to change to mailgroup.  This patch appears
  26. to work, but I haven't exhaustively checked for some path that leaves
  27. the gid set
  28. wrong.  From: dwolfe@pffft.sps.mot.com (Dave Wolfe)
  29.  
  30. There's an error in two messages in s_aliases.m which causes elm2.4
  31. to core dump when resyncronize aliases. (%s/%s) should be (%c/%c).
  32.  
  33. This bug doesn't show up unless you use message cataloges, since the default
  34. message in a_quit.c is correct.
  35. From: Jan Djarv <Jan.Djarv@sa.erisoft.se>
  36.  
  37. Fix how nls emulation lib gencat links prev pointers
  38. From: Jan Djarv <Jan.Djarv@sa.erisoft.se>
  39.  
  40. The alias message_count isn't set to zero if the last alias has
  41. been deleted from the alias table. As no aliases are reread from
  42. the aliases database the message_count is left as it was before.
  43.  
  44. Fixed that the function do_newalias() sometimes returns without freeing
  45. the buffer allocated before. The patch adds these free calls.
  46.  
  47. When you erroneously type a number in your folder elm asks you for
  48. a new current message number. But now if you erase this one number
  49. and leave the string empty elm will set the new current message to
  50. the second message on our sun4! The patch adds a check for an empty
  51. string and returns the current number if no number was entered.
  52. From: vogt@isa.de (Gerald Vogt)
  53.  
  54. The situation is that the .elm/aliases file is missing, but
  55. .elm/aliases.dir and .elm/aliases.pag exist (isn't serendipity
  56. wonderful?).  The ndbz functions tolerate this and just put a NULL
  57. pointer in the db structure for the data file FILE pointer.  However,
  58. get_one_alias() in listalias and elm doesn't account for the db_open()
  59. succeeding but the dbz_basef field being NULL, so it passes the NULL
  60. pointer to fread().  Detect null and return 0
  61. From: dwolfe@pffft.sps.mot.com (Dave Wolfe)
  62.  
  63. Clear the screen before displaying MIME:
  64. From: marius@rhi.hi.is (Marius Olafsson)
  65.  
  66. Add regexp processing to filter.
  67. Add execc operator
  68. From: Jan Djarv <Jan.Djarv@sa.erisoft.se>
  69.  
  70. Fix:    From rn, say "| patch -p -N -d DIR", where DIR is your elm source
  71.     directory.  Outside of rn, say "cd DIR; patch -p -N <thisarticle".
  72.     If you don't have the patch program, apply the following by hand,
  73.     or get patch (version 2.0, latest patchlevel).
  74.  
  75.     After patching:
  76.         Do nothing, apply patch 10 next
  77.  
  78.     If patch indicates that patchlevel is the wrong version, you may need
  79.     to apply one or more previous patches, or the patch may already
  80.     have been applied.  See the patchlevel.h file to find out what has or
  81.     has not been applied.  In any event, don't continue with the patch.
  82.  
  83.     If you are missing previous patches they can be obtained from our:
  84.     archive server.
  85.  
  86.     Syd Weinstein
  87.     elm@DSI.COM
  88.  
  89.     The patches are available from the dsinc archive server
  90.     Send the following message to archive-server@DSI.COM for
  91.     a list of available patches:
  92.  
  93.     Subject: patch list
  94.     send index elm
  95.  
  96. Index: hdrs/patchlevel.h
  97. Prereq: "8"
  98. *** ../elm2.4/hdrs/patchlevel.h    Tue Nov 10 15:20:28 1992
  99. --- hdrs/patchlevel.h    Sat Nov 14 16:40:24 1992
  100. ***************
  101. *** 1 ****
  102. ! #define PATCHLEVEL "8"
  103. --- 1 ----
  104. ! #define PATCHLEVEL "9"
  105.  
  106. Index: Configure
  107. Prereq: 5.6
  108. *** ../elm2.4/Configure    Tue Oct 27 11:17:21 1992
  109. --- Configure    Tue Nov 17 13:19:52 1992
  110. ***************
  111. *** 8,14 ****
  112.   # and edit it to reflect your system.  Some packages may include samples
  113.   # of config.h for certain machines, so you might look for one of those.)
  114.   #
  115. ! # $Header: /home/syd/elm.rel/RCS/Configure,v 5.6 1992/10/25 02:18:36 syd Exp $
  116.   #
  117.   # Yes, you may rip this off to use in other distribution packages.
  118.   # (Note: this Configure script was generated automatically.  Rather than
  119. --- 8,14 ----
  120.   # and edit it to reflect your system.  Some packages may include samples
  121.   # of config.h for certain machines, so you might look for one of those.)
  122.   #
  123. ! # $Header: /home/syd/elm.rel/RCS/Configure,v 5.9 1992/11/17 18:19:47 syd Exp $
  124.   #
  125.   # Yes, you may rip this off to use in other distribution packages.
  126.   # (Note: this Configure script was generated automatically.  Rather than
  127. ***************
  128. *** 205,210 ****
  129. --- 205,211 ----
  130.   d_termio=''
  131.   d_termios=''
  132.   d_tz_min=''
  133. + d_tzname=''
  134.   d_useembed=''
  135.   d_utimbuf=''
  136.   d_vfork=''
  137. ***************
  138. *** 303,309 ****
  139.   attrlist="$attrlist $mc68k __STDC__ UTS M_I8086 M_I186 M_I286 M_I386"
  140.   attrlist="$attrlist i186 __m88k__ m88k DGUX __DGUX__ NeXT _AIX"
  141.   pth="/bin /usr/bin /usr/ucb /sbin /usr/sbin /usr/local /usr/local/bin /usr/lbin"
  142. ! pth="$pth /usr/5bin /vol/local/bin /etc /usr/bsd /usr/lib /usr/css/lib /lib"
  143.   pth="$pth /usr/local/lib /sys5.3/bin /sys5.3/usr/bin /bsd4.3/bin /bsd4.3/usr/bin /bsd4.3/usr/ucb"
  144.   pth="$pth /usr/convex /usr/mmdf/bin /usr/mmdf/lib ${BSDBASE-/bsd}/usr/ucb ${BSDBASE-/bsd}/bin ${BSDBASE-/bsd}/usr/bin"
  145.   
  146. --- 304,310 ----
  147.   attrlist="$attrlist $mc68k __STDC__ UTS M_I8086 M_I186 M_I286 M_I386"
  148.   attrlist="$attrlist i186 __m88k__ m88k DGUX __DGUX__ NeXT _AIX"
  149.   pth="/bin /usr/bin /usr/ucb /sbin /usr/sbin /usr/local /usr/local/bin /usr/lbin"
  150. ! pth="$pth /usr/5bin /vol/local/bin /etc /usr/bsd /usr/lib /usr/ccs/lib /usr/ccs/bin /lib"
  151.   pth="$pth /usr/local/lib /sys5.3/bin /sys5.3/usr/bin /bsd4.3/bin /bsd4.3/usr/bin /bsd4.3/usr/ucb"
  152.   pth="$pth /usr/convex /usr/mmdf/bin /usr/mmdf/lib ${BSDBASE-/bsd}/usr/ucb ${BSDBASE-/bsd}/bin ${BSDBASE-/bsd}/usr/bin"
  153.   
  154. ***************
  155. *** 798,804 ****
  156.   if $test -f "$uname"; then
  157.       uname_os=`uname -s`
  158.       uname_rel=`uname -r`
  159. !     uname_rel=`expr "$uname" : "\(...\).*"`
  160.   else
  161.       uname_os=unknown
  162.       uname_rel=unknown
  163. --- 799,805 ----
  164.   if $test -f "$uname"; then
  165.       uname_os=`uname -s`
  166.       uname_rel=`uname -r`
  167. !     uname_rel=`expr "$uname_rel" : "\(...\).*"`
  168.   else
  169.       uname_os=unknown
  170.       uname_rel=unknown
  171. ***************
  172. *** 810,816 ****
  173.       echo exit 0 >usg
  174.       echo exit 1 >v7
  175.   elif $contains SIGTSTP foo >/dev/null 2>&1 ; then
  176. !     if $test "$uname_os" = "SunOs" -a "$uname_rel" = "4.1" ; then
  177.       echo "Looks like SunOs 4.1, a USG system, but we'll see..."
  178.       echo exit 1 >bsd
  179.       echo exit 0 >usg
  180. --- 811,817 ----
  181.       echo exit 0 >usg
  182.       echo exit 1 >v7
  183.   elif $contains SIGTSTP foo >/dev/null 2>&1 ; then
  184. !     if $test "(" $uname_os" = "SunOS" -a "$uname_rel" = "4.1")" ; then
  185.       echo "Looks like SunOs 4.1, a USG system, but we'll see..."
  186.       echo exit 1 >bsd
  187.       echo exit 0 >usg
  188. ***************
  189. *** 1405,1411 ****
  190.   
  191.   case "$ccflags" in
  192.   '') case "$cc" in
  193. !     *gcc*) dflt='-fpcc-struct-return';;
  194.       *) dflt='';;
  195.       esac
  196.       ;;
  197. --- 1406,1412 ----
  198.   
  199.   case "$ccflags" in
  200.   '') case "$cc" in
  201. !     *gcc*) dflt='-fpcc-struct-return -traditional';;
  202.       *) dflt='';;
  203.       esac
  204.       ;;
  205. ***************
  206. *** 3700,3705 ****
  207. --- 3701,3710 ----
  208.       d_tz_min="$undef"
  209.   fi
  210.   $rm -f try.c
  211. + : see if there is a tzname
  212. + set tzname d_tzname
  213. + eval $inlibc
  214. + 
  215.   : check for valid reply/to fields
  216.   case "$d_useembed" in
  217.   "$define")    dflt=y;;
  218. ***************
  219. *** 4516,4521 ****
  220. --- 4521,4527 ----
  221.   d_termio='$d_termio'
  222.   d_termios='$d_termios'
  223.   d_tz_min='$d_tz_min'
  224. + d_tzname='$d_tzname'
  225.   d_useembed='$d_useembed'
  226.   d_utimbuf='$d_utimbuf'
  227.   d_vfork='$d_vfork'
  228.  
  229. Index: config.h.SH
  230. *** ../elm2.4/config.h.SH    Tue Oct 27 11:17:22 1992
  231. --- config.h.SH    Sat Nov 14 21:11:40 1992
  232. ***************
  233. *** 496,501 ****
  234. --- 496,506 ----
  235.    */
  236.   #$d_tz_min    TZ_MINUTESWEST     /**/
  237.   
  238. + /* TZNAME:
  239. +  *    This symbol, if defined, indicates that extern char *tzname[] exists.
  240. +  */
  241. + #$d_tzname    TZNAME    /**/
  242. + 
  243.   /* USE_EMBEDDED_ADDRESSES:
  244.    *    This symbol, if defined, indicates that replyto: and from:
  245.    *    headers can be trusted.
  246.  
  247. Index: Instruct
  248. *** ../elm2.4/Instruct    Sat Oct  3 18:12:32 1992
  249. --- Instruct    Sat Nov 14 20:07:24 1992
  250. ***************
  251. *** 1,7 ****
  252.                   Instructions
  253.                   ------------
  254.   
  255. !                 Last Update: $Date: 1992/10/03 22:12:17 $
  256.   
  257.   
  258.       This file contains instructions on how to create and install
  259. --- 1,7 ----
  260.                   Instructions
  261.                   ------------
  262.   
  263. !                 Last Update: $Date: 1992/11/15 01:07:19 $
  264.   
  265.   
  266.       This file contains instructions on how to create and install
  267. ***************
  268. *** 16,22 ****
  269.   
  270.       $ sh Configure
  271.   
  272. !     Answer the questions of that program,, then let it create the
  273.   localized Makefiles and system definition files for you.  When it's
  274.   done you can double check the configuration (or customize it further)
  275.   by reading the Configuration Guide and then rerunning Configure.
  276. --- 16,22 ----
  277.   
  278.       $ sh Configure
  279.   
  280. !     Answer the questions of that program, then let it create the
  281.   localized Makefiles and system definition files for you.  When it's
  282.   done you can double check the configuration (or customize it further)
  283.   by reading the Configuration Guide and then rerunning Configure.
  284.  
  285. Index: MANIFEST
  286. *** ../elm2.4/MANIFEST    Tue Nov 10 15:20:21 1992
  287. --- MANIFEST    Sat Nov 14 20:35:44 1992
  288. ***************
  289. *** 43,48 ****
  290. --- 43,49 ----
  291.   filter/filter.c
  292.   filter/lock.c
  293.   filter/parse.c
  294. + filter/regexp.c
  295.   filter/rules.c
  296.   filter/summarize.c
  297.   filter/utils.c
  298. ***************
  299. *** 59,64 ****
  300. --- 60,66 ----
  301.   hdrs/ndbz.h
  302.   hdrs/nl_types.h
  303.   hdrs/patchlevel.h
  304. + hdrs/regexp.h
  305.   hdrs/s_aliases.h
  306.   hdrs/s_answer.h
  307.   hdrs/s_arepdaem.h
  308.  
  309. Index: README
  310. *** ../elm2.4/README    Tue Nov 10 15:20:21 1992
  311. --- README    Sat Nov 14 20:06:38 1992
  312. ***************
  313. *** 2,8 ****
  314.   
  315.   See the NOTICE and Instruct files for further details.
  316.   
  317. ! It is IMPERITIVE that all users rerun newalias after installing
  318.   Elm 2.4 when upgrading from a previous version.  Elm's behavior
  319.   with aliases could be unpredictible if this step is not performed.
  320.   
  321. --- 2,8 ----
  322.   
  323.   See the NOTICE and Instruct files for further details.
  324.   
  325. ! It is IMPERATIVE that all users rerun newalias after installing
  326.   Elm 2.4 when upgrading from a previous version.  Elm's behavior
  327.   with aliases could be unpredictible if this step is not performed.
  328.   
  329.  
  330. Index: doc/Filter.guid
  331. Prereq: 5.1
  332. *** ../elm2.4/doc/Filter.guid    Sat Oct  3 16:54:23 1992
  333. --- doc/Filter.guid    Sat Nov 14 20:41:50 1992
  334. ***************
  335. *** 1,4 ****
  336. ! .\" @(#)$Id: Filter.guid,v 5.1 1992/10/03 20:51:50 syd Exp $
  337.   .\"
  338.   .\"  A guide to the Elm Filter program
  339.   .\"  format with:
  340. --- 1,4 ----
  341. ! .\" @(#)$Id: Filter.guid,v 5.2 1992/11/15 01:41:50 syd Exp $
  342.   .\"
  343.   .\"  A guide to the Elm Filter program
  344.   .\"  format with:
  345. ***************
  346. *** 12,17 ****
  347. --- 12,22 ----
  348.   .\"    Syd Weinstein        elm@DSI.COM (dsinc!elm)
  349.   .\"
  350.   .\"  $Log: Filter.guid,v $
  351. + .\" Revision 5.2  1992/11/15  01:41:50  syd
  352. + .\" Add regexp processing to filter.
  353. + .\" Add execc operator
  354. + .\" From: Jan Djarv <Jan.Djarv@sa.erisoft.se>
  355. + .\"
  356.   .\" Revision 5.1  1992/10/03  20:51:50  syd
  357.   .\" Initial checkin as of 2.4 Release at PL0
  358.   .\"
  359. ***************
  360. *** 145,150 ****
  361. --- 150,159 ----
  362.   The \f2value\f1 is any quoted string that is to be matched against
  363.   or number if ``lines'' is the field being considered.
  364.   .sp
  365. + The relation ``matches'' (or ``~'') takes an egrep like regular expression 
  366. + as the \f2value\f1. The regular expression must be enclosed in pairs of ``/''.
  367. + If you need a ``/'' in your expression write it as ``\\/''.
  368. + .sp
  369.   Individual conditions are joined together by using the word ``and'',
  370.   and the logic of a condition can be flipped by using ``not'' as the
  371.   first word (e.g. `not subject "joe"').  We'll see more examples of
  372. ***************
  373. *** 162,167 ****
  374. --- 171,177 ----
  375.   forward  \f2address\f1
  376.   forwardc  \f2address\f1
  377.   execute  \f2command\f1
  378. + executec  \f2command\f1
  379.   leave
  380.   .in 0
  381.   .fi
  382. ***************
  383. *** 172,190 ****
  384.   \f3forwardc\f1 sends the message to the specified address and leaves a copy in your mailbox; 
  385.   \f3execute\f1 feeds the message to the specified command (or complex
  386.   sequence of commands) as standard input;
  387.   and \f3leave\f1 leaves the message in your mailbox.
  388.   .sp
  389.   NOTE: The execute command assumes that you are doing something
  390.   useful with incoming mail.  The command does \f2not\f1
  391. ! automatically append the message to your mail spool.  A
  392. ! command such as:
  393.   .sp
  394. !  if (from = "dave") then echo mail from dave > /dev/tty
  395.   .sp
  396.   will result in \f2losing\f1 your mail.  A more suitable
  397.   use for execute would be:
  398.   .sp
  399. !  if (from = "boss") then vacation pat
  400.   .sp
  401.   Foldernames can contain any of a number of macros, too, as we'll see in
  402.   the example ruleset below.  The macros available for the string fields are;
  403. --- 182,201 ----
  404.   \f3forwardc\f1 sends the message to the specified address and leaves a copy in your mailbox; 
  405.   \f3execute\f1 feeds the message to the specified command (or complex
  406.   sequence of commands) as standard input;
  407. + \f3executec\f1 is like \f3execute\f1 but also leaves a copy in your mailbox;
  408.   and \f3leave\f1 leaves the message in your mailbox.
  409.   .sp
  410.   NOTE: The execute command assumes that you are doing something
  411.   useful with incoming mail.  The command does \f2not\f1
  412. ! automatically append the message to your mail spool.  Use executec for that.
  413. ! A command such as:
  414.   .sp
  415. !  if (from = "dave") then execute "echo mail from dave > /dev/tty"
  416.   .sp
  417.   will result in \f2losing\f1 your mail.  A more suitable
  418.   use for execute would be:
  419.   .sp
  420. !  if (from = "boss") then execute "vacation pat"
  421.   .sp
  422.   Foldernames can contain any of a number of macros, too, as we'll see in
  423.   the example ruleset below.  The macros available for the string fields are;
  424. ***************
  425. *** 208,216 ****
  426. --- 219,236 ----
  427.   .zf
  428.   %t    current hour and minute in HH:MM format
  429.   %y    year (last two digits)
  430. + %&    the string that matched the last regular expression
  431. + %1-%9    the i:th subexpression in the last regular expression that matched
  432.   .TE
  433.   .ft 1
  434.   .sp
  435. + If a message has a subject of \f2This is a test\f1, and the rule is
  436. + .sp
  437. + if (subject matches /([a-z]+) a ([a-z]+)/) then "echo %& %1 %2"
  438. + .sp
  439. + then %& expands to \f2is a test\f1, %1 expands to \f2is\f1 and %2 expands to
  440. + \f2test\f1.
  441. + .sp
  442.   Foldernames may contain a leading '~/' which will be expanded to be
  443.   your home directory.
  444.   .sp
  445. ***************
  446. *** 586,599 ****
  447.   .in .5i
  448.   
  449.   .ti -\n(TWu
  450. ! 1. The ability to use regular expressions in the patterns.  
  451. ! This would be a \f2very\f1 nice feature!
  452. ! 
  453. ! .ti -\n(TWu
  454. ! 2. Perhaps more \f2actions\f1 available (but what?)
  455.   
  456.   .ti -\n(TWu
  457. ! 3. Certainly the ability to filter based on any field or combination of
  458.   fields.  
  459.   .in 0
  460.   .ne 5
  461. --- 606,615 ----
  462.   .in .5i
  463.   
  464.   .ti -\n(TWu
  465. ! 1. Perhaps more \f2actions\f1 available (but what?)
  466.   
  467.   .ti -\n(TWu
  468. ! 2. Certainly the ability to filter based on any field or combination of
  469.   fields.  
  470.   .in 0
  471.   .ne 5
  472.  
  473. Index: doc/filter.1
  474. *** ../elm2.4/doc/filter.1    Mon Oct 19 13:04:04 1992
  475. --- doc/filter.1    Sat Nov 14 20:48:08 1992
  476. ***************
  477. *** 58,63 ****
  478. --- 58,64 ----
  479.           \fBsave  \fIfoldername\fR
  480.           \fBsavecopy \fIfoldername\fR
  481.           \fBexecute  \fIcommand\fR
  482. +         \fBexecutec  \fIcommand\fR
  483.           \fBforward  \fIaddress\fR
  484.           \fBleave\fR
  485.   
  486.  
  487. Index: filter/regexp.c
  488. *** /dev/null    Mon Nov 16 22:43:59 1992
  489. --- filter/regexp.c    Mon Nov 16 23:10:02 1992
  490. ***************
  491. *** 0 ****
  492. --- 1,1214 ----
  493. + 
  494. + /* $Id: regexp.c,v 5.4 1992/11/17 18:25:42 syd Exp $ */
  495. + 
  496. + /*******************************************************************************
  497. +  *  The Elm Mail System  -  $Revision: 5.4 $   $State: Exp $
  498. +  *
  499. +  *             Copyright (c) 1992 USENET Community Trust
  500. +  *******************************************************************************
  501. +  * Bug reports, patches, comments, suggestions should be sent to:
  502. +  *
  503. +  *    Syd Weinstein, Elm Coordinator
  504. +  *    elm@DSI.COM            dsinc!elm
  505. +  *
  506. +  *******************************************************************************
  507. +  * $Log: regexp.c,v $
  508. +  * Revision 5.4  1992/11/17  18:25:42  syd
  509. +  * change to use index instead of strchr
  510. +  * From: Syd
  511. +  *
  512. +  * Revision 5.3  1992/11/17  04:10:01  syd
  513. +  * The changes to filter/regexp.c are to correct compiler warnings about
  514. +  * unreachable statements.
  515. +  *
  516. +  * The changes to filter/rules.c are to correct the fact that we are passing
  517. +  * a pointer to a condition_rec structore to a function expecting a pointer to
  518. +  * a character string.
  519. +  * From: Tom Moore <tmoore@fievel.DaytonOH.NCR.COM>
  520. +  *
  521. +  * Revision 5.2  1992/11/15  01:39:31  syd
  522. +  * add proper headers
  523. +  *
  524. +  *
  525. +  ******************************************************************************/
  526. + 
  527. + /*
  528. +  * regcomp and regexec -- regsub and regerror are elsewhere
  529. +  *
  530. +  *    Copyright (c) 1986 by University of Toronto.
  531. +  *    Written by Henry Spencer.  Not derived from licensed software.
  532. +  *
  533. +  *    Permission is granted to anyone to use this software for any
  534. +  *    purpose on any computer system, and to redistribute it freely,
  535. +  *    subject to the following restrictions:
  536. +  *
  537. +  *    1. The author is not responsible for the consequences of use of
  538. +  *        this software, no matter how awful, even if they arise
  539. +  *        from defects in it.
  540. +  *
  541. +  *    2. The origin of this software must not be misrepresented, either
  542. +  *        by explicit claim or by omission.
  543. +  *
  544. +  *    3. Altered versions must be plainly marked as such, and must not
  545. +  *        be misrepresented as being the original software.
  546. +  *
  547. +  * Beware that some of this code is subtly aware of the way operator
  548. +  * precedence is structured in regular expressions.  Serious changes in
  549. +  * regular-expression syntax might require a total rethink.
  550. +  */
  551. + 
  552. + /*
  553. +  * Altered by Jan D. (Jan.Djarv@sa.erisoft.se) for use in elm:s filter
  554. +  */
  555. + #include "defs.h"
  556. + #include "regexp.h"
  557. + #include <stdio.h>
  558. + 
  559. + /* #include "regmagic.h" -- Inlined here (next 5 lines) */
  560. + /*
  561. +  * The first byte of the regexp internal "program" is actually this magic
  562. +  * number; the start node begins in the second byte.
  563. +  */
  564. + #define    MAGIC    0234
  565. + 
  566. + /*
  567. +  * The "internal use only" fields in regexp.h are present to pass info from
  568. +  * compile to execute that permits the execute phase to run lots faster on
  569. +  * simple cases.  They are:
  570. +  *
  571. +  * regstart    char that must begin a match; '\0' if none obvious
  572. +  * reganch    is the match anchored (at beginning-of-line only)?
  573. +  * regmust    string (pointer into program) that match must include, or NULL
  574. +  * regmlen    length of regmust string
  575. +  *
  576. +  * Regstart and reganch permit very fast decisions on suitable starting points
  577. +  * for a match, cutting down the work a lot.  Regmust permits fast rejection
  578. +  * of lines that cannot possibly match.  The regmust tests are costly enough
  579. +  * that regcomp() supplies a regmust only if the r.e. contains something
  580. +  * potentially expensive (at present, the only such thing detected is * or +
  581. +  * at the start of the r.e., which can involve a lot of backup).  Regmlen is
  582. +  * supplied because the test in regexec() needs it and regcomp() is computing
  583. +  * it anyway.
  584. +  */
  585. + 
  586. + /*
  587. +  * Structure for regexp "program".  This is essentially a linear encoding
  588. +  * of a nondeterministic finite-state machine (aka syntax charts or
  589. +  * "railroad normal form" in parsing technology).  Each node is an opcode
  590. +  * plus a "next" pointer, possibly plus an operand.  "Next" pointers of
  591. +  * all nodes except BRANCH implement concatenation; a "next" pointer with
  592. +  * a BRANCH on both ends of it is connecting two alternatives.  (Here we
  593. +  * have one of the subtle syntax dependencies:  an individual BRANCH (as
  594. +  * opposed to a collection of them) is never concatenated with anything
  595. +  * because of operator precedence.)  The operand of some types of node is
  596. +  * a literal string; for others, it is a node leading into a sub-FSM.  In
  597. +  * particular, the operand of a BRANCH node is the first node of the branch.
  598. +  * (NB this is *not* a tree structure:  the tail of the branch connects
  599. +  * to the thing following the set of BRANCHes.)  The opcodes are:
  600. +  */
  601. + 
  602. + /* definition    number    opnd?    meaning */
  603. + #define    END    0    /* no    End of program. */
  604. + #define    BOL    1    /* no    Match "" at beginning of line. */
  605. + #define    EOL    2    /* no    Match "" at end of line. */
  606. + #define    ANY    3    /* no    Match any one character. */
  607. + #define    ANYOF    4    /* str    Match any character in this string. */
  608. + #define    ANYBUT    5    /* str    Match any character not in this string. */
  609. + #define    BRANCH    6    /* node    Match this alternative, or the next... */
  610. + #define    BACK    7    /* no    Match "", "next" ptr points backward. */
  611. + #define    EXACTLY    8    /* str    Match this string. */
  612. + #define    NOTHING    9    /* no    Match empty string. */
  613. + #define    STAR    10    /* node    Match this (simple) thing 0 or more times. */
  614. + #define    PLUS    11    /* node    Match this (simple) thing 1 or more times. */
  615. + #define    OPEN    20    /* no    Mark this point in input as start of #n. */
  616. +             /*    OPEN+1 is number 1, etc. */
  617. + #define    CLOSE    30    /* no    Analogous to OPEN. */
  618. + 
  619. + /*
  620. +  * Opcode notes:
  621. +  *
  622. +  * BRANCH    The set of branches constituting a single choice are hooked
  623. +  *        together with their "next" pointers, since precedence prevents
  624. +  *        anything being concatenated to any individual branch.  The
  625. +  *        "next" pointer of the last BRANCH in a choice points to the
  626. +  *        thing following the whole choice.  This is also where the
  627. +  *        final "next" pointer of each individual branch points; each
  628. +  *        branch starts with the operand node of a BRANCH node.
  629. +  *
  630. +  * BACK        Normal "next" pointers all implicitly point forward; BACK
  631. +  *        exists to make loop structures possible.
  632. +  *
  633. +  * STAR,PLUS    '?', and complex '*' and '+', are implemented as circular
  634. +  *        BRANCH structures using BACK.  Simple cases (one character
  635. +  *        per match) are implemented with STAR and PLUS for speed
  636. +  *        and to minimize recursive plunges.
  637. +  *
  638. +  * OPEN,CLOSE    ...are numbered at compile time.
  639. +  */
  640. + 
  641. + /*
  642. +  * A node is one char of opcode followed by two chars of "next" pointer.
  643. +  * "Next" pointers are stored as two 8-bit pieces, high order first.  The
  644. +  * value is a positive offset from the opcode of the node containing it.
  645. +  * An operand, if any, simply follows the node.  (Note that much of the
  646. +  * code generation knows about this implicit relationship.)
  647. +  *
  648. +  * Using two bytes for the "next" pointer is vast overkill for most things,
  649. +  * but allows patterns to get big without disasters.
  650. +  */
  651. + #define    OP(p)    (*(p))
  652. + #define    NEXT(p)    (((*((p)+1)&0377)<<8) + (*((p)+2)&0377))
  653. + #define    OPERAND(p)    ((p) + 3)
  654. + 
  655. + /*
  656. +  * See regmagic.h for one further detail of program structure.
  657. +  */
  658. + 
  659. + 
  660. + /*
  661. +  * Utility definitions.
  662. +  */
  663. + #ifndef CHARBITS
  664. + #define    UCHARAT(p)    ((int)*(unsigned char *)(p))
  665. + #else
  666. + #define    UCHARAT(p)    ((int)*(p)&CHARBITS)
  667. + #endif
  668. + 
  669. + #define    FAIL(m)    { regerror(m); return(NULL); }
  670. + #define    ISMULT(c)    ((c) == '*' || (c) == '+' || (c) == '?')
  671. + #define    META    "^$.[()|?+*\\"
  672. + 
  673. + /*
  674. +  * Flags to be passed up and down.
  675. +  */
  676. + #define    HASWIDTH    01    /* Known never to match null string. */
  677. + #define    SIMPLE        02    /* Simple enough to be STAR/PLUS operand. */
  678. + #define    SPSTART        04    /* Starts with * or +. */
  679. + #define    WORST        0    /* Worst case. */
  680. + 
  681. + /*
  682. +  * Global work variables for regcomp().
  683. +  */
  684. + static char *regparse;        /* Input-scan pointer. */
  685. + static int regnpar;        /* () count. */
  686. + static char regdummy;
  687. + static char *regcode;        /* Code-emit pointer; ®dummy = don't. */
  688. + static long regsize;        /* Code size. */
  689. + 
  690. + /*
  691. +  * Forward declarations for regcomp()'s friends.
  692. +  */
  693. + #ifndef STATIC
  694. + #define    STATIC    static
  695. + #endif
  696. + STATIC char *reg();
  697. + STATIC char *regbranch();
  698. + STATIC char *regpiece();
  699. + STATIC char *regatom();
  700. + STATIC char *regnode();
  701. + STATIC char *regnext();
  702. + STATIC void regc();
  703. + STATIC void reginsert();
  704. + STATIC void regtail();
  705. + STATIC void regoptail();
  706. + 
  707. + /*
  708. +  - regcomp - compile a regular expression into internal code
  709. +  *
  710. +  * We can't allocate space until we know how big the compiled form will be,
  711. +  * but we can't compile it (and thus know how big it is) until we've got a
  712. +  * place to put the code.  So we cheat:  we compile it twice, once with code
  713. +  * generation turned off and size counting turned on, and once "for real".
  714. +  * This also means that we don't allocate space until we are sure that the
  715. +  * thing really will compile successfully, and we never have to move the
  716. +  * code and thus invalidate pointers into it.  (Note that it has to be in
  717. +  * one piece because free() must be able to free it all.)
  718. +  *
  719. +  * Beware that the optimization-preparation code in here knows about some
  720. +  * of the structure of the compiled regexp.
  721. +  */
  722. + regexp *
  723. + regcomp(exp)
  724. + char *exp;
  725. + {
  726. +     register regexp *r;
  727. +     register char *scan;
  728. +     register char *longest;
  729. +     register int len;
  730. +     int flags;
  731. + 
  732. +     if (exp == NULL)
  733. +         FAIL("NULL argument");
  734. + 
  735. +     /* First pass: determine size, legality. */
  736. +     regparse = exp;
  737. +     regnpar = 1;
  738. +     regsize = 0L;
  739. +     regcode = ®dummy;
  740. +     regc(MAGIC);
  741. +     if (reg(0, &flags) == NULL)
  742. +         return(NULL);
  743. + 
  744. +     /* Small enough for pointer-storage convention? */
  745. +     if (regsize >= 32767L)        /* Probably could be 65535L. */
  746. +         FAIL("regexp too big");
  747. + 
  748. +     /* Allocate space. */
  749. +     r = (regexp *)malloc(sizeof(regexp) + (unsigned)regsize);
  750. +     if (r == NULL)
  751. +         FAIL("out of space");
  752. + 
  753. +     /* Second pass: emit code. */
  754. +     regparse = exp;
  755. +     regnpar = 1;
  756. +     regcode = r->program;
  757. +     regc(MAGIC);
  758. +     if (reg(0, &flags) == NULL)
  759. +         return(NULL);
  760. + 
  761. +     /* Dig out information for optimizations. */
  762. +     r->regstart = '\0';    /* Worst-case defaults. */
  763. +     r->reganch = 0;
  764. +     r->regmust = NULL;
  765. +     r->regmlen = 0;
  766. +     scan = r->program+1;            /* First BRANCH. */
  767. +     if (OP(regnext(scan)) == END) {        /* Only one top-level choice. */
  768. +         scan = OPERAND(scan);
  769. + 
  770. +         /* Starting-point info. */
  771. +         if (OP(scan) == EXACTLY)
  772. +             r->regstart = *OPERAND(scan);
  773. +         else if (OP(scan) == BOL)
  774. +             r->reganch++;
  775. + 
  776. +         /*
  777. +          * If there's something expensive in the r.e., find the
  778. +          * longest literal string that must appear and make it the
  779. +          * regmust.  Resolve ties in favor of later strings, since
  780. +          * the regstart check works with the beginning of the r.e.
  781. +          * and avoiding duplication strengthens checking.  Not a
  782. +          * strong reason, but sufficient in the absence of others.
  783. +          */
  784. +         if (flags&SPSTART) {
  785. +             longest = NULL;
  786. +             len = 0;
  787. +             for (; scan != NULL; scan = regnext(scan))
  788. +                 if (OP(scan) == EXACTLY && strlen(OPERAND(scan)) >= len) {
  789. +                     longest = OPERAND(scan);
  790. +                     len = strlen(OPERAND(scan));
  791. +                 }
  792. +             r->regmust = longest;
  793. +             r->regmlen = len;
  794. +         }
  795. +     }
  796. + 
  797. +     return(r);
  798. + }
  799. + 
  800. + /*
  801. +  - reg - regular expression, i.e. main body or parenthesized thing
  802. +  *
  803. +  * Caller must absorb opening parenthesis.
  804. +  *
  805. +  * Combining parenthesis handling with the base level of regular expression
  806. +  * is a trifle forced, but the need to tie the tails of the branches to what
  807. +  * follows makes it hard to avoid.
  808. +  */
  809. + static char *
  810. + reg(paren, flagp)
  811. + int paren;            /* Parenthesized? */
  812. + int *flagp;
  813. + {
  814. +     register char *ret;
  815. +     register char *br;
  816. +     register char *ender;
  817. +     register int parno;
  818. +     int flags;
  819. + 
  820. +     *flagp = HASWIDTH;    /* Tentatively. */
  821. + 
  822. +     /* Make an OPEN node, if parenthesized. */
  823. +     if (paren) {
  824. +         if (regnpar >= NSUBEXP)
  825. +             FAIL("too many ()");
  826. +         parno = regnpar;
  827. +         regnpar++;
  828. +         ret = regnode(OPEN+parno);
  829. +     } else
  830. +         ret = NULL;
  831. + 
  832. +     /* Pick up the branches, linking them together. */
  833. +     br = regbranch(&flags);
  834. +     if (br == NULL)
  835. +         return(NULL);
  836. +     if (ret != NULL)
  837. +         regtail(ret, br);    /* OPEN -> first. */
  838. +     else
  839. +         ret = br;
  840. +     if (!(flags&HASWIDTH))
  841. +         *flagp &= ~HASWIDTH;
  842. +     *flagp |= flags&SPSTART;
  843. +     while (*regparse == '|') {
  844. +         regparse++;
  845. +         br = regbranch(&flags);
  846. +         if (br == NULL)
  847. +             return(NULL);
  848. +         regtail(ret, br);    /* BRANCH -> BRANCH. */
  849. +         if (!(flags&HASWIDTH))
  850. +             *flagp &= ~HASWIDTH;
  851. +         *flagp |= flags&SPSTART;
  852. +     }
  853. + 
  854. +     /* Make a closing node, and hook it on the end. */
  855. +     ender = regnode((paren) ? CLOSE+parno : END);    
  856. +     regtail(ret, ender);
  857. + 
  858. +     /* Hook the tails of the branches to the closing node. */
  859. +     for (br = ret; br != NULL; br = regnext(br))
  860. +         regoptail(br, ender);
  861. + 
  862. +     /* Check for proper termination. */
  863. +     if (paren && *regparse++ != ')') {
  864. +         FAIL("unmatched ()");
  865. +     } else if (!paren && *regparse != '\0') {
  866. +         if (*regparse == ')') {
  867. +             FAIL("unmatched ()");
  868. +         } else
  869. +             FAIL("junk on end");    /* "Can't happen". */
  870. +         /* NOTREACHED */
  871. +     }
  872. + 
  873. +     return(ret);
  874. + }
  875. + 
  876. + /*
  877. +  - regbranch - one alternative of an | operator
  878. +  *
  879. +  * Implements the concatenation operator.
  880. +  */
  881. + static char *
  882. + regbranch(flagp)
  883. + int *flagp;
  884. + {
  885. +     register char *ret;
  886. +     register char *chain;
  887. +     register char *latest;
  888. +     int flags;
  889. + 
  890. +     *flagp = WORST;        /* Tentatively. */
  891. + 
  892. +     ret = regnode(BRANCH);
  893. +     chain = NULL;
  894. +     while (*regparse != '\0' && *regparse != '|' && *regparse != ')') {
  895. +         latest = regpiece(&flags);
  896. +         if (latest == NULL)
  897. +             return(NULL);
  898. +         *flagp |= flags&HASWIDTH;
  899. +         if (chain == NULL)    /* First piece. */
  900. +             *flagp |= flags&SPSTART;
  901. +         else
  902. +             regtail(chain, latest);
  903. +         chain = latest;
  904. +     }
  905. +     if (chain == NULL)    /* Loop ran zero times. */
  906. +         (void) regnode(NOTHING);
  907. + 
  908. +     return(ret);
  909. + }
  910. + 
  911. + /*
  912. +  - regpiece - something followed by possible [*+?]
  913. +  *
  914. +  * Note that the branching code sequences used for ? and the general cases
  915. +  * of * and + are somewhat optimized:  they use the same NOTHING node as
  916. +  * both the endmarker for their branch list and the body of the last branch.
  917. +  * It might seem that this node could be dispensed with entirely, but the
  918. +  * endmarker role is not redundant.
  919. +  */
  920. + static char *
  921. + regpiece(flagp)
  922. + int *flagp;
  923. + {
  924. +     register char *ret;
  925. +     register char op;
  926. +     register char *next;
  927. +     int flags;
  928. + 
  929. +     ret = regatom(&flags);
  930. +     if (ret == NULL)
  931. +         return(NULL);
  932. + 
  933. +     op = *regparse;
  934. +     if (!ISMULT(op)) {
  935. +         *flagp = flags;
  936. +         return(ret);
  937. +     }
  938. + 
  939. +     if (!(flags&HASWIDTH) && op != '?')
  940. +         FAIL("*+ operand could be empty");
  941. +     *flagp = (op != '+') ? (WORST|SPSTART) : (WORST|HASWIDTH);
  942. + 
  943. +     if (op == '*' && (flags&SIMPLE))
  944. +         reginsert(STAR, ret);
  945. +     else if (op == '*') {
  946. +         /* Emit x* as (x&|), where & means "self". */
  947. +         reginsert(BRANCH, ret);            /* Either x */
  948. +         regoptail(ret, regnode(BACK));        /* and loop */
  949. +         regoptail(ret, ret);            /* back */
  950. +         regtail(ret, regnode(BRANCH));        /* or */
  951. +         regtail(ret, regnode(NOTHING));        /* null. */
  952. +     } else if (op == '+' && (flags&SIMPLE))
  953. +         reginsert(PLUS, ret);
  954. +     else if (op == '+') {
  955. +         /* Emit x+ as x(&|), where & means "self". */
  956. +         next = regnode(BRANCH);            /* Either */
  957. +         regtail(ret, next);
  958. +         regtail(regnode(BACK), ret);        /* loop back */
  959. +         regtail(next, regnode(BRANCH));        /* or */
  960. +         regtail(ret, regnode(NOTHING));        /* null. */
  961. +     } else if (op == '?') {
  962. +         /* Emit x? as (x|) */
  963. +         reginsert(BRANCH, ret);            /* Either x */
  964. +         regtail(ret, regnode(BRANCH));        /* or */
  965. +         next = regnode(NOTHING);        /* null. */
  966. +         regtail(ret, next);
  967. +         regoptail(ret, next);
  968. +     }
  969. +     regparse++;
  970. +     if (ISMULT(*regparse))
  971. +         FAIL("nested *?+");
  972. + 
  973. +     return(ret);
  974. + }
  975. + 
  976. + /*
  977. +  - regatom - the lowest level
  978. +  *
  979. +  * Optimization:  gobbles an entire sequence of ordinary characters so that
  980. +  * it can turn them into a single node, which is smaller to store and
  981. +  * faster to run.  Backslashed characters are exceptions, each becoming a
  982. +  * separate node; the code is simpler that way and it's not worth fixing.
  983. +  */
  984. + static char *
  985. + regatom(flagp)
  986. + int *flagp;
  987. + {
  988. +     register char *ret;
  989. +     int flags;
  990. + 
  991. +     *flagp = WORST;        /* Tentatively. */
  992. + 
  993. +     switch (*regparse++) {
  994. +     case '^':
  995. +         ret = regnode(BOL);
  996. +         break;
  997. +     case '$':
  998. +         ret = regnode(EOL);
  999. +         break;
  1000. +     case '.':
  1001. +         ret = regnode(ANY);
  1002. +         *flagp |= HASWIDTH|SIMPLE;
  1003. +         break;
  1004. +     case '[': {
  1005. +             register int class;
  1006. +             register int classend;
  1007. + 
  1008. +             if (*regparse == '^') {    /* Complement of range. */
  1009. +                 ret = regnode(ANYBUT);
  1010. +                 regparse++;
  1011. +             } else
  1012. +                 ret = regnode(ANYOF);
  1013. +             if (*regparse == ']' || *regparse == '-')
  1014. +                 regc(*regparse++);
  1015. +             while (*regparse != '\0' && *regparse != ']') {
  1016. +                 if (*regparse == '-') {
  1017. +                     regparse++;
  1018. +                     if (*regparse == ']' || *regparse == '\0')
  1019. +                         regc('-');
  1020. +                     else {
  1021. +                         class = UCHARAT(regparse-2)+1;
  1022. +                         classend = UCHARAT(regparse);
  1023. +                         if (class > classend+1)
  1024. +                             FAIL("invalid [] range");
  1025. +                         for (; class <= classend; class++)
  1026. +                             regc(class);
  1027. +                         regparse++;
  1028. +                     }
  1029. +                 } else
  1030. +                     regc(*regparse++);
  1031. +             }
  1032. +             regc('\0');
  1033. +             if (*regparse != ']')
  1034. +                 FAIL("unmatched []");
  1035. +             regparse++;
  1036. +             *flagp |= HASWIDTH|SIMPLE;
  1037. +         }
  1038. +         break;
  1039. +     case '(':
  1040. +         ret = reg(1, &flags);
  1041. +         if (ret == NULL)
  1042. +             return(NULL);
  1043. +         *flagp |= flags&(HASWIDTH|SPSTART);
  1044. +         break;
  1045. +     case '\0':
  1046. +     case '|':
  1047. +     case ')':
  1048. +         FAIL("internal urp");    /* Supposed to be caught earlier. */
  1049. +     case '?':
  1050. +     case '+':
  1051. +     case '*':
  1052. +         FAIL("?+* follows nothing");
  1053. +     case '\\':
  1054. +         if (*regparse == '\0')
  1055. +             FAIL("trailing \\");
  1056. +         ret = regnode(EXACTLY);
  1057. +         regc(*regparse++);
  1058. +         regc('\0');
  1059. +         *flagp |= HASWIDTH|SIMPLE;
  1060. +         break;
  1061. +     default: {
  1062. +             register int len;
  1063. +             register char ender;
  1064. + 
  1065. +             regparse--;
  1066. +             len = strcspn(regparse, META);
  1067. +             if (len <= 0)
  1068. +                 FAIL("internal disaster");
  1069. +             ender = *(regparse+len);
  1070. +             if (len > 1 && ISMULT(ender))
  1071. +                 len--;        /* Back off clear of ?+* operand. */
  1072. +             *flagp |= HASWIDTH;
  1073. +             if (len == 1)
  1074. +                 *flagp |= SIMPLE;
  1075. +             ret = regnode(EXACTLY);
  1076. +             while (len > 0) {
  1077. +                 regc(*regparse++);
  1078. +                 len--;
  1079. +             }
  1080. +             regc('\0');
  1081. +         }
  1082. +         break;
  1083. +     }
  1084. + 
  1085. +     return(ret);
  1086. + }
  1087. + 
  1088. + /*
  1089. +  - regnode - emit a node
  1090. +  */
  1091. + static char *            /* Location. */
  1092. + regnode(op)
  1093. + char op;
  1094. + {
  1095. +     register char *ret;
  1096. +     register char *ptr;
  1097. + 
  1098. +     ret = regcode;
  1099. +     if (ret == ®dummy) {
  1100. +         regsize += 3;
  1101. +         return(ret);
  1102. +     }
  1103. + 
  1104. +     ptr = ret;
  1105. +     *ptr++ = op;
  1106. +     *ptr++ = '\0';        /* Null "next" pointer. */
  1107. +     *ptr++ = '\0';
  1108. +     regcode = ptr;
  1109. + 
  1110. +     return(ret);
  1111. + }
  1112. + 
  1113. + /*
  1114. +  - regc - emit (if appropriate) a byte of code
  1115. +  */
  1116. + static void
  1117. + regc(b)
  1118. + char b;
  1119. + {
  1120. +     if (regcode != ®dummy)
  1121. +         *regcode++ = b;
  1122. +     else
  1123. +         regsize++;
  1124. + }
  1125. + 
  1126. + /*
  1127. +  - reginsert - insert an operator in front of already-emitted operand
  1128. +  *
  1129. +  * Means relocating the operand.
  1130. +  */
  1131. + static void
  1132. + reginsert(op, opnd)
  1133. + char op;
  1134. + char *opnd;
  1135. + {
  1136. +     register char *src;
  1137. +     register char *dst;
  1138. +     register char *place;
  1139. + 
  1140. +     if (regcode == ®dummy) {
  1141. +         regsize += 3;
  1142. +         return;
  1143. +     }
  1144. + 
  1145. +     src = regcode;
  1146. +     regcode += 3;
  1147. +     dst = regcode;
  1148. +     while (src > opnd)
  1149. +         *--dst = *--src;
  1150. + 
  1151. +     place = opnd;        /* Op node, where operand used to be. */
  1152. +     *place++ = op;
  1153. +     *place++ = '\0';
  1154. +     *place++ = '\0';
  1155. + }
  1156. + 
  1157. + /*
  1158. +  - regtail - set the next-pointer at the end of a node chain
  1159. +  */
  1160. + static void
  1161. + regtail(p, val)
  1162. + char *p;
  1163. + char *val;
  1164. + {
  1165. +     register char *scan;
  1166. +     register char *temp;
  1167. +     register int offset;
  1168. + 
  1169. +     if (p == ®dummy)
  1170. +         return;
  1171. + 
  1172. +     /* Find last node. */
  1173. +     scan = p;
  1174. +     for (;;) {
  1175. +         temp = regnext(scan);
  1176. +         if (temp == NULL)
  1177. +             break;
  1178. +         scan = temp;
  1179. +     }
  1180. + 
  1181. +     if (OP(scan) == BACK)
  1182. +         offset = scan - val;
  1183. +     else
  1184. +         offset = val - scan;
  1185. +     *(scan+1) = (offset>>8)&0377;
  1186. +     *(scan+2) = offset&0377;
  1187. + }
  1188. + 
  1189. + /*
  1190. +  - regoptail - regtail on operand of first argument; nop if operandless
  1191. +  */
  1192. + static void
  1193. + regoptail(p, val)
  1194. + char *p;
  1195. + char *val;
  1196. + {
  1197. +     /* "Operandless" and "op != BRANCH" are synonymous in practice. */
  1198. +     if (p == NULL || p == ®dummy || OP(p) != BRANCH)
  1199. +         return;
  1200. +     regtail(OPERAND(p), val);
  1201. + }
  1202. + 
  1203. + /*
  1204. +  * regexec and friends
  1205. +  */
  1206. + 
  1207. + /*
  1208. +  * Global work variables for regexec().
  1209. +  */
  1210. + static char *reginput;        /* String-input pointer. */
  1211. + static char *regbol;        /* Beginning of input, for ^ check. */
  1212. + static char **regstartp;    /* Pointer to startp array. */
  1213. + static char **regendp;        /* Ditto for endp. */
  1214. + 
  1215. + /*
  1216. +  * Forwards.
  1217. +  */
  1218. + STATIC int regtry();
  1219. + STATIC int regmatch();
  1220. + STATIC int regrepeat();
  1221. + 
  1222. + #ifdef DEBUG
  1223. + int regnarrate = 0;
  1224. + void regdump();
  1225. + STATIC char *regprop();
  1226. + #endif
  1227. + 
  1228. + /*
  1229. +  - regexec - match a regexp against a string
  1230. +  */
  1231. + int
  1232. + regexec(prog, string)
  1233. + register regexp *prog;
  1234. + register char *string;
  1235. + {
  1236. +     register char *s;
  1237. + 
  1238. +     /* Be paranoid... */
  1239. +     if (prog == NULL || string == NULL) {
  1240. +         regerror("NULL parameter");
  1241. +         return(0);
  1242. +     }
  1243. + 
  1244. +     /* Check validity of program. */
  1245. +     if (UCHARAT(prog->program) != MAGIC) {
  1246. +         regerror("corrupted program");
  1247. +         return(0);
  1248. +     }
  1249. + 
  1250. +     /* If there is a "must appear" string, look for it. */
  1251. +     if (prog->regmust != NULL) {
  1252. +         s = string;
  1253. +         while ((s = index(s, prog->regmust[0])) != NULL) {
  1254. +             if (strncmp(s, prog->regmust, prog->regmlen) == 0)
  1255. +                 break;    /* Found it. */
  1256. +             s++;
  1257. +         }
  1258. +         if (s == NULL)    /* Not present. */
  1259. +             return(0);
  1260. +     }
  1261. + 
  1262. +     /* Mark beginning of line for ^ . */
  1263. +     regbol = string;
  1264. + 
  1265. +     /* Simplest case:  anchored match need be tried only once. */
  1266. +     if (prog->reganch)
  1267. +         return(regtry(prog, string));
  1268. + 
  1269. +     /* Messy cases:  unanchored match. */
  1270. +     s = string;
  1271. +     if (prog->regstart != '\0')
  1272. +         /* We know what char it must start with. */
  1273. +         while ((s = index(s, prog->regstart)) != NULL) {
  1274. +             if (regtry(prog, s))
  1275. +                 return(1);
  1276. +             s++;
  1277. +         }
  1278. +     else
  1279. +         /* We don't -- general case. */
  1280. +         do {
  1281. +             if (regtry(prog, s))
  1282. +                 return(1);
  1283. +         } while (*s++ != '\0');
  1284. + 
  1285. +     /* Failure. */
  1286. +     return(0);
  1287. + }
  1288. + 
  1289. + /*
  1290. +  - regtry - try match at specific point
  1291. +  */
  1292. + static int            /* 0 failure, 1 success */
  1293. + regtry(prog, string)
  1294. + regexp *prog;
  1295. + char *string;
  1296. + {
  1297. +     register int i;
  1298. +     register char **sp;
  1299. +     register char **ep;
  1300. + 
  1301. +     reginput = string;
  1302. +     regstartp = prog->startp;
  1303. +     regendp = prog->endp;
  1304. + 
  1305. +     sp = prog->startp;
  1306. +     ep = prog->endp;
  1307. +     for (i = NSUBEXP; i > 0; i--) {
  1308. +         *sp++ = NULL;
  1309. +         *ep++ = NULL;
  1310. +     }
  1311. +     if (regmatch(prog->program + 1)) {
  1312. +         prog->startp[0] = string;
  1313. +         prog->endp[0] = reginput;
  1314. +         return(1);
  1315. +     } else
  1316. +         return(0);
  1317. + }
  1318. + 
  1319. + /*
  1320. +  - regmatch - main matching routine
  1321. +  *
  1322. +  * Conceptually the strategy is simple:  check to see whether the current
  1323. +  * node matches, call self recursively to see whether the rest matches,
  1324. +  * and then act accordingly.  In practice we make some effort to avoid
  1325. +  * recursion, in particular by going through "ordinary" nodes (that don't
  1326. +  * need to know whether the rest of the match failed) by a loop instead of
  1327. +  * by recursion.
  1328. +  */
  1329. + static int            /* 0 failure, 1 success */
  1330. + regmatch(prog)
  1331. + char *prog;
  1332. + {
  1333. +     register char *scan;    /* Current node. */
  1334. +     char *next;        /* Next node. */
  1335. + 
  1336. +     scan = prog;
  1337. + #ifdef DEBUG
  1338. +     if (scan != NULL && regnarrate)
  1339. +         fprintf(stderr, "%s(\n", regprop(scan));
  1340. + #endif
  1341. +     while (scan != NULL) {
  1342. + #ifdef DEBUG
  1343. +         if (regnarrate)
  1344. +             fprintf(stderr, "%s...\n", regprop(scan));
  1345. + #endif
  1346. +         next = regnext(scan);
  1347. + 
  1348. +         switch (OP(scan)) {
  1349. +         case BOL:
  1350. +             if (reginput != regbol)
  1351. +                 return(0);
  1352. +             break;
  1353. +         case EOL:
  1354. +             if (*reginput != '\0')
  1355. +                 return(0);
  1356. +             break;
  1357. +         case ANY:
  1358. +             if (*reginput == '\0')
  1359. +                 return(0);
  1360. +             reginput++;
  1361. +             break;
  1362. +         case EXACTLY: {
  1363. +                 register int len;
  1364. +                 register char *opnd;
  1365. + 
  1366. +                 opnd = OPERAND(scan);
  1367. +                 /* Inline the first character, for speed. */
  1368. +                 if (*opnd != *reginput)
  1369. +                     return(0);
  1370. +                 len = strlen(opnd);
  1371. +                 if (len > 1 && strncmp(opnd, reginput, len) != 0)
  1372. +                     return(0);
  1373. +                 reginput += len;
  1374. +             }
  1375. +             break;
  1376. +         case ANYOF:
  1377. +              if (*reginput == '\0' || index(OPERAND(scan), *reginput) == NULL)
  1378. +                 return(0);
  1379. +             reginput++;
  1380. +             break;
  1381. +         case ANYBUT:
  1382. +              if (*reginput == '\0' || index(OPERAND(scan), *reginput) != NULL)
  1383. +                 return(0);
  1384. +             reginput++;
  1385. +             break;
  1386. +         case NOTHING:
  1387. +             break;
  1388. +         case BACK:
  1389. +             break;
  1390. +         case OPEN+1:
  1391. +         case OPEN+2:
  1392. +         case OPEN+3:
  1393. +         case OPEN+4:
  1394. +         case OPEN+5:
  1395. +         case OPEN+6:
  1396. +         case OPEN+7:
  1397. +         case OPEN+8:
  1398. +         case OPEN+9: {
  1399. +                 register int no;
  1400. +                 register char *save;
  1401. + 
  1402. +                 no = OP(scan) - OPEN;
  1403. +                 save = reginput;
  1404. + 
  1405. +                 if (regmatch(next)) {
  1406. +                     /*
  1407. +                      * Don't set startp if some later
  1408. +                      * invocation of the same parentheses
  1409. +                      * already has.
  1410. +                      */
  1411. +                     if (regstartp[no] == NULL)
  1412. +                         regstartp[no] = save;
  1413. +                     return(1);
  1414. +                 } else
  1415. +                     return(0);
  1416. +             }
  1417. +             break;
  1418. +         case CLOSE+1:
  1419. +         case CLOSE+2:
  1420. +         case CLOSE+3:
  1421. +         case CLOSE+4:
  1422. +         case CLOSE+5:
  1423. +         case CLOSE+6:
  1424. +         case CLOSE+7:
  1425. +         case CLOSE+8:
  1426. +         case CLOSE+9: {
  1427. +                 register int no;
  1428. +                 register char *save;
  1429. + 
  1430. +                 no = OP(scan) - CLOSE;
  1431. +                 save = reginput;
  1432. + 
  1433. +                 if (regmatch(next)) {
  1434. +                     /*
  1435. +                      * Don't set endp if some later
  1436. +                      * invocation of the same parentheses
  1437. +                      * already has.
  1438. +                      */
  1439. +                     if (regendp[no] == NULL)
  1440. +                         regendp[no] = save;
  1441. +                     return(1);
  1442. +                 } else
  1443. +                     return(0);
  1444. +             }
  1445. +             break;
  1446. +         case BRANCH: {
  1447. +                 register char *save;
  1448. + 
  1449. +                 if (OP(next) != BRANCH)        /* No choice. */
  1450. +                     next = OPERAND(scan);    /* Avoid recursion. */
  1451. +                 else {
  1452. +                     do {
  1453. +                         save = reginput;
  1454. +                         if (regmatch(OPERAND(scan)))
  1455. +                             return(1);
  1456. +                         reginput = save;
  1457. +                         scan = regnext(scan);
  1458. +                     } while (scan != NULL && OP(scan) == BRANCH);
  1459. +                     return(0);
  1460. +                     /* NOTREACHED */
  1461. +                 }
  1462. +             }
  1463. +             break;
  1464. +         case STAR:
  1465. +         case PLUS: {
  1466. +                 register char nextch;
  1467. +                 register int no;
  1468. +                 register char *save;
  1469. +                 register int mmin;
  1470. + 
  1471. +                 /*
  1472. +                  * Lookahead to avoid useless match attempts
  1473. +                  * when we know what character comes next.
  1474. +                  */
  1475. +                 nextch = '\0';
  1476. +                 if (OP(next) == EXACTLY)
  1477. +                     nextch = *OPERAND(next);
  1478. +                 mmin = (OP(scan) == STAR) ? 0 : 1;
  1479. +                 save = reginput;
  1480. +                 no = regrepeat(OPERAND(scan));
  1481. +                 while (no >= mmin) {
  1482. +                     /* If it could work, try it. */
  1483. +                     if (nextch == '\0' || *reginput == nextch)
  1484. +                         if (regmatch(next))
  1485. +                             return(1);
  1486. +                     /* Couldn't or didn't -- back up. */
  1487. +                     no--;
  1488. +                     reginput = save + no;
  1489. +                 }
  1490. +                 return(0);
  1491. +             }
  1492. +         case END:
  1493. +             return(1);    /* Success! */
  1494. +         default:
  1495. +             regerror("memory corruption");
  1496. +             return(0);
  1497. +         }
  1498. + 
  1499. +         scan = next;
  1500. +     }
  1501. + 
  1502. +     /*
  1503. +      * We get here only if there's trouble -- normally "case END" is
  1504. +      * the terminating point.
  1505. +      */
  1506. +     regerror("corrupted pointers");
  1507. +     return(0);
  1508. + }
  1509. + 
  1510. + /*
  1511. +  - regrepeat - repeatedly match something simple, report how many
  1512. +  */
  1513. + static int
  1514. + regrepeat(p)
  1515. + char *p;
  1516. + {
  1517. +     register int count = 0;
  1518. +     register char *scan;
  1519. +     register char *opnd;
  1520. + 
  1521. +     scan = reginput;
  1522. +     opnd = OPERAND(p);
  1523. +     switch (OP(p)) {
  1524. +     case ANY:
  1525. +         count = strlen(scan);
  1526. +         scan += count;
  1527. +         break;
  1528. +     case EXACTLY:
  1529. +         while (*opnd == *scan) {
  1530. +             count++;
  1531. +             scan++;
  1532. +         }
  1533. +         break;
  1534. +     case ANYOF:
  1535. +         while (*scan != '\0' && index(opnd, *scan) != NULL) {
  1536. +             count++;
  1537. +             scan++;
  1538. +         }
  1539. +         break;
  1540. +     case ANYBUT:
  1541. +         while (*scan != '\0' && index(opnd, *scan) == NULL) {
  1542. +             count++;
  1543. +             scan++;
  1544. +         }
  1545. +         break;
  1546. +     default:        /* Oh dear.  Called inappropriately. */
  1547. +         regerror("internal foulup");
  1548. +         count = 0;    /* Best compromise. */
  1549. +         break;
  1550. +     }
  1551. +     reginput = scan;
  1552. + 
  1553. +     return(count);
  1554. + }
  1555. + 
  1556. + /*
  1557. +  - regnext - dig the "next" pointer out of a node
  1558. +  */
  1559. + static char *
  1560. + regnext(p)
  1561. + register char *p;
  1562. + {
  1563. +     register int offset;
  1564. + 
  1565. +     if (p == ®dummy)
  1566. +         return(NULL);
  1567. + 
  1568. +     offset = NEXT(p);
  1569. +     if (offset == 0)
  1570. +         return(NULL);
  1571. + 
  1572. +     if (OP(p) == BACK)
  1573. +         return(p-offset);
  1574. +     else
  1575. +         return(p+offset);
  1576. + }
  1577. + 
  1578. + #ifdef DEBUG
  1579. + 
  1580. + STATIC char *regprop();
  1581. + 
  1582. + /*
  1583. +  - regdump - dump a regexp onto stdout in vaguely comprehensible form
  1584. +  */
  1585. + void
  1586. + regdump(r)
  1587. + regexp *r;
  1588. + {
  1589. +     register char *s;
  1590. +     register char op = EXACTLY;    /* Arbitrary non-END op. */
  1591. +     register char *next;
  1592. + 
  1593. + 
  1594. +     s = r->program + 1;
  1595. +     while (op != END) {    /* While that wasn't END last time... */
  1596. +         op = OP(s);
  1597. +         printf("%2d%s", s-r->program, regprop(s));    /* Where, what. */
  1598. +         next = regnext(s);
  1599. +         if (next == NULL)        /* Next ptr. */
  1600. +             printf("(0)");
  1601. +         else 
  1602. +             printf("(%d)", (s-r->program)+(next-s));
  1603. +         s += 3;
  1604. +         if (op == ANYOF || op == ANYBUT || op == EXACTLY) {
  1605. +             /* Literal string, where present. */
  1606. +             while (*s != '\0') {
  1607. +                 putchar(*s);
  1608. +                 s++;
  1609. +             }
  1610. +             s++;
  1611. +         }
  1612. +         putchar('\n');
  1613. +     }
  1614. + 
  1615. +     /* Header fields of interest. */
  1616. +     if (r->regstart != '\0')
  1617. +         printf("start `%c' ", r->regstart);
  1618. +     if (r->reganch)
  1619. +         printf("anchored ");
  1620. +     if (r->regmust != NULL)
  1621. +         printf("must have \"%s\"", r->regmust);
  1622. +     printf("\n");
  1623. + }
  1624. + 
  1625. + /*
  1626. +  - regprop - printable representation of opcode
  1627. +  */
  1628. + static char *
  1629. + regprop(op)
  1630. + char *op;
  1631. + {
  1632. +     register char *p;
  1633. +     static char buf[50];
  1634. + 
  1635. +     (void) strcpy(buf, ":");
  1636. + 
  1637. +     switch (OP(op)) {
  1638. +     case BOL:
  1639. +         p = "BOL";
  1640. +         break;
  1641. +     case EOL:
  1642. +         p = "EOL";
  1643. +         break;
  1644. +     case ANY:
  1645. +         p = "ANY";
  1646. +         break;
  1647. +     case ANYOF:
  1648. +         p = "ANYOF";
  1649. +         break;
  1650. +     case ANYBUT:
  1651. +         p = "ANYBUT";
  1652. +         break;
  1653. +     case BRANCH:
  1654. +         p = "BRANCH";
  1655. +         break;
  1656. +     case EXACTLY:
  1657. +         p = "EXACTLY";
  1658. +         break;
  1659. +     case NOTHING:
  1660. +         p = "NOTHING";
  1661. +         break;
  1662. +     case BACK:
  1663. +         p = "BACK";
  1664. +         break;
  1665. +     case END:
  1666. +         p = "END";
  1667. +         break;
  1668. +     case OPEN+1:
  1669. +     case OPEN+2:
  1670. +     case OPEN+3:
  1671. +     case OPEN+4:
  1672. +     case OPEN+5:
  1673. +     case OPEN+6:
  1674. +     case OPEN+7:
  1675. +     case OPEN+8:
  1676. +     case OPEN+9:
  1677. +         sprintf(buf+strlen(buf), "OPEN%d", OP(op)-OPEN);
  1678. +         p = NULL;
  1679. +         break;
  1680. +     case CLOSE+1:
  1681. +     case CLOSE+2:
  1682. +     case CLOSE+3:
  1683. +     case CLOSE+4:
  1684. +     case CLOSE+5:
  1685. +     case CLOSE+6:
  1686. +     case CLOSE+7:
  1687. +     case CLOSE+8:
  1688. +     case CLOSE+9:
  1689. +         sprintf(buf+strlen(buf), "CLOSE%d", OP(op)-CLOSE);
  1690. +         p = NULL;
  1691. +         break;
  1692. +     case STAR:
  1693. +         p = "STAR";
  1694. +         break;
  1695. +     case PLUS:
  1696. +         p = "PLUS";
  1697. +         break;
  1698. +     default:
  1699. +         regerror("corrupted opcode");
  1700. +         break;
  1701. +     }
  1702. +     if (p != NULL)
  1703. +         (void) strcat(buf, p);
  1704. +     return(buf);
  1705. + }
  1706. + #endif
  1707.  
  1708. Index: src/date.c
  1709. Prereq: 5.1
  1710. *** ../elm2.4/src/date.c    Sat Oct  3 18:58:48 1992
  1711. --- src/date.c    Sat Nov 14 21:10:21 1992
  1712. ***************
  1713. *** 1,8 ****
  1714.   
  1715. ! static char rcsid[] = "@(#)$Id: date.c,v 5.1 1992/10/03 22:58:40 syd Exp $";
  1716.   
  1717.   /*******************************************************************************
  1718. !  *  The Elm Mail System  -  $Revision: 5.1 $   $State: Exp $
  1719.    *
  1720.    *             Copyright (c) 1988-1992 USENET Community Trust
  1721.    *             Copyright (c) 1986,1987 Dave Taylor
  1722. --- 1,8 ----
  1723.   
  1724. ! static char rcsid[] = "@(#)$Id: date.c,v 5.2 1992/11/15 02:10:11 syd Exp $";
  1725.   
  1726.   /*******************************************************************************
  1727. !  *  The Elm Mail System  -  $Revision: 5.2 $   $State: Exp $
  1728.    *
  1729.    *             Copyright (c) 1988-1992 USENET Community Trust
  1730.    *             Copyright (c) 1986,1987 Dave Taylor
  1731. ***************
  1732. *** 14,19 ****
  1733. --- 14,23 ----
  1734.    *
  1735.    *******************************************************************************
  1736.    * $Log: date.c,v $
  1737. +  * Revision 5.2  1992/11/15  02:10:11  syd
  1738. +  * remove no longer used tzname
  1739. +  * From: Syd
  1740. +  *
  1741.    * Revision 5.1  1992/10/03  22:58:40  syd
  1742.    * Initial checkin as of 2.4 Release at PL0
  1743.    *
  1744. ***************
  1745. *** 65,76 ****
  1746.   
  1747.   int  days_in_month[] = { 31,    28,    31,    30,    31,     30, 
  1748.             31,     31,    30,   31,    30,     31,  -1};
  1749. - 
  1750. - #ifdef BSD
  1751. -   char *timezone();
  1752. - #else
  1753. -   extern char *tzname[];
  1754. - #endif
  1755.   
  1756.   days_ahead(days, buffer)
  1757.   int days;
  1758. --- 69,74 ----
  1759.  
  1760. Index: lib/getarpdate.c
  1761. Prereq: 5.2
  1762. *** ../elm2.4/lib/getarpdate.c    Tue Nov 10 15:20:24 1992
  1763. --- lib/getarpdate.c    Sat Nov 14 21:18:27 1992
  1764. ***************
  1765. *** 1,7 ****
  1766. ! static char rcsid[] = "@(#)$Id: getarpdate.c,v 5.2 1992/11/07 19:27:30 syd Exp $";
  1767.   
  1768.   /*******************************************************************************
  1769. !  *  The Elm Mail System  -  $Revision: 5.2 $   $State: Exp $
  1770.    *
  1771.    *            Copyright (c) 1988-1992 USENET Community Trust
  1772.    *            Copyright (c) 1986,1987 Dave Taylor
  1773. --- 1,7 ----
  1774. ! static char rcsid[] = "@(#)$Id: getarpdate.c,v 5.4 1992/11/15 02:18:15 syd Exp $";
  1775.   
  1776.   /*******************************************************************************
  1777. !  *  The Elm Mail System  -  $Revision: 5.4 $   $State: Exp $
  1778.    *
  1779.    *            Copyright (c) 1988-1992 USENET Community Trust
  1780.    *            Copyright (c) 1986,1987 Dave Taylor
  1781. ***************
  1782. *** 13,18 ****
  1783. --- 13,27 ----
  1784.    *
  1785.    *******************************************************************************
  1786.    * $Log: getarpdate.c,v $
  1787. +  * Revision 5.4  1992/11/15  02:18:15  syd
  1788. +  * Change most of the rest of the BSDs to TZNAME
  1789. +  * From: Syd
  1790. +  *
  1791. +  * Revision 5.3  1992/11/15  02:10:58  syd
  1792. +  * change tzname ifdef from ndefBSD to ifdef TZNAME on its own
  1793. +  * configure variable
  1794. +  * From: Syd
  1795. +  *
  1796.    * Revision 5.2  1992/11/07  19:27:30  syd
  1797.    * Symbol change for AIX370
  1798.    * From: uri@watson.ibm.com
  1799. ***************
  1800. *** 54,63 ****
  1801.   static char *arpa_monname[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  1802.             "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", ""};
  1803.   
  1804. ! #if defined(BSD) && !defined(_POSIX_SOURCE)
  1805. !   char *timezone();
  1806. ! #else
  1807.     extern char *tzname[];
  1808.   #endif
  1809.   
  1810.   #ifdef _AIX370
  1811. --- 63,72 ----
  1812.   static char *arpa_monname[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  1813.             "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", ""};
  1814.   
  1815. ! #ifdef TZNAME
  1816.     extern char *tzname[];
  1817. + #else
  1818. +   char *timezone();
  1819.   #endif
  1820.   
  1821.   #ifdef _AIX370
  1822. ***************
  1823. *** 80,86 ****
  1824.       long       tzmin;        /* number of minutes off gmt      */
  1825.       char      *tzsign;        /* + or - gmt              */
  1826.   
  1827. ! #ifdef BSD
  1828.   # ifndef TZ_MINUTESWEST
  1829.       struct timeb    loc_time;
  1830.   
  1831. --- 89,95 ----
  1832.       long       tzmin;        /* number of minutes off gmt      */
  1833.       char      *tzsign;        /* + or - gmt              */
  1834.   
  1835. ! #ifndef TZNAME
  1836.   # ifndef TZ_MINUTESWEST
  1837.       struct timeb    loc_time;
  1838.   
  1839. ***************
  1840. *** 94,100 ****
  1841.       junk = time_val.tv_sec;
  1842.   # endif /* TZ_MINUTESWEST */
  1843.   
  1844. ! #else /* BSD */
  1845.       extern    time_t    timezone;
  1846.   # ifdef ALTCHECK
  1847.       extern    time_t    altzone;
  1848. --- 103,109 ----
  1849.       junk = time_val.tv_sec;
  1850.   # endif /* TZ_MINUTESWEST */
  1851.   
  1852. ! #else /* TZNAME */
  1853.       extern    time_t    timezone;
  1854.   # ifdef ALTCHECK
  1855.       extern    time_t    altzone;
  1856. ***************
  1857. *** 101,112 ****
  1858.   # endif
  1859.   
  1860.       junk = time((time_t *) 0);    /* this must be here for it to work! */
  1861. ! #endif /* BSD */
  1862.   
  1863.       the_time = localtime(&junk);
  1864.       if (the_time->tm_year < 100)
  1865.           the_time->tm_year += 1900;
  1866. ! #ifdef BSD
  1867.   # ifdef TZ_MINUTESWEST
  1868.       if (the_time->tm_isdst && time_zone.tz_dsttime != DST_NONE)
  1869.           tzmin = - (time_zone.tz_minuteswest - 60);
  1870. --- 110,121 ----
  1871.   # endif
  1872.   
  1873.       junk = time((time_t *) 0);    /* this must be here for it to work! */
  1874. ! #endif /* TZNAME */
  1875.   
  1876.       the_time = localtime(&junk);
  1877.       if (the_time->tm_year < 100)
  1878.           the_time->tm_year += 1900;
  1879. ! #ifndef TZNAME
  1880.   # ifdef TZ_MINUTESWEST
  1881.       if (the_time->tm_isdst && time_zone.tz_dsttime != DST_NONE)
  1882.           tzmin = - (time_zone.tz_minuteswest - 60);
  1883. ***************
  1884. *** 115,121 ****
  1885.   # else /* TZ_MINUTESWEST */
  1886.       tzmin = the_time->tm_gmtoff / 60;
  1887.   # endif /* TZ_MINUTESWEST */
  1888. ! #else /* BSD */
  1889.   # ifdef ALTCHECK
  1890.       if (the_time->tm_isdst)
  1891.           tzmin = - (altzone / 60);
  1892. --- 124,130 ----
  1893.   # else /* TZ_MINUTESWEST */
  1894.       tzmin = the_time->tm_gmtoff / 60;
  1895.   # endif /* TZ_MINUTESWEST */
  1896. ! #else /* TZNAME */
  1897.   # ifdef ALTCHECK
  1898.       if (the_time->tm_isdst)
  1899.           tzmin = - (altzone / 60);
  1900. ***************
  1901. *** 124,130 ****
  1902.   # else /* ALTCHECK */
  1903.       tzmin = - (timezone / 60);
  1904.   # endif /* ALTCHECK */
  1905. ! #endif /* BSD */
  1906.   
  1907.       if (tzmin >= 0)
  1908.           tzsign = "+";
  1909. --- 133,139 ----
  1910.   # else /* ALTCHECK */
  1911.       tzmin = - (timezone / 60);
  1912.   # endif /* ALTCHECK */
  1913. ! #endif /* TZNAME */
  1914.   
  1915.       if (tzmin >= 0)
  1916.           tzsign = "+";
  1917. ***************
  1918. *** 139,145 ****
  1919.         arpa_monname[the_time->tm_mon], the_time->tm_year,
  1920.         the_time->tm_hour, the_time->tm_min, the_time->tm_sec,
  1921.         tzsign, tzmin / 60, tzmin % 60,
  1922. ! #ifdef BSD
  1923.   #ifdef TZ_MINUTESWEST
  1924.   # ifdef GOULD_NP1
  1925.         the_time->tm_zone);
  1926. --- 148,154 ----
  1927.         arpa_monname[the_time->tm_mon], the_time->tm_year,
  1928.         the_time->tm_hour, the_time->tm_min, the_time->tm_sec,
  1929.         tzsign, tzmin / 60, tzmin % 60,
  1930. ! #ifndef TZNAME
  1931.   #ifdef TZ_MINUTESWEST
  1932.   # ifdef GOULD_NP1
  1933.         the_time->tm_zone);
  1934.  
  1935. Index: src/editmsg.c
  1936. Prereq: 5.2
  1937. *** ../elm2.4/src/editmsg.c    Mon Oct 19 13:04:08 1992
  1938. --- src/editmsg.c    Mon Nov 16 23:05:25 1992
  1939. ***************
  1940. *** 1,8 ****
  1941.   
  1942. ! static char rcsid[] = "@(#)$Id: editmsg.c,v 5.2 1992/10/17 22:22:33 syd Exp $";
  1943.   
  1944.   /*******************************************************************************
  1945. !  *  The Elm Mail System  -  $Revision: 5.2 $   $State: Exp $
  1946.    *
  1947.    *             Copyright (c) 1988-1992 USENET Community Trust
  1948.    *            Copyright (c) 1986,1987 Dave Taylor
  1949. --- 1,8 ----
  1950.   
  1951. ! static char rcsid[] = "@(#)$Id: editmsg.c,v 5.3 1992/11/17 04:05:24 syd Exp $";
  1952.   
  1953.   /*******************************************************************************
  1954. !  *  The Elm Mail System  -  $Revision: 5.3 $   $State: Exp $
  1955.    *
  1956.    *             Copyright (c) 1988-1992 USENET Community Trust
  1957.    *            Copyright (c) 1986,1987 Dave Taylor
  1958. ***************
  1959. *** 14,19 ****
  1960. --- 14,23 ----
  1961.    *
  1962.    *******************************************************************************
  1963.    * $Log: editmsg.c,v $
  1964. +  * Revision 5.3  1992/11/17  04:05:24  syd
  1965. +  * Fix for editing interrupt broken by posix_signal().
  1966. +  * From cs.utexas.edu!chinacat!chip Mon Nov 16 09:03:04 1992
  1967. +  *
  1968.    * Revision 5.2  1992/10/17  22:22:33  syd
  1969.    * Fix warnings from my ANSI C compiler because the declaration of
  1970.    * edit_interrupt did not match the prototype for the second argument of
  1971. ***************
  1972. *** 38,43 ****
  1973. --- 42,53 ----
  1974.   #include <setjmp.h>
  1975.   #endif /* BSD */
  1976.   #include <ctype.h>
  1977. + 
  1978. + #ifdef POSIX_SIGNALS
  1979. + #define jmp_buf            sigjmp_buf
  1980. + #define setjmp(env)        sigsetjmp((env), 1)
  1981. + #define longjmp(env,val)    siglongjmp((env), (val))
  1982. + #endif
  1983.   
  1984.   #ifdef BSD
  1985.   #undef        tolower
  1986.  
  1987. -- 
  1988. ========================================================================
  1989. Sydney S. Weinstein, CDP, CCP          Elm Coordinator - Current 2.4PL08
  1990. Datacomp Systems, Inc.                 Projected 3.0 Release: ??? ?,1994
  1991. syd@DSI.COM or dsinc!syd      Voice: (215) 947-9900, FAX: (215) 938-0235
  1992.