home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume13 / slice < prev    next >
Text File  |  1988-01-31  |  37KB  |  1,274 lines
  1. Subject:  v13i073:  Split file based on patterns or line numbers
  2. Newsgroups: comp.sources.unix
  3. Sender: sources
  4. Approved: rsalz@uunet.UU.NET
  5.  
  6. Submitted-by: Gary Puckering <cognos!garyp>
  7. Posting-number: Volume 13, Issue 73
  8. Archive-name: slice
  9.  
  10. Slice splits up a file into lots of little files.  It reads its input
  11. a line at a time, and starts a new output file when
  12.  
  13.     *  the input line matches a pattern, or
  14.     *  there have been n lines written to the current output file.
  15.  
  16. You can use it to split a mailbox or an archive of news articles into
  17. one article per file, for example.  In fact, you can do this with
  18. about 5 lines of awk, but you run into problems with long lines (and
  19. speed, if it bothers you!).
  20.  
  21. Slice was originally contributed by Russell Quinn as the program
  22. "mailsplit".  It was subsequently revised by me and posted to
  23. net.sources.  A patch for System V was also issued.  Since then, I've
  24. made quite a few changes, enough so that this version is not 100%
  25. compatible with the net.sources versions.  Also, I've not retested
  26. this version on System V, so there may be some problems.
  27.  
  28. Slice allows multiple output formats to be specified (rather than
  29. multiple input files).  This makes it possible to deposit the pieces
  30. (slices!) into files named whatever your want.  For example:
  31.  
  32.      slice -f article -x -r README '^--* [Cc]ut' article.sh
  33.  
  34. will deposit everything up to the cut line into README and everything
  35. after it into article.sh.  The -x option causes the matched line to be
  36. excluded.  The -r option specifies the destination of rejected lines
  37. (which in this example includes all lines appearing before the cut line).
  38.  
  39. There are even options to make slicing mailboxes and files containing
  40. shell scripts easier (-m and -s).  The mailbox option enables you to
  41. easily reorder messages in your mailbox into proper date sequence:
  42. just slice the mailbox with -m then cat the resulting files back
  43. together.  This neat trick is accomplished by the use of substitution
  44. parameters in the output pattern.  If an output pattern contains, say,
  45. a #3 then the 3rd token from each matched line is substituted into the
  46. file name.  Thus, to split a mailbox the default output pattern causes
  47. each message to be put in a file whose name is constructed from the
  48. date and time on the "From" line.
  49.  
  50. There are some good examples in the man page.
  51.  
  52. Source, Makefile and manual entry enclosed.  To install, do the
  53. following:
  54.  
  55. 1:    Edit the Makefile: you'll need to alter the "R=/usr/local" if 
  56.     you don't want slice to live in /usr/local/usr/bin.
  57.  
  58. 2:    make slice
  59.  
  60. 3:    have a play with it & satisfy yourself that it behaves reasonably
  61.  
  62. 4:    make install
  63.  
  64. Make "install" will do a "$(MAKE) $(CLEAN)" afterwards.  If you don't 
  65. want to remove the binary, say
  66.  
  67.         CLEAN="" make install
  68.  
  69. at step 4.
  70.  
  71.  
  72. --------------------- cut here ----------------------------------------
  73. #!/bin/sh
  74. # This is a shell archive, meaning:
  75. # 1. Remove everything above the #!/bin/sh line.
  76. # 2. Save the resulting text in a file.
  77. # 3. Execute the file with /bin/sh (not csh) to create the files:
  78. #    slice.1
  79. #    Makefile
  80. #    opts.h
  81. #    slice.c
  82. #    CHANGES
  83. # By:    Gary Puckering ()
  84. export PATH; PATH=/bin:$PATH
  85. echo shar: extracting "'slice.1'" '(10249 characters)'
  86. if test -f 'slice.1'
  87. then
  88.     echo shar: over-writing existing file "'slice.1'"
  89. fi
  90. sed 's/^X//' << \SHAR_EOF > 'slice.1'
  91. X.TH SLICE 1L "1987 September 14" "Cognos Inc."
  92. X.SH NAME
  93. Xslice \- split a file into pieces, by pattern or every n'th line
  94. X.SH SYNOPSIS
  95. X.B slice
  96. X.tr _-
  97. X[\|\fB_f\ \fIfilename\fP\|]
  98. X[\|\fB_i\fP\fIn\fP\|]
  99. X[\|\fB_a\fP\|]
  100. X[\|\fB_x\fP\|]
  101. X[\|\fB_r\fP\ \fIrejectfile\fP\|]
  102. X[\|\fB_\&m\fP\||\ \fB_\&s\fP\||\ \fB_\&n\fP\fIn\fP\|]
  103. X[\|\fIformat\fP\ .\|.\|.\|]
  104. X.LP
  105. X.sp
  106. X.B slice
  107. X[\|\fB_f\ \fIfilename\fP\|]
  108. X[\|\fB_i\fP\fIn\fP\|]
  109. X[\|\fB_a\fP\|]
  110. X[\|\fB_x\fP\|]
  111. X[\|\fB_r\fP\ \fIrejectfile\fP\|]
  112. X\ \fB_\&e\ \fIexpression\fP\ 
  113. X[\|\fIformat\fP\ .\|.\|.\|]
  114. X.LP
  115. X.sp
  116. X.B slice
  117. X[\|\fB_f\ \fIfilename\fP\|]
  118. X[\|\fB_i\fP\fIn\fP\|]
  119. X[\|\fB_a\fP\|]
  120. X[\|\fB_x\fP\|]
  121. X[\|\fB_r\fP\ \fIrejectfile\fP\|]
  122. X\ \fIexpression\fP\ 
  123. X[\|\fIformat\fP\ .\|.\|.\|]
  124. X.tr
  125. X.SH DESCRIPTION
  126. X.I Slice
  127. Xsplits a file into pieces (called \fIslices\fR) which are deposited
  128. Xinto one or more output files.  The output files are named according
  129. Xto the \fIformat\fR strings provided.  The input file is split
  130. Xwhenever a pattern is matched or every \fIn\fR lines, depending on the
  131. Xoptions selected.  Because some of the options are mutually exclusive,
  132. Xthere are three forms of the command.
  133. X.LP
  134. XWhenever a pattern match is used to slice the file, lines occurring
  135. Xbefore the first match are sent to the \fIreject\fR file (which is
  136. X\fI/dev/null\fR by default).  Lines are also rejected when an output file
  137. Xcannot be opened, for whatever reason.
  138. X.LP
  139. X.SH OPTIONS
  140. X.LP
  141. X.IP "\fB-f\fR \fIfilename\fR"
  142. XInput for \fIslice\fR is taken from the named file rather than \fIstdin\fR.
  143. X.IP "\fB-i\fP\fIn\fP"
  144. XThe starting number for numbering output files generated by formats
  145. Xcontaining "#\&n" (see \fISubstitutions\fR below).  The default
  146. Xstarting number is one.
  147. X.IP "\fB-a\fR"
  148. XCauses the file to be split \fBafter\fR the line matching the pattern,
  149. Xrather than before (as is normally the case).  This option will not
  150. Xwork properly if an output format contains the substitution parameters
  151. X"#\&1", "#\&2", etc.  (See \fIformat\fR below).
  152. X.IP "\fB-x\fR"
  153. XCauses the matched line to be excluded from the output files.  Handy
  154. Xfor eliminating cut lines, etc.
  155. X.IP "\fB-m\fR"
  156. XUses the pattern "^From " to split the file.  This is convenient for
  157. Xbreaking up a mailbox file.  It also changes the default output
  158. Xpattern so that the output files are named according to the date and
  159. Xtime of each message.  This makes it easy to sort the messages in a
  160. Xmailbox into chronological order \- just slice the box and cat the
  161. Xresulting files back together again.
  162. X.IP "\fB-s\fR"
  163. XUses the pattern "^#\&!\ */bin/sh" to split the file.  This is ideal for
  164. Xbreaking up mail or news article containing a Bourne shell script.
  165. X.IP "\fB-n\fIn\fR"
  166. XSplit the file every \fIn\fR lines.  In this case, no pattern matching 
  167. Xis performed.  This is the behaviour of \fIsplit (1)\fR,
  168. Xexcept that the default output filename format for
  169. X\fIslice\fR is different.
  170. X.IP "\fB-r\fR \fIrejectfile\fR"
  171. XEstablishes the name of a file to which rejected lines are sent
  172. X(default is \fI/dev/null\fR).  Lines appearing before the first matched
  173. Xpattern are rejected.  Also, any time an output file cannot be opened,
  174. Xsource lines are sent to the reject file instead.  Substitution
  175. Xparameters are not allowed in the reject file name, but a leading "+"
  176. Xis allowed (to indicated that the reject file should be opened for append).
  177. XThe name \fIstderr\fR can also be used for the standard error file.
  178. X.IP "\fB-e\fR \fIexpression\fR"
  179. XUses the pattern specified by \fIexpression\fR to identify where the
  180. Xfile is to be split.  The pattern may contain newlines (which match
  181. Xthemselves).  See
  182. X.I ed (1)
  183. Xfor details of the regular expressions.
  184. X.IP \fIformat\fR
  185. XAll three forms of the command allow the specification of zero or more
  186. X\fIformat\fR strings as non-flag parameters.  Formats are used to
  187. Xgenerate output filenames.  You can provide as many as you like.
  188. XEvery time a split is required, a format is used to generate the file
  189. Xname.  If the name is the same as the last name generated from that
  190. Xformat, a new format is selected.  If \fIslice\fR runs out of formats,
  191. Xa warning will be issued (unless the last output file is \fIstdout\fR)
  192. Xand the remaining lines will be sent to the reject file.  The format
  193. Xstrings can contain substitution parameters.  
  194. X.SH SUBSTITUTIONS
  195. X.IP "#\&f"
  196. XThe name of the input file, less any leading pathname, is substituted.
  197. XIf the input file is \fIstdin\fR, the name \fIslice\fR is used.
  198. X.IP "#\&n"
  199. XA unique number, beginning with the value specified in the \fB-i\fR
  200. Xoption, is substituted.  This number is incremented by 1 for each
  201. Xoutput file produced by the current output format.  When an output
  202. Xformat produces the same name twice, a new format is selected and
  203. Xnumbering begins again with the initial value.
  204. X.IP "#\&1, #\&2 ..."
  205. XParameters of the form #\&1, #\&2, ... #\&9 are replaced by corresponding
  206. Xtokens drawn from the source line which matched the slice pattern.
  207. XFor example, if each procedure in a C program began with a comment
  208. Xline of the following form:
  209. X.sp
  210. X\ \ \ \ /\&* Procedure:\ \ \ main */
  211. X.br
  212. X\ \ \ \ #\&1\ \ \ #\&2\ \ \ \ \ \ \ \ \ \ \ #\&3\ \ #\&4 
  213. X.IP
  214. Xthen parameter #\&3 could be used to extract the procedure name (in
  215. Xthis case, "main").  If #\&3 appears in an output format, it will be
  216. Xreplaced by this value.
  217. X.IP "#$"
  218. XThis parameter is used to select the last non-blank parameter on the
  219. Xmatched line.  For example, if the matched line were:
  220. X.sp
  221. X\ \ \ \ \From garyp@cognos Tue Sep 15 15:08:23 EDT 1987
  222. X.sp
  223. Xthen "#$" would select "1987", the last token on the line.
  224. X.SH FORMAT SPEC's
  225. X.LP
  226. XSubstitution parameters can be followed by an optional 
  227. X.I printf 
  228. Xstyle format specification.  They can be used to control the width of
  229. Xthe field and formatting of a numeric token into a string.
  230. X.LP
  231. XIf a numeric format like %d is used, the token is assumed to contain
  232. Xan integer value and the function \fIatoi\fR is used to convert it.
  233. XThe resulting value is then formatted with \fIsprintf\fR using the
  234. Xformat code.
  235. X.LP
  236. XFor example, the output format zzz.#\&n%02d will produce files of the
  237. Xform zzz.01, zzz.02, zzz.03, etc.  The #\&n is replaced with the current
  238. Xcount value, which is then formatted by %02d (signed decimal integer,
  239. X2 digits wide, print leading zeros).
  240. X.LP
  241. XFloating point format codes ("f", "e" and "g") are not allowed, nor is the
  242. Xsingle-character code "c".
  243. X.LP
  244. XThere is a special format code (not one of the usual \fIprintf\fR set)
  245. Xfor conversion of 3 character month names to numbers.  The code "m"
  246. Xcan be used to convert "Jan", "Feb", ...  "Dec" to the numbers 1, 2,
  247. X\&... 12.  The numeric month value is then formatted as if the format
  248. Xstring were of the %d type.  For example, the code %02m will result in
  249. Xthe month name token "Aug" being transformed into the string "08".
  250. X.SH DEFAULT FORMATS
  251. XIf no output formats are supplied, the following default format is used:
  252. X.sp .5v
  253. X\ \ \ \ #\&f:#\&n%03d
  254. X.sp .5v
  255. XThis results in files having names like \fIfilename\fR:001, 
  256. X\fIfilename\fR:002, \fIfilename\fR:003 and so on.  
  257. XThe default format was chosen because the resulting files are listed 
  258. Xin numerical order by
  259. X.I ls
  260. Xor by
  261. X.I echo *
  262. Xwhich is sometimes useful.
  263. X.LP
  264. XIf the \fB-m\fR option is used, the default output format is:
  265. X.sp .5v
  266. X\ \ \ \ #\&f:#\&$-#\&4%02m-#\&5%02d.#\&6
  267. X.sp .5v
  268. Xwhich results in files have names like \fIfilename\fR:1987-01-25.08:15:30.
  269. XThe date and time are taken from the "From" line of each message in
  270. Xthe mailbox.  
  271. X.LP
  272. XYou can take advantage of this naming convention to reassemble the
  273. Xmessages in chronological order by \fIcat\fR'ing the files back
  274. Xtogether again using the command:
  275. X.sp
  276. X\ \ \ \ cat \fIfilename\fR:*\ \  >\fImailbox.new\fR
  277. X.SH SPECIAL CONVENTIONS
  278. X.LP
  279. XNormally, \fIslice\fR opens each output file for "write".  By
  280. Xprepending an output format string with "+" (a plus sign) the
  281. Xdesignated output file will be opened for "append".  Thus, a filename
  282. Xcan appear more than once.
  283. X.LP
  284. XIf a format string is simply a "+", then \fIstdout\fR is
  285. Xused.  This is handy for piping one of the pieces to another
  286. Xcommand.  
  287. X.LP
  288. XThe special format string "@" is used as an abbreviation for
  289. X/dev/null.  This is handy for throwing away slices.
  290. X.LP
  291. X.SH EXAMPLES
  292. XSplit up a mail folder into a series of files, one for each message,
  293. Xnamed after the folder and date/time of each message.
  294. X.sp
  295. X    slice -m -f FOLDER
  296. X.sp
  297. XPipe a news article containing a shell script to slice, saving
  298. Xeverything before the line "#!/bin/sh" line to a file named HEADER and
  299. Xpiping the script portion to \fIsh\fR to unshar it:
  300. X.sp
  301. X    | slice -s -r HEADER +\ \ | sh
  302. X.sp
  303. XSplit \fIstdin\fR at every line of dashes into the files 0, 1, 2, etc.:
  304. X.sp
  305. X    cat anyfile | slice -i0\ \  "^--* *$"\ \  #\&n
  306. X.sp
  307. XPipe the middle portion of a file to sh, keeping the head and tail in a
  308. Xfile called README.  Exclude the cut lines:
  309. X.sp
  310. X    slice -f myfile -x -r README "^--* [Cc]ut "\ \ +\ \ +README\ \ | sh
  311. X.sp
  312. XKeep the middle portion of a file, discarding the head and tail:
  313. X.sp
  314. X    slice -f myfile -r @ "^--* [Cc]ut "\ \ middle @
  315. X.sp
  316. XSplit a C program which has an identifying comment before each
  317. Xprocedure into separate files for each procedure (named after the
  318. Xprocedure): 
  319. X.sp
  320. X    slice -f program.c "/[*] *Procedure: *.* *[*]/"\ \  #\&3.c
  321. X.sp
  322. X.SH BUGS
  323. X.IP a) 4
  324. XWatch out for filename expansion by the shell.  This could cause
  325. X\fIslice\fR to interpret the extra filenames as output formats causing
  326. Xfiles to be overwritten.  To be safe, do "set noclobber" in csh.
  327. X.IP b) 4
  328. XWhen the -a option is used and an output format contains token
  329. Xsubstitutions (#\&1, #\&2, etc.) the wrong filenames are generated.  To
  330. Xgenerate the correct filenames, either slice has to lookahead to find
  331. Xthe next match line or it has to direct lines for the current slice
  332. Xinto a temporary file until it finds the line matching the pattern.
  333. X.SH DIAGNOSTICS
  334. X``Internal Error'' indicates a bug in \fIslice\fR, and should be reported.
  335. XExit status 1 indicates an error parsing options \- for example, if an unknown
  336. Xflag was used.
  337. XExit status 2 indicates a meaningless combination was detected and rejected.
  338. XExit status 3 indicates a run-time problem \- for example, if a file couldn't
  339. Xbe opened.
  340. X.LP
  341. XIf a reject file is not provided, a count of rejected lines is reported.
  342. X.SH "SEE ALSO"
  343. X.I cat (1),
  344. X.I ed (1),
  345. X.I ls (1),
  346. X.I mail (1),
  347. X.I split (1),
  348. X.I mailsplit (1L),
  349. X.I atoi (3),
  350. X.I printf (3).
  351. SHAR_EOF
  352. if test 10249 -ne "`wc -c 'slice.1'`"
  353. then
  354.     echo shar: error transmitting "'slice.1'" '(should have been 10249 characters)'
  355. fi
  356. echo shar: extracting "'Makefile'" '(1301 characters)'
  357. if test -f 'Makefile'
  358. then
  359.     echo shar: over-writing existing file "'Makefile'"
  360. fi
  361. sed 's/^X//' << \SHAR_EOF > 'Makefile'
  362. X# Makefile for slice
  363. X#
  364. X# Originally contributed at mailsplit, written by:
  365. X#   R E Quin, October 1986 University of Warwick (UK) Computer Science
  366. X#   warwick!req     +44 203 523193
  367. X#
  368. X# Modified and recontributed by:
  369. X#   Gary Puckering        3755 Riverside Dr.
  370. X#   Cognos Incorporated   Ottawa, Ontario
  371. X#   (613) 738-1440        CANADA  K1G 3N3
  372. X#
  373. X# This makefile is intended for the sys5 Augmented make.
  374. X# 
  375. XMAKE=make 
  376. XCLEAN=clean 
  377. XCC=cc 
  378. X
  379. X# R is the root of the filesystem -- i.e. where to install things.
  380. X# PROG is what to make; BINDIR is where to put it.
  381. X# The binaries are installed in $R/$(BINDIR).
  382. XR=/usr/local
  383. XBINDIR=$R/bin
  384. XMANDIR=$R/man/man1
  385. XPROG=slice 
  386. XMANPAGE=slice.1
  387. X
  388. X# HACKS are for -DBUGFIX style things.
  389. XHACKS=
  390. X
  391. X# For BSD 4.2 or 4.3
  392. XUSG=
  393. X
  394. X# For USG System V version
  395. X# USG=-DUSG -lPW
  396. X
  397. XCFLAGS=-O $(HACKS) $(USG)
  398. X
  399. X
  400. X# "make install " does a $(MAKE) $(CLEAN) at the end, so you can say
  401. X# CLEAN=  make -e install
  402. X# if you don't want to remove the garbage at the end, for example.
  403. X# This is useful primarily for testing the install: entry!
  404. X
  405. Xall: $(PROG)
  406. X 
  407. Xslice: opts.h slice.o
  408. X    $(CC) $(CFLAGS) -o $(PROG) slice.o
  409. X 
  410. Xinstall: slice slice.1
  411. X    chmod a+x $(PROG)
  412. X    /bin/cp $(PROG) $(BINDIR)
  413. X    chmod a+r $(MANPAGE)
  414. X    /bin/cp $(MANPAGE) $(MANDIR)
  415. X    $(MAKE) $(CLEAN)
  416. X 
  417. Xclean: 
  418. X    rm -rf core *.o $(PROG) a.out
  419. SHAR_EOF
  420. if test 1301 -ne "`wc -c 'Makefile'`"
  421. then
  422.     echo shar: error transmitting "'Makefile'" '(should have been 1301 characters)'
  423. fi
  424. echo shar: extracting "'opts.h'" '(1008 characters)'
  425. if test -f 'opts.h'
  426. then
  427.     echo shar: over-writing existing file "'opts.h'"
  428. fi
  429. sed 's/^X//' << \SHAR_EOF > 'opts.h'
  430. X
  431. X#define FALSE 0
  432. X#define TRUE 1
  433. Xtypedef int bool;
  434. X
  435. X#define EXIT_SYNTAX 1    /* syntax error parsing commandline options */
  436. X#define EXIT_SEMANT 2    /* options are correct but meaningless */
  437. X#define EXIT_RUNERR 3    /* error opening a file, for example */
  438. X#define EXIT_INTERN 4    /* internal error -- bug!! */
  439. X
  440. X#define nextstr(s,count,array,failure)    \
  441. X    {if (((count)<2) && !((array)[0][1])) {failure;}\
  442. X    else {if ((array)[0][1]) { s = &((array)[0][1]); } \
  443. X          else {s = array[1]; --count; array++;}}}
  444. X
  445. X#define DFLTNAME "slice"    /* input filename (for stdin) */
  446. X#define DFLTREJECT "/dev/null" /* default reject file */
  447. X#define BUFLEN BUFSIZ    /* the maximum length of an input line (incl. "\n\0") */
  448. X#define MAXFILENAMELEN BUFSIZ    /* longer than the longest possible file name */
  449. X#define DFLTOUTNAME    "#f:#n%03d"    /* o/p file name format */
  450. X#define MBOXFORMAT  "+#f:#$-#4%02m-#5%02d.#6"    /* default for mailbox */
  451. X#define MAXPARM 9                /* maximum parm index value */
  452. X#define PARMESCAPE '#'            /* parameter escape character */
  453. SHAR_EOF
  454. if test 1008 -ne "`wc -c 'opts.h'`"
  455. then
  456.     echo shar: error transmitting "'opts.h'" '(should have been 1008 characters)'
  457. fi
  458. echo shar: extracting "'slice.c'" '(15915 characters)'
  459. if test -f 'slice.c'
  460. then
  461.     echo shar: over-writing existing file "'slice.c'"
  462. fi
  463. sed 's/^X//' << \SHAR_EOF > 'slice.c'
  464. X/*
  465. X *    Program name:  slice
  466. X *
  467. X *    Copyright (c) 1987 by Gary Puckering
  468. X *
  469. X *    This program may be freely used and/or modified, 
  470. X *    with the following provisions:
  471. X *    1. This notice and the above copyright notice must remain intact.
  472. X *    2. Neither this program, nor any modification of it,
  473. X *       may be sold for profit without written consent of the author.
  474. X *
  475. X *    -----------------------------------------------------------------
  476. X *
  477. X *    This program allows you to cut a file into pieces, either at every
  478. X *  n lines (like fsplit) or based on a pattern match.  Slices are sent
  479. X *  to output files, which are named by providing a format string.  A
  480. X *  file name may be a constant, or may contain substitution parameters,
  481. X *  such as #f for the input file name or #1, #2, ... #9 for tokens
  482. X *  1 through 9 on the line matching the pattern.
  483. X *
  484. X *    -----------------------------------------------------------------
  485. X */
  486. X
  487. Xchar version[] = "@(#)slice.c    2.4";
  488. X
  489. X#include <stdio.h>
  490. X#include <ctype.h>
  491. X#include <string.h>
  492. X#include <sys/file.h>
  493. X
  494. X#include "opts.h"                /* defines nextstr() etc */
  495. X
  496. Xbool exclude = FALSE;            /* exclude matched line from o/p files */
  497. Xbool split_after = FALSE;        /* split after matched line */
  498. Xbool m_flag = FALSE;            /* was -m option used */
  499. X
  500. XFILE *output = (FILE *) NULL;    /* fd of current output file */
  501. XFILE *rejectfd = (FILE *) NULL;    /* fd of reject file */
  502. X
  503. Xint  n_format;                    /* number of format strings */
  504. Xint  filenumber = 0;            /* #n substitution for each file */
  505. Xint  every_n_lines = 0;            /* split every n lines */
  506. Xint rejectcnt = 0;                /* count of rejected lines */
  507. X
  508. Xchar inbuffer[BUFLEN];            /* input buffer */
  509. Xchar *progname = "slice";        /* for error messages */
  510. Xchar *pattern = (char *) NULL;    /* reg expr used to split file */
  511. Xchar **format;                    /* ptr for format strings */
  512. Xchar *defaultfmt[] = {DFLTOUTNAME};    /* default format string */
  513. Xchar *mboxformat[] = {MBOXFORMAT};    /* default format for mailboxes */
  514. Xchar parmbuf[BUFLEN];            /* parameter buffer */
  515. Xchar *parm[MAXPARM+1];            /* array of pointers to parms */
  516. Xchar nullstring[1] = {""};        /* a null string */
  517. Xchar *infile = (char *) NULL;    /* input file name */
  518. Xchar rejectfile[MAXFILENAMELEN+2] = {DFLTREJECT}; /* reject file name */
  519. X
  520. X/* forward declarations */
  521. XFILE * openfile();
  522. XFILE * mkreject();
  523. Xchar * mkname();
  524. Xchar * rmpath();
  525. Xchar   getfmt();
  526. X
  527. X
  528. Xmain(argc, argv)
  529. X    char *argv[];
  530. X{
  531. X    /* split files at points that match a given pattern */
  532. X
  533. X    /* initialise things */
  534. X    char *buffer;
  535. X    int i;
  536. X    int getnum();        /* does more checking than atoi */
  537. X    char *rmpath();    /* removes leading pathname from a filename */
  538. X
  539. X    for (i=0; i<=MAXPARM; i++) parm[i] = nullstring;
  540. X
  541. X    /* now remove possible leading pathname
  542. X     * (e.g. /usr/bin/slice is to report it's errors as slice
  543. X    */
  544. X    progname = rmpath(argv[0]);
  545. X
  546. X
  547. X    while (--argc) {
  548. X      if (**++argv == '-') {
  549. X        switch(*++*argv) {
  550. X            case 'a': {                /* split after pattern */
  551. X                split_after = TRUE;
  552. X                break;
  553. X            }
  554. X            case 'e': {                /* pattern (expression) */
  555. X                ++argv; argc--;
  556. X                if (argc==0 || !**argv) {
  557. X                    error("Pattern after -e missing or null\n");
  558. X                    usage(1);
  559. X                }
  560. X                pattern = *argv;
  561. X                break;
  562. X            }
  563. X            case 'm': {                /* mailbox pattern */
  564. X                pattern = "^From ";
  565. X                m_flag = TRUE;
  566. X                break; 
  567. X            }
  568. X            case 's': {                /* shell pattern */
  569. X                pattern = "^#! *\/bin\/sh";
  570. X                break; 
  571. X            }
  572. X            case 'n': {                /* -n n_lines -- split every n lines */
  573. X                nextstr(buffer,argc,argv,usage(2));
  574. X                every_n_lines = getnum(buffer);
  575. X                if (every_n_lines <= 0) {
  576. X                    error("-n: number must be at least 1\n");
  577. X                    exit(EXIT_SYNTAX);
  578. X                }
  579. X                break;
  580. X            } 
  581. X            case 'f': {
  582. X                ++argv; argc--;
  583. X                if (argc==0 || !**argv) {
  584. X                    error("Filename after -f missing or null\n");
  585. X                    usage(1);
  586. X                }
  587. X                infile = *argv;
  588. X                break;
  589. X            }                
  590. X            case 'r': {
  591. X                ++argv; argc--;
  592. X                if (argc==0 ||!**argv) {
  593. X                    error("Filename after -r missing or null\n");
  594. X                    usage(1);
  595. X                }
  596. X                strcpy(rejectfile,*argv);
  597. X                break;
  598. X            }
  599. X            case 'i': {    /* -i initial_number */
  600. X                nextstr(buffer,argc,argv,usage(2));
  601. X                filenumber = getnum(buffer);
  602. X                if (filenumber < 0) {
  603. X                    error("-i must be followed by a positive number\n");
  604. X                    exit(EXIT_SYNTAX);
  605. X                 }
  606. X                filenumber--;    /* needs to be one less to start with */
  607. X                break;
  608. X            }
  609. X            case 'x': { /* exclude matched lines */
  610. X                exclude = TRUE;
  611. X                break;
  612. X            }
  613. X            default: {
  614. X                error("Unknown flag -%c\n", **argv);
  615. X                usage(1);
  616. X            }
  617. X        }            /* end switch */
  618. X      } else {    
  619. X        if (!pattern) pattern = *argv;    /* first non-flag is pattern */
  620. X        else break;                        /* break while loop */
  621. X      }            /* end if */
  622. X     }        /* end while */
  623. X
  624. X     if (!argc) {
  625. X        if (m_flag) {
  626. X            format = mboxformat;
  627. X        } else {
  628. X            format = defaultfmt;
  629. X        }
  630. X        n_format = 1; 
  631. X     } else {
  632. X        format = argv;
  633. X        n_format = argc;
  634. X     }
  635. X
  636. X#ifdef DEBUG
  637. X    printf("argc=%d\n",argc);
  638. X    printf("format='%s'\n",*format);
  639. X    printf("pattern='%s'\n",pattern);
  640. X#endif
  641. X
  642. X     if (!infile) split(stdin, DFLTNAME, pattern);
  643. X     else        fsplit(infile, pattern);
  644. X
  645. X     exit(0);
  646. X}
  647. X
  648. X
  649. X/* split a file that hasn't been opened yet */
  650. X
  651. Xfsplit(name, pat)
  652. X     char *name;
  653. X     char *pat;
  654. X{
  655. X     FILE *fd;
  656. X
  657. X     if (!name || !*name) {
  658. X      error("Can't split a file with an empty name\n");
  659. X      usage(2);
  660. X     }
  661. X
  662. X     if ( (fd = fopen(name, "r")) == NULL) {
  663. X      error("Can't open %s\n", name);
  664. X      return;
  665. X     }
  666. X
  667. X     (void) split(fd, name, pat);
  668. X
  669. X     if (fclose(fd) == EOF) {    /* something's gone wrong */
  670. X      error("Can't close %s -- giving up\n", name);
  671. X      exit(EXIT_RUNERR);
  672. X     }
  673. X}
  674. X
  675. X
  676. X/* Split a file that's already been opened */
  677. X
  678. Xsplit(input, name, pattern)
  679. X     FILE *input;        /* fd of input file */
  680. X     char *name;        /* input filename */
  681. X     char *pattern;        /* pattern used to split file */
  682. X{
  683. X
  684. X#ifndef USG
  685. X     extern char *re_comp();     /* compile string into automaton */
  686. X     extern int   re_exec();    /* try to match string */
  687. X     int reg_status = 0;    /* regular expression status */
  688. X     char *errmessage;
  689. X#define REMATCH 1
  690. X#define RENOMATCH 0
  691. X#define REFAULT -1
  692. X#define match(expr) ((expr) == REMATCH)
  693. X#else
  694. X     extern char *regcmp();    /* compile string into automaton */
  695. X     extern char *regex();    /* match string with automaton */
  696. X     char *reg_status;        /* regular expression status */
  697. X     char *rex;
  698. X#define match(expr) ((expr) != NULL)
  699. X#endif
  700. X
  701. X     char *fname;
  702. X     int line = 0;
  703. X
  704. X     rejectcnt = 0;
  705. X
  706. X     if (split_after && exclude) {
  707. X      error("Can't specify both -a and -x\n");
  708. X      usage(2);
  709. X     }
  710. X
  711. X     if (every_n_lines && exclude) {
  712. X      error("Can't specify both -n and -x\n");
  713. X      usage(2);
  714. X     }
  715. X
  716. X     if (every_n_lines && split_after) {
  717. X      error("Can't specify both -n and -a\n");
  718. X      usage(2);
  719. X     }
  720. X
  721. X     if (every_n_lines && pattern) {
  722. X      error("Can't specify both -n and pattern\n");
  723. X      usage(2);
  724. X     }
  725. X
  726. X     if (!every_n_lines && (!pattern || !*pattern)) {
  727. X      error("Can't match an empty pattern\n");
  728. X      usage(2);
  729. X     }
  730. X
  731. X#ifndef USG
  732. X     if (!every_n_lines && (errmessage = re_comp(pattern)) != NULL) {
  733. X      error("Error in pattern <%s>: %s\n", pattern, errmessage);
  734. X      exit(EXIT_RUNERR);
  735. X     }
  736. X     /* errmessage is NULL here */
  737. X#else
  738. X     if (!every_n_lines && (rex = regcmp(pattern,(char *)0)) == NULL) {
  739. X      error("Erron in pattern <%s>\n", pattern);
  740. X      exit(EXIT_RUNERR);
  741. X     }
  742. X     /* rex is pointer to compiled expression.... */
  743. X#endif
  744. X
  745. X    /* if split after mode, open file at start */
  746. X    if (split_after) {
  747. X        fname = mkname(name);
  748. X        output = openfile(fname);
  749. X}
  750. X    
  751. X     /* the -2 to fgets is because of the null and \n appended */
  752. X     while (fgets(inbuffer, BUFLEN - 2, input) != NULL) {
  753. X
  754. X      if ((every_n_lines > 0 && (++line == every_n_lines)) ||     /* nth line */
  755. X         (!every_n_lines &&
  756. X#ifndef USG
  757. X         ( match(reg_status = re_exec(inbuffer) ) ) ) ) {         /* matches pat */
  758. X#else
  759. X         ( match(reg_status = regex(rex, inbuffer) ) ) ) ) {         /* matches pat */
  760. X#endif
  761. X
  762. X            if (split_after) putbuff(inbuffer,output);
  763. X
  764. X            if (!every_n_lines) get_parms(inbuffer);
  765. X            
  766. X            /* close the current file */
  767. X            if (output && output != stderr && 
  768. X                          output != stdout &&
  769. X                          output != rejectfd) {
  770. X                if (fclose(output) == EOF) {
  771. X                    error("Can't close output file\n");
  772. X                    exit(EXIT_RUNERR);
  773. X                }
  774. X            }
  775. X
  776. X            fname = mkname(name);
  777. X
  778. X            if (*fname) {
  779. X                /* open a new file */
  780. X                output = openfile(fname);
  781. X            } else {
  782. X                /* no filename to open, so use reject file */
  783. X                error("Insufficient formats -- remainder rejected\n");
  784. X                output = (FILE *) NULL;
  785. X            }
  786. X
  787. X            line = 0;  /* reset input line count */
  788. X
  789. X            /* if matched lines are excluded, skip the putbuff */
  790. X            if (exclude && match(reg_status)) continue;
  791. X
  792. X            /* if file is to be split after pattern, put already done */
  793. X            if (split_after && match(reg_status)) continue;
  794. X#ifndef USG
  795. X      } else {
  796. X              if (reg_status == REFAULT) {    /* the re_exec failed */
  797. X                error("Internal error trying to match <%s> to <%s>\n",pattern, inbuffer);
  798. X                exit(EXIT_INTERN);
  799. X            }
  800. X#endif
  801. X      }  /* end match pattern test  */
  802. X
  803. X      putbuff(inbuffer, output);        /* now put line out */
  804. X
  805. X      }  /* end while */
  806. X
  807. X      if (rejectcnt && strcmp(rejectfile,"/dev/null")==0) {
  808. X          error("%d lines rejected to /dev/null\n",rejectcnt);
  809. X      }
  810. X      
  811. X      return (filenumber == -1);    /* exit status for main */
  812. X}
  813. X
  814. X
  815. X/* Make a reject file */
  816. X
  817. XFILE *
  818. Xmkreject()
  819. X{
  820. X    if (rejectfd) return(rejectfd);    /* if there's already one, don't bother */
  821. X
  822. X    if ( strcmp(rejectfile,"stderr")==0 ) 
  823. X            rejectfd = stderr;
  824. X    else    rejectfd = openfile(rejectfile);
  825. X
  826. X    if (!rejectfd) {
  827. X        error("Cannot open reject file %s\n",rejectfile);
  828. X        exit(EXIT_RUNERR);
  829. X    }
  830. X
  831. X    return (rejectfd);
  832. X}
  833. X
  834. X
  835. X/* Open an output file (or the reject file) */
  836. X
  837. X/* If filename starts with '+' open for append */
  838. X/* If filename is '@' use /dev/null */
  839. X
  840. XFILE *
  841. Xopenfile(fname)
  842. X    char *fname;                /* file to be opened */
  843. X{
  844. X    FILE *fd = (FILE *) NULL;
  845. X    bool exists = FALSE;
  846. X
  847. X    switch (fname[0]) {
  848. X        case '+': {
  849. X            fname++;
  850. X            /* check for output file = input file */
  851. X            if (infile && (strcmp(fname,infile)==0) ) {
  852. X                error("Output file %s same as input file -- slice rejected\n",fname);
  853. X                break;
  854. X            }
  855. X            if (fname[0]==NULL) {
  856. X                fd = stdout;
  857. X                break;
  858. X            } else {
  859. X                if ((fd = fopen(fname, "a")) == NULL) {
  860. X                    error("Can't open output file %s for append -- slice rejected\n", fname[1]);
  861. X                    break;
  862. X                }
  863. X            }
  864. X            break;
  865. X        }
  866. X        case '@': {
  867. X            fname++;
  868. X            if (fname[0]==NULL) {
  869. X                if ((fd = fopen("/dev/null", "w")) == NULL) {
  870. X                    error("Can't open output file /dev/null -- slice rejected\n");
  871. X                    break;
  872. X                }
  873. X                break;
  874. X            } else {
  875. X                fname--;
  876. X                /* fall through to process as normal filename */
  877. X            }
  878. X        }
  879. X        default: {
  880. X            if (access(fname,F_OK)==0) exists = TRUE;
  881. X            if ((fd = fopen(fname, "w")) == NULL) {
  882. X                error("Can't open output file %s for write -- slice rejected\n", fname);
  883. X                break;
  884. X            }
  885. X            if (exists && strcmp(fname,"/dev/null")!=0) {
  886. X                error("File %s overwritten\n",fname);
  887. X            }
  888. X        }
  889. X    }
  890. X    return (fd);
  891. X}
  892. X
  893. X
  894. X/* Make a new file name using a format string */
  895. X
  896. Xchar *
  897. Xmkname(name)
  898. X    char *name;        /* file name for #f substitution */
  899. X{
  900. X    static char fnambuf[MAXFILENAMELEN + 2]; /* +1 for null, +1 for overflow */
  901. X    static char lastname[MAXFILENAMELEN + 2];
  902. X
  903. X    int i, j;
  904. X    char *p, *q, *fn;
  905. X    char fmtcode;
  906. X    char fmt[MAXFILENAMELEN];
  907. X    char tempbuf[MAXFILENAMELEN];
  908. X
  909. X  do_format:
  910. X    for (p=(*format), q=fnambuf; *p; p++) {
  911. X        if (*p != PARMESCAPE) { 
  912. X            *q = *p; 
  913. X            q++;
  914. X        } else {
  915. X            *q = NULL;
  916. X            switch (*++p) {
  917. X                case PARMESCAPE: {
  918. X                    *q = PARMESCAPE;
  919. X                    q++;
  920. X                    break;
  921. X                }
  922. X                case 'f': {
  923. X                    fn = rmpath(name);
  924. X                    strcat(q,fn);
  925. X                    q += strlen(fn);
  926. X                    break;
  927. X                }
  928. X                case 'n': {
  929. X                    ++filenumber;
  930. X                    if (*(p+1) == '%') {
  931. X                        p++;
  932. X                        fmtcode = getfmt(fmt,p);
  933. X                        p += strlen(fmt) - 1;
  934. X                        sprintf(tempbuf,fmt,filenumber);
  935. X                    } else {
  936. X                        sprintf(tempbuf,"%d",filenumber);
  937. X                    }
  938. X                    strcat(q,tempbuf);
  939. X                    q += strlen(tempbuf);
  940. X                    break;
  941. X                }
  942. X                case '1':
  943. X                case '2':
  944. X                case '3':
  945. X                case '4':
  946. X                case '5':
  947. X                case '6':
  948. X                case '7':
  949. X                case '8':
  950. X                case '9': 
  951. X                case '$': {
  952. X                    if (*p == '$') {
  953. X                        i = lastparm();
  954. X                    } else {
  955. X                        i = (*p) - '1';
  956. X                    }
  957. X                    if (*(p+1) == '%') {
  958. X                        p++;
  959. X                        fmtcode = getfmt(fmt,p);
  960. X                        p += strlen(fmt) - 1;
  961. X                        if (fmtcode != 's') {
  962. X                            if (fmtcode == 'm') {
  963. X                                j = mtoi(parm[i]);
  964. X                            } else {
  965. X                                j = atoi(parm[i]);
  966. X                            }
  967. X                            sprintf(tempbuf,fmt,j);
  968. X                        } else {
  969. X                            sprintf(tempbuf,fmt,parm[i]);
  970. X                        }
  971. X                    } else {
  972. X                        strcpy(tempbuf,parm[i]);
  973. X                    }
  974. X                    strcat(q,tempbuf);
  975. X                    q += strlen(tempbuf);
  976. X                    break;
  977. X                }
  978. X                default: {
  979. X                    error("Invalid substitution #%c in format '%s'\n",*p,*format);
  980. X                    exit(EXIT_RUNERR);
  981. X                }
  982. X            }    /* end switch */
  983. X        }    /* end if-else */
  984. X    }    /* end for */
  985. X    
  986. X    *q = NULL;
  987. X
  988. X    /* if name is same, try next format */
  989. X    if (strcmp(fnambuf,lastname)==0) {
  990. X        if (n_format>1) {    /* must be a format left to try */
  991. X            format++;
  992. X            --n_format;
  993. X            filenumber=0;
  994. X            lastname[0] = NULL;
  995. X            goto do_format;
  996. X        } else {            /* we've run out of formats */
  997. X            fnambuf[0] = NULL;            
  998. X        }
  999. X    }
  1000. X
  1001. X    if (fnambuf[0]) strcpy(lastname,fnambuf);
  1002. X
  1003. X    return(fnambuf);
  1004. X
  1005. X} /* end routine */
  1006. X
  1007. X
  1008. X
  1009. X/* Get a printf-style format string from within an output format */
  1010. X
  1011. Xchar
  1012. Xgetfmt(fmt,p)        /* returns last character of string (format code) */
  1013. X    char *fmt;        /* target of format string */
  1014. X    char *p;        /* p should point to the '%' starting the format */
  1015. X{
  1016. X    char *q;
  1017. X    char fmtcode;
  1018. X
  1019. X    if (*p != '%') {
  1020. X        error("Internal error -- getfmt called when not pointing at %");
  1021. X        exit(EXIT_RUNERR);
  1022. X    }
  1023. X    q = strpbrk(p,"mduxhocsfeg");  /* 'm' is a special extension */
  1024. X    
  1025. X    if (!q) {
  1026. X        error("Can't find end of format spec");
  1027. X        exit(EXIT_RUNERR);
  1028. X    }
  1029. X
  1030. X    fmtcode = *q;
  1031. X    strncpy(fmt,p,(q-p+1));
  1032. X
  1033. X    switch (*q) {
  1034. X        case 'h':
  1035. X        case 'c':
  1036. X        case 'f':
  1037. X        case 'e':
  1038. X        case 'g': {
  1039. X            error("Format '%s' is not supported\n",fmt);
  1040. X            exit(EXIT_RUNERR);
  1041. X        }
  1042. X        case 'm': {
  1043. X            fmt[strlen(fmt) - 1] = 'd';    /* change to d */
  1044. X        }
  1045. X    }
  1046. X
  1047. X    return(fmtcode);
  1048. X}
  1049. X
  1050. X
  1051. X
  1052. X/* Write an input line to the output file */
  1053. X/* If the output file isn't open, write it to the reject file */
  1054. X
  1055. Xputbuff(buffer,fd)
  1056. X    char *buffer;
  1057. X    FILE *fd;
  1058. X{
  1059. X    if (fd) fputs(buffer,fd);
  1060. X    else {
  1061. X        rejectcnt++;
  1062. X        fputs( buffer,mkreject() );
  1063. X    }
  1064. X}
  1065. X
  1066. X
  1067. X
  1068. X/* getnum(s) returns the value of the unsigned int in s.  If there's any
  1069. X * trailing garbage, or the number isn't +ve, we return -1
  1070. X */
  1071. X
  1072. Xgetnum(s)
  1073. X     char *s;
  1074. X{
  1075. X     register char *p;
  1076. X
  1077. X     for (p = s; *p; p++) {
  1078. X      if (!isdigit(*p)) {
  1079. X           return -1;
  1080. X      }
  1081. X     }
  1082. X     return atoi(s);
  1083. X}
  1084. X
  1085. X
  1086. X
  1087. X/* Remove the leading pathname from a filename */
  1088. X
  1089. Xchar *
  1090. Xrmpath(fullname)
  1091. X    char *fullname;
  1092. X{
  1093. X    register char *p;
  1094. X    char *q = (char *) NULL;
  1095. X
  1096. X    for (p = fullname; p && *p; p++) {
  1097. X         if (*p == '/')
  1098. X          q = ++p;
  1099. X    }
  1100. X    if (q && *q) {
  1101. X         return(q);
  1102. X    }
  1103. X    return(fullname);
  1104. X}
  1105. X
  1106. X
  1107. X
  1108. X/* Get tokens (parameters) from matched input lines */
  1109. X
  1110. Xget_parms(buffer)
  1111. X    char *buffer;
  1112. X{
  1113. X    int  i,l;
  1114. X
  1115. X    strcpy(parmbuf,buffer);
  1116. X    l = strlen(parmbuf);
  1117. X    if(parmbuf[l-1]=='\n') parmbuf[l-1]=NULL;
  1118. X
  1119. X    parm[0]=strtok(parmbuf," ");
  1120. X
  1121. X    for (i=1; i<=MAXPARM; i++) {
  1122. X        parm[i]=strtok(NULL," ");
  1123. X    }
  1124. X
  1125. X    for (i=0; i<=MAXPARM; i++) {
  1126. X        if (!parm[i]) parm[i] = nullstring;
  1127. X    }
  1128. X}
  1129. X
  1130. X
  1131. X
  1132. X/* Find last non-null parameter */
  1133. X
  1134. Xlastparm()
  1135. X{
  1136. X    int i;
  1137. X
  1138. X    for (i=MAXPARM; i>0; i--) {
  1139. X        if (parm[i] && *parm[i]) return(i);
  1140. X    }
  1141. X    return(0);
  1142. X}
  1143. X
  1144. X
  1145. X
  1146. X/* Convert three character month name to integer */
  1147. X
  1148. Xmtoi(monthname)
  1149. X    char *monthname;
  1150. X{
  1151. X    static char *months[] = { 
  1152. X        "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  1153. X        "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
  1154. X        };
  1155. X
  1156. X    int i;
  1157. X
  1158. X    for (i=1; i<=12; i++) {
  1159. X        if (strcmp(monthname,months[i-1])==0) return(i);
  1160. X    }
  1161. X
  1162. X    error("Invalid month '%s' found -- zero used",monthname);
  1163. X    i=0;
  1164. X    return(i);
  1165. X}
  1166. X
  1167. X
  1168. Xerror(fmt, a1, a2, a3, a4)
  1169. X     char *fmt;
  1170. X{
  1171. X     fputs(progname, stderr);
  1172. X     fputs(": ", stderr);
  1173. X     fprintf(stderr, fmt, a1, a2, a3, a4);
  1174. X}
  1175. X
  1176. X
  1177. Xusage(status)
  1178. X     int status;    /* exit if status != 0 */
  1179. X{
  1180. X     fprintf(stderr,"Usage: %s [-f filename] [-a|-x] [-i<n>] [-w] [-m|-s|-n<n>] [-r file] [-e expression | expression] [format...]\n", progname);
  1181. X     if (status)
  1182. X      exit(status);
  1183. X}
  1184. X
  1185. SHAR_EOF
  1186. if test 15915 -ne "`wc -c 'slice.c'`"
  1187. then
  1188.     echo shar: error transmitting "'slice.c'" '(should have been 15915 characters)'
  1189. fi
  1190. echo shar: extracting "'CHANGES'" '(2731 characters)'
  1191. if test -f 'CHANGES'
  1192. then
  1193.     echo shar: over-writing existing file "'CHANGES'"
  1194. fi
  1195. sed 's/^X//' << \SHAR_EOF > 'CHANGES'
  1196. X 
  1197. X------------------------------ CHANGES ------------------------------
  1198. X
  1199. Xv2.3    87/09/20  21:36:52  garyp
  1200. X        Make default reject file /dev/null.  Report count of lines
  1201. X        rejected, unless reject file specified.
  1202. X
  1203. Xv2.2    87/09/15  17:33:33  garyp
  1204. X        Fix bug that caused dump when parm was null.  Changed mkname so
  1205. X        that the path is removed from the input filename.  Added #$
  1206. X        substitution parameter, to correctly split mailboxes.  Changed
  1207. X        the default pattern for -m to use #$ instead of #7.
  1208. X
  1209. Xv2.1    87/09/15  00:20:07  garyp
  1210. X        New release of slice, now supports substitution parameters.
  1211. X        Use of %s and %d replaced by #f and #n respectively.
  1212. X        Parameters #1, #2, ... #9 are replaced by tokens from the
  1213. X        matched line.  Printf-style format (e.g. %02d) may immediately
  1214. X        follow any substitution.
  1215. X
  1216. Xv1.12   87/09/10  17:05:04  garyp
  1217. X        Reject file now added.
  1218. X
  1219. Xv1.11   87/09/08  23:53:29  garyp
  1220. X        Add features "+<filename>" and "@"
  1221. X
  1222. Xv1.10   87/02/12  10:32:50  garyp
  1223. X        Minor revision to Sys V changes Added #define match() to reduce
  1224. X        number of #ifndef USG Added some comments
  1225. X
  1226. Xv1.9    87/02/09  10:10:27  garyp
  1227. X        Revisions to support System V regular expression routines.
  1228. X        Provided by Jon A. Tankersley.
  1229. X
  1230. Xv1.8    86/12/12  22:28:40  garyp
  1231. X        Add -x and -a options.  Improve semantic checking.  Fix -n
  1232. X        (wasn't working -- caused core dump).
  1233. X
  1234. Xv1.7    86/12/12  11:54:56  garyp
  1235. X        Fix problem with multiple '+' formats Switch from 'w' to 'a'
  1236. X        (append) access for output files.
  1237. X
  1238. Xv1.6    86/12/11  21:18:08  garyp
  1239. X        Cleaned up error status codes.  Allowed '+' format to designate
  1240. X        stdout.
  1241. X
  1242. Xv1.5    86/12/11  17:29:25  garyp
  1243. X        New improved mailsplit with lots of features.  Renamed slice.
  1244. X
  1245. Xv1.4    86/12/09  17:03:05  garyp
  1246. X        First parameter is now either -m, for mailbox pattern, or -s,
  1247. X        for shell pattern, or -n for line count split, or a user
  1248. X        specified pattern (not starting with '-').  These options
  1249. X        replace -p.  The default output filename is now "%s:%03d" where
  1250. X        %s is the input filename.
  1251. X
  1252. Xv1.3    86/12/09  12:57:49  garyp
  1253. X        Fixed search for %d.  All forms now allowed.  Only %s allowed,
  1254. X        though (no other form seems useful anyway).
  1255. X
  1256. Xv1.2    86/12/09  12:10:09  garyp
  1257. X        Changed to allow output pattern to contain %s to represent
  1258. X        input filename.  However, code only does exact match on %d and
  1259. X        %s.  It should do a pattern match to allow things like %6d.
  1260. X
  1261. Xv1.1    86/12/08  21:08:12  garyp
  1262. X        date and time created 86/12/08 21:08:12 by garyp
  1263. X---------------------------------------------------------------------
  1264. X 
  1265. SHAR_EOF
  1266. if test 2731 -ne "`wc -c 'CHANGES'`"
  1267. then
  1268.     echo shar: error transmitting "'CHANGES'" '(should have been 2731 characters)'
  1269. fi
  1270. #    End of shell archive
  1271. exit 0
  1272.  
  1273.  
  1274.