home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 3 / 3342 < prev    next >
Encoding:
Internet Message Format  |  1991-05-17  |  60.7 KB
  1. From: brennan@ssc-vax.UUCP (Mike Brennan)
  2. Newsgroups: alt.sources
  3. Subject: mawk0.97.shar  1 of 6 (6 pieces not 4)
  4. Message-ID: <3963@ssc-bee.ssc-vax.UUCP>
  5. Date: 11 May 91 14:49:56 GMT
  6.  
  7.  
  8. ------------------cut here----------------
  9.  
  10. # This is a shell archive.  Remove anything before this line,
  11. # then unpack it by saving it in a file and typing "sh file".
  12. #
  13. # Wrapped by ssc-bee!brennan on Fri May 10 18:11:41 PDT 1991
  14. # Contents:  mawk0.97/ mawk0.97/rexp/ mawk0.97/test/ mawk0.97/examples/
  15. #    mawk0.97/msdos/ mawk0.97/packing.list mawk0.97/README
  16. #    mawk0.97/LIMITATIONS mawk0.97/Makefile mawk0.97/mawk.manual
  17. #    mawk0.97/array.c mawk0.97/bi_funct.c mawk0.97/bi_funct.h
  18. #    mawk0.97/bi_vars.c mawk0.97/bi_vars.h mawk0.97/cast.c mawk0.97/code.c
  19. #    mawk0.97/code.h mawk0.97/da.c mawk0.97/error.c mawk0.97/execute.c
  20. #    mawk0.97/fcall.c mawk0.97/field.c mawk0.97/field.h mawk0.97/files.c
  21. #    mawk0.97/files.h mawk0.97/fin.c mawk0.97/fin.h mawk0.97/hash.c
  22. #    mawk0.97/init.c mawk0.97/init.h mawk0.97/jmp.c mawk0.97/jmp.h
  23. #    mawk0.97/kw.c mawk0.97/machine.h mawk0.97/main.c mawk0.97/makescan.c
  24. #    mawk0.97/matherr.c mawk0.97/mawk.h mawk0.97/memory.c mawk0.97/memory.h
  25. #    mawk0.97/parse.y mawk0.97/print.c mawk0.97/re_cmpl.c mawk0.97/regexp.h
  26. #    mawk0.97/repl.h mawk0.97/scan.c mawk0.97/scan.h mawk0.97/scancode.c
  27. #    mawk0.97/sizes.h mawk0.97/split.c mawk0.97/symtype.h mawk0.97/types.h
  28. #    mawk0.97/zmalloc.c mawk0.97/zmalloc.h mawk0.97/rexp/Makefile
  29. #    mawk0.97/rexp/rexp.c mawk0.97/rexp/rexp.h mawk0.97/rexp/rexp0.c
  30. #    mawk0.97/rexp/rexp1.c mawk0.97/rexp/rexp2.c mawk0.97/rexp/rexp3.c
  31. #    mawk0.97/rexp/rexpdb.c mawk0.97/test/README mawk0.97/test/benchmarks
  32. #    mawk0.97/test/cat.awk mawk0.97/test/concat.awk mawk0.97/test/fields.awk
  33. #    mawk0.97/test/loops.awk mawk0.97/test/newton.awk
  34. #    mawk0.97/test/primes.awk mawk0.97/test/qsort.awk mawk0.97/test/reg0.awk
  35. #    mawk0.97/test/reg1.awk mawk0.97/test/reg2.awk mawk0.97/test/sample
  36. #    mawk0.97/test/squeeze.awk mawk0.97/test/test.sh mawk0.97/test/wc.awk
  37. #    mawk0.97/test/wfrq.awk mawk0.97/test/wfrq0.awk mawk0.97/test/words.awk
  38. #    mawk0.97/test/words0.awk mawk0.97/examples/decl.awk
  39. #    mawk0.97/examples/deps.awk mawk0.97/examples/gdecl.awk
  40. #    mawk0.97/examples/nocomment.awk mawk0.97/msdos/INSTALL
  41. #    mawk0.97/msdos/makefile mawk0.97/msdos/mklib.bat
  42. #    mawk0.97/msdos/rand48.asm mawk0.97/msdos/rand48.h
  43. #    mawk0.97/msdos/rand48_0.c mawk0.97/msdos/reargv.c
  44.  
  45. echo mkdir - mawk0.97
  46. mkdir mawk0.97
  47. chmod u=rwx,g=rx,o=rx mawk0.97
  48.  
  49. echo x - mawk0.97/packing.list
  50. sed 's/^@//' > "mawk0.97/packing.list" <<'@//E*O*F mawk0.97/packing.list//'
  51.  
  52. ################################################
  53. # These files form the mawk distribution
  54. #
  55. # Mawk is an implementation of the AWK Programming Language as
  56. # defined and described in Aho, Kernighan and Weinberger, The
  57. # Awk Programming Language, Addison-Wesley, 1988.
  58. #
  59. ################################################
  60. # Source code written by Michael D. Brennan
  61. # Copyright (C) 1991 , Michael D. Brennan
  62. ################################################
  63. packing.list        this file
  64. README            how to get started
  65. LIMITATIONS        restrictions on use
  66. Makefile        mawk makefile
  67. mawk.manual        mock manual
  68. ######################
  69. array.c            source files
  70. bi_funct.c
  71. bi_funct.h
  72. bi_vars.c
  73. bi_vars.h
  74. cast.c
  75. code.c
  76. code.h
  77. da.c
  78. error.c
  79. execute.c
  80. fcall.c
  81. field.c
  82. field.h
  83. files.c
  84. files.h
  85. fin.c
  86. fin.h
  87. hash.c
  88. init.c
  89. init.h
  90. jmp.c
  91. jmp.h
  92. kw.c
  93. machine.h
  94. main.c
  95. makescan.c
  96. matherr.c
  97. mawk.h
  98. memory.c
  99. memory.h
  100. parse.y
  101. print.c
  102. re_cmpl.c
  103. regexp.h
  104. repl.h
  105. scan.c
  106. scan.h
  107. scancode.c
  108. sizes.h
  109. split.c
  110. symtype.h
  111. types.h
  112. zmalloc.c
  113. zmalloc.h
  114. ########################
  115. # directory:  rexp
  116. rexp/Makefile        makefile for regexp.a
  117. rexp/rexp.c        source for regular matching library
  118. rexp/rexp.h
  119. rexp/rexp0.c
  120. rexp/rexp1.c
  121. rexp/rexp2.c
  122. rexp/rexp3.c
  123. rexp/rexpdb.c
  124. #######################
  125. # directory:  test      benchmarking directory
  126. test/README
  127. test/benchmarks
  128. test/cat.awk
  129. test/concat.awk
  130. test/fields.awk
  131. test/loops.awk
  132. test/newton.awk
  133. test/primes.awk
  134. test/qsort.awk
  135. test/reg0.awk
  136. test/reg1.awk
  137. test/reg2.awk
  138. test/sample            sample input file for test.sh
  139. test/squeeze.awk
  140. test/test.sh
  141. test/wc.awk
  142. test/wfrq.awk
  143. test/wfrq0.awk
  144. test/words.awk
  145. test/words0.awk
  146. ######################
  147. # directory:  examples       useful awk programs
  148. examples/decl.awk
  149. examples/deps.awk
  150. examples/gdecl.awk
  151. examples/nocomment.awk
  152. ######################
  153. # directory  msdos
  154. msdos/INSTALL
  155. msdos/makefile
  156. msdos/mklib.bat
  157. msdos/rand48.asm
  158. msdos/rand48.h
  159. msdos/rand48_0.c
  160. msdos/reargv.c
  161. @//E*O*F mawk0.97/packing.list//
  162. chmod u=rw,g=r,o=r mawk0.97/packing.list
  163.  
  164. echo x - mawk0.97/README
  165. sed 's/^@//' > "mawk0.97/README" <<'@//E*O*F mawk0.97/README//'
  166.  
  167.  
  168. to build mawk:
  169.  
  170. make sure  there is an appropriate description of
  171. your system in machine.h
  172.  
  173. set CFLAGS in the Makefile to pick the appropriate blob
  174. in machine.h
  175.  
  176. run make
  177.  
  178.  
  179.  
  180. PS:
  181. I expected to have bcopy() <-> memcpy()
  182. hassles on 4.3BSD, but didn't
  183. Is this right? or did someone add memcpy(), strchr() etc
  184.    to that machine?
  185.    If 4.3BSD in machine.h is wrong, let me know at
  186.    brennan@bcsaic.boeing.com
  187. @//E*O*F mawk0.97/README//
  188. chmod u=r,g=r,o=r mawk0.97/README
  189.  
  190. echo x - mawk0.97/LIMITATIONS
  191. sed 's/^@//' > "mawk0.97/LIMITATIONS" <<'@//E*O*F mawk0.97/LIMITATIONS//'
  192.  
  193.  
  194. Mawk is an implementation of the AWK Programming Language
  195. as defined in Aho, Kernighan and Weinberger, The AWK 
  196. Programming Language, Addison-Wesley, 1988.
  197.  
  198. The source code is original work, in the sense that its
  199. development relied only on the specification of the AWK
  200. language in the book above.  Most of the algorithms and
  201. data structures used in this code are not original --
  202. but based on knowledge acquired from numerous sources.
  203. Originality is claimed only for the aggregate work.  Any
  204. ideas or techniques in this code can be freely copied and
  205. used in other work.  
  206.  
  207. The source code may be modified provided the copyright
  208. notices remain intact, and modifications are unambiguously
  209. distinct from the original.  I want to retain credit for my
  210. work and do not want credit for yours.
  211.  
  212. Redistribution in any form is permitted provided the built-in
  213. variable VERSION is retained, and its initial value only
  214. modified by appending extra lines.
  215.  
  216.     For example, if you modify a mawk with VERSION
  217.  
  218.     mawk x.xx Mon Year, Copyright (C) Michael D. Brennan
  219.  
  220.     then add an extra line to VERSION without modifying the
  221.     first line.
  222.  
  223.     mawk x.xx Mon Year, Copyright (C) Michael D. Brennan
  224.     mod y.yy  Mon Year, your name
  225.  
  226.  
  227. Michael D. Brennan
  228. 16 Apr 1991
  229.  
  230. @//E*O*F mawk0.97/LIMITATIONS//
  231. chmod u=r,g=r,o=r mawk0.97/LIMITATIONS
  232.  
  233. echo x - mawk0.97/Makefile
  234. sed 's/^@//' > "mawk0.97/Makefile" <<'@//E*O*F mawk0.97/Makefile//'
  235.  
  236. # ###################################################
  237. # This is a makefile for mawk,
  238. # an implementation of The AWK Programmin Language, 1988.
  239. # 
  240. # 
  241.  
  242. SHELL=/bin/sh
  243.  
  244. ####################################
  245. # CFLAGS needs to match a define in machine.h
  246. # unless machine.h uses a built-in compiler flag
  247. #
  248.  
  249. CFLAGS = -O -DULTRIX
  250. #CFLAGS =  -O -DBSD43
  251. YACC=yacc -dv
  252. #YACC=bison -dvy
  253.  
  254. #######################################
  255.  
  256. O=parse.o scan.o memory.o main.o hash.o execute.o code.o\
  257.   da.o error.o init.o bi_vars.o cast.o print.o bi_funct.o\
  258.   kw.o jmp.o array.o field.o  split.o re_cmpl.o zmalloc.o\
  259.   fin.o files.o  scancode.o matherr.o  fcall.o
  260.  
  261. REXP_C=rexp/rexp.c rexp/rexp0.c rexp/rexp1.c rexp/rexp2.c\
  262.     rexp/rexp3.c rexp/rexpdb.c
  263.  
  264.  
  265.  
  266. mawk : $(O)  rexp/regexp.a
  267.     cc $(CFLAGS) -o mawk $(O) -lm rexp/regexp.a
  268.  
  269. rexp/regexp.a :  $(REXP_C)
  270.     cd  rexp ; make
  271.  
  272.  
  273. parse.c  : parse.y
  274.     @echo  expect 3 shift/reduce conflicts
  275.     $(YACC)  parse.y
  276.     mv y.tab.c parse.c
  277.     -if cmp -s y.tab.h parse.h ;\
  278.        then rm y.tab.h ;\
  279.        else mv y.tab.h parse.h ; fi
  280.  
  281. scancode.c :  makescan.c  scan.h
  282.     cc -o makescan.exe  makescan.c
  283.     makescan.exe > scancode.c
  284.     rm makescan.exe
  285.  
  286.  
  287. array.o : bi_vars.h sizes.h zmalloc.h memory.h types.h machine.h mawk.h symtype.h
  288. bi_funct.o : fin.h bi_vars.h sizes.h memory.h zmalloc.h regexp.h types.h machine.h field.h repl.h files.h bi_funct.h mawk.h symtype.h init.h
  289. bi_vars.o : bi_vars.h sizes.h memory.h zmalloc.h types.h machine.h field.h mawk.h symtype.h init.h
  290. cast.o : parse.h sizes.h memory.h zmalloc.h types.h machine.h field.h scan.h repl.h mawk.h symtype.h
  291. code.o : sizes.h memory.h zmalloc.h types.h machine.h code.h mawk.h init.h
  292. da.o : sizes.h memory.h zmalloc.h types.h machine.h field.h repl.h code.h bi_funct.h mawk.h symtype.h
  293. error.o : parse.h bi_vars.h sizes.h types.h machine.h scan.h mawk.h symtype.h
  294. execute.o : sizes.h memory.h zmalloc.h regexp.h types.h machine.h field.h code.h repl.h bi_funct.h mawk.h symtype.h
  295. fcall.o : sizes.h memory.h zmalloc.h types.h machine.h code.h mawk.h symtype.h
  296. field.o : parse.h bi_vars.h sizes.h memory.h zmalloc.h regexp.h types.h machine.h field.h scan.h repl.h mawk.h symtype.h init.h
  297. files.o : fin.h sizes.h memory.h zmalloc.h types.h machine.h files.h mawk.h
  298. fin.o : parse.h fin.h bi_vars.h sizes.h memory.h zmalloc.h types.h machine.h field.h scan.h mawk.h symtype.h
  299. hash.o : sizes.h memory.h zmalloc.h types.h machine.h mawk.h symtype.h
  300. init.o : bi_vars.h sizes.h memory.h zmalloc.h types.h machine.h field.h code.h mawk.h symtype.h init.h
  301. jmp.o : sizes.h memory.h zmalloc.h types.h machine.h code.h jmp.h mawk.h init.h
  302. kw.o : parse.h sizes.h types.h machine.h mawk.h symtype.h init.h
  303. main.o : fin.h bi_vars.h sizes.h memory.h zmalloc.h types.h machine.h field.h code.h files.h mawk.h init.h
  304. makescan.o : parse.h scan.h symtype.h
  305. matherr.o : sizes.h types.h machine.h mawk.h
  306. memory.o : sizes.h memory.h zmalloc.h types.h machine.h mawk.h
  307. parse.o : bi_vars.h sizes.h memory.h zmalloc.h types.h machine.h field.h code.h files.h bi_funct.h mawk.h jmp.h symtype.h
  308. print.o : bi_vars.h parse.h sizes.h memory.h zmalloc.h types.h machine.h field.h scan.h files.h bi_funct.h mawk.h symtype.h
  309. re_cmpl.o : parse.h sizes.h memory.h zmalloc.h regexp.h types.h machine.h scan.h repl.h mawk.h symtype.h
  310. scan.o : parse.h fin.h sizes.h memory.h zmalloc.h types.h machine.h field.h scan.h repl.h files.h mawk.h symtype.h init.h
  311. split.o : bi_vars.h parse.h sizes.h memory.h zmalloc.h regexp.h types.h machine.h field.h scan.h bi_funct.h mawk.h symtype.h
  312. zmalloc.o : sizes.h zmalloc.h types.h machine.h mawk.h
  313. @//E*O*F mawk0.97/Makefile//
  314. chmod u=r,g=r,o=r mawk0.97/Makefile
  315.  
  316. echo x - mawk0.97/mawk.manual
  317. sed 's/^@//' > "mawk0.97/mawk.manual" <<'@//E*O*F mawk0.97/mawk.manual//'
  318.  
  319.                               Mawk Manual 
  320.  
  321. Mawk implements the awk language as defined in Aho, Kernighan and 
  322. Weinberger, The AWK Programming Language, Addison-Wesley, 1988, ISBN 
  323. 0-201-07981-X, hereafter called the AWK book.  Chapter 2 serves as a 
  324. reference to the language and the rest (8 total chapters) provides a 
  325. wide range of examples and applications.  This book is must reading to 
  326. understand the versatility of the language.  
  327.  
  328. The 1988 version of the language is sometimes called new awk as opposed 
  329. to the 1977 version (awk or old awk.) Virtially every Unix system has 
  330. old awk, somewhere in the documentation will be an (old) awk tutorial 
  331. (probably in support tools).  If you use (old) awk, the transition to 
  332. new awk is easy.  The language has been extended and ambiguous points 
  333. clarified, but old awk programs still run under new awk.  
  334.  
  335. This manual assumes you know (old) awk, and hence concentrates on the 
  336. new features of awk.  Feature xxx is new means xxx was added to the 1988
  337. version.  
  338.  
  339. Experienced new awk users should read sections 9 and 12, and skim 
  340. sections 7 and 8.  
  341.  
  342. 1. Command line
  343.  
  344.     mawk [-Fs] 'program'  optional_list_of_files
  345.     mawk [-Fs] -f program_file  optional_list_of_files
  346.  
  347. 2. Program blocks
  348.  
  349.     Program blocks are of the form:
  350.  
  351.     pattern { action }
  352.  
  353.     pattern can be:
  354.  
  355.     regular_expression
  356.     expression
  357.     ( pattern )
  358.     ! pattern
  359.     pattern || pattern
  360.     pattern && pattern
  361.  
  362.     pattern , pattern  (range pattern)
  363.     BEGIN
  364.     END
  365.  
  366. Range, BEGIN and END patterns cannot be combined to form new patterns.  
  367. BEGIN and END patterns require an action; otherwise, if action is 
  368. omitted it is implicitly { print }.  
  369.  
  370.     NR==2    {  print }  # prints line number 2
  371.     NR==2             # also prints line number 2
  372.  
  373. If pattern is omitted then action is always applied.
  374.  
  375.     { print $NF }
  376.  
  377. prints the last field of every record.
  378.  
  379. 3. Statement format and loops
  380.  
  381. Statements are terminated by newlines, semi-colons or both.  Groups of 
  382. statements are blocked via { ...  } as in C.  The last statement in a 
  383. block doesn't need a terminator.  Blank lines have no meaning; an empty 
  384. statement is terminated with a semi-colon.  Long statements can be 
  385. continued with a backslash, \.  A statement can be broken without a 
  386. backslash after a comma, left brace, &&, ||, do, else, the right 
  387. parenthesis of an if, while or for statement, and the right parenthesis 
  388. of a function definition.  
  389.  
  390. Loops are for(){}, while(){} and do{}while() as in C.  
  391.  
  392. 4. Expression syntax
  393.  
  394. The expression syntax and grouping of the language is similar to C.  
  395. Primary expressions are numeric constants, string constants, variables, 
  396. arrays and functions.  Complex expressions are composed with the 
  397. following operators in order of increasing precedence.  
  398.  
  399.     assignment: = += -+ *= /= ^=
  400.     conditional:  ? :
  401.     logical or:   ||
  402.     logical and:  &&
  403.     array membership :   in
  404.     matching :   ~   !~
  405.     relational :  <  >   <=  >=  ==  !=
  406.     concatenation:   (no explicit operator)
  407.     add ops:  +  -
  408.     mul ops:  *  /  % 
  409.     unary  :  +  -
  410.     logical not :  !
  411.     exponentiation:  ^
  412.     inc and dec:  ++ -- (both post and pre)
  413.     field:  $
  414.  
  415. 5. Builtin variables.
  416.  
  417. The following variables are built-in and initialized before program 
  418. execution.  
  419.  
  420.     ARGC    number of command line arguments
  421.     ARGV    array of command line arguments, 0..ARGC-1
  422.     FILENAME    name of the current input file
  423.     FNR         current record number in the current input file
  424.     FS        splits records into fields as a regular expression
  425.     NF        number of fields in the current record, i.e., $0
  426.     NR        current record number in the total input stream
  427.     OFMT    format for printing numbers; initially = "%.6g"
  428.     OFS        inserted between fields on output, initially = " "
  429.     ORS        terminates each record on output, initially = "\n"
  430.     RLENGTH     length of the last call to the built-in function, match()
  431.     RS        input record separator, initially = " "
  432.     RSTART    index of the last call to match()
  433.     SUBSEP    used to build multiple array subscripts, initially = "\034"
  434.     VERSION     Mawk version, unique to mawk.
  435.  
  436. ARGC, ARGV, FNR, RLENGTH, RSTART and SUBSEP are new.  
  437.  
  438. The current input record is stored in the field, $0.  The fields of $0 
  439. determined by splitting with RS are stored in $1, $2, ..., $NF.  
  440.  
  441.  
  442. 6. Built-in Functions
  443.  
  444. String functions
  445.  
  446.     index(s,t)
  447.     length(s), length
  448.     split(s, A, r), split(s, A)
  449.     substr(s,i,n) , substr(s,i)
  450.     sprintf(format, expr_list)
  451.  
  452.     match(s,r)        returns the index where string s matches
  453.                 regular expression r or 0 if no match. As
  454.             a side effect, sets RSTART and RLENGTH.
  455.  
  456.     gsub(r, s, t)       Global substitution, every match of regular
  457.             expression r in variable t is replaced by s.
  458.             The number of matches/replacements is returned.
  459.  
  460.     sub(r, s, t)    Like gsub(), except at most one replacement.
  461.  
  462. Match(), gsub() and sub() are new.  If r is an expr it is coerced to 
  463. string and then treated as a regular expression.  In sub and gsub, t can
  464. be a variable, field or array element, i.e., it must have storage to 
  465. hold the modification.  Sub(r,s) and gsub(r,s) are the same as 
  466. sub(r,s,$0) and gsub(r,s,$0).  In the replacement string s, an & is 
  467. replaced by the matched piece and a literal & is obtained with \&.  
  468. E.g., 
  469.  
  470.         y = x = "abbc"
  471.         sub(/b+/, "B&B" , x)
  472.         sub(/b+/, "B\&B" , y)
  473.         print x, y
  474.  
  475. outputs:    aBbbBc aB&Bc
  476.  
  477.  
  478.  
  479.  
  480. Arithmetic functions
  481.  
  482.     atan2(y,x)        arctan of y/x between -pi and pi.
  483.     cos(x)
  484.     exp(x)
  485.     int(x)        x.dddd ->  x.0
  486.     log(x)
  487.     rand()        returns random number , 0 <= r < 1.
  488.     sin(x)
  489.     sqrt(x)
  490.     srand(x) , srand()  seeds random number generator, uses clock
  491.             if x is omitted.
  492.  
  493. Output functions
  494.  
  495.     print        writes  $0 ORS   to stdout.
  496.  
  497.     print expr1 , expr2 , ... , exprn
  498.             writes expr1 OFS expr2 OFS ... OFS exprn ORS to
  499.             stdout.
  500.  
  501.     printf format, expr_list
  502.             Acts like the C library function, writing to
  503.             stdout.  Supported conversions are
  504.             %c, %d, %e, %f, %g, %o, %s and %x.  
  505.             - , width and .prec are supported.
  506.             Dynamic widths can be built using string operations
  507.  
  508.  
  509. Output can be redirected 
  510.  
  511.    print[f]  > file
  512.          >> file
  513.          | command
  514.  
  515. File and command are awk expressions that are interpreted as a filename 
  516. or a shell command.  
  517.  
  518.  
  519. Input functions
  520.  
  521.     getline        read $0, update NF, NR and FNR.
  522.  
  523.     getline < file      read $0 from file, update NF.
  524.     getline var         read var from input stream, update NR, FNR.
  525.     getline var < file  read var from next record of file
  526.  
  527.     command | getline   read $0 from piped command, update NF.
  528.     command | getline var   read var from next record of piped command.
  529.  
  530. (Old) awk had getline, the redirection facilities are new.
  531.  
  532.     Files or commands are closed with
  533.  
  534.     close(expr)
  535.  
  536. where expr is command or file as a string.  Close returns 0 if expr was 
  537. in fact an open file or command else -1.  Close is needed if you want to
  538. reread a file, rerun a command, have a large number of output files 
  539. without mawk running out of resources or wait for an output command to 
  540. finish.  Here is an example of the last case: 
  541.  
  542.     { ....  do some processing on each input line
  543.       #  send the processed line to sort
  544.       print | "sort > temp_file"
  545.  
  546.     }
  547.  
  548.     END { # reread the sorted input
  549.       close( "sort > temp_file")  # makes sure sort is finished
  550.  
  551.       cnt=1
  552.       while ( getline line[cnt++] < "temp_file"  > 0 )  ;  
  553.       system( "rm temp_file" )  # cleanup
  554.  
  555.       ... process line[1], line[2] ... line[cnt-1]
  556.     }
  557.  
  558. The system() function executes a command and returns the command's exit 
  559. status.  Mawk uses the shell in the environment variable SHELL to 
  560. execute system or command pipelines; defaulting to "/bin/sh" if SHELL is
  561. not set.  
  562.  
  563.  
  564. 7. String constants
  565.  
  566. String constants are written as in C.
  567.  
  568.  
  569.     "This is a string with a newline at the end.\n"
  570.  
  571. Strings can be continued across a line by escaping (\) the newline.  The
  572. following escape sequences are recognized.  
  573.  
  574.     \\        \
  575.     \"        "
  576.     \'        '
  577.     \a        alert, ascii 7
  578.     \b        backspace, ascii 8
  579.     \t        tab, ascii 9
  580.     \n        newline, ascii 10
  581.     \v        vertical tab, ascii 11
  582.     \f        formfeed, ascii 12
  583.     \r        carriage return, ascii 13
  584.     \ddd        1, 2 or 3 octal digits for ascii ddd
  585.  
  586.     \xhh        1 or 2 hex digits for ascii  hh
  587.  
  588. If you escape any other character \c, you get \c, i.e.  the escape is 
  589. ignored.  Mawk is different than most awks here; the AWK book says \c is
  590. c.  The reason mawk chooses to be different is for easier conversion of 
  591. strings to regular expressions.  
  592.  
  593.  
  594. 8. Regular expressions
  595.  
  596. Awk notation for regular expressions is in the style of egrep(1).  In 
  597. awk, regular expressions are enclosed in / ...  /.  A regular expression
  598. /r/, is a set of strings.  
  599.  
  600.         s ~ /r/
  601.  
  602. is an awk expression that evaluates to 1 if an element of /r/ is a 
  603. substring of s and evaluates to 0 otherwise.  ~ is called the match 
  604. operator and the expression is read "s matches r".  
  605.  
  606.        s ~ /^r/   is 1 if some element of r is a prefix of s.
  607.        s ~ /r$/   is 1 if some element of r is a suffix of s.
  608.        s ~ /^r$/  is 1 if s is an element of r.
  609.  
  610. Replacing ~ by !~ , the not match operator, reverses the meanings.  In 
  611. patterns, /r/ and !/r/ are shorthand for $0 ~ /r/ and $0 !~ /r/.  
  612.  
  613. Regular expressions are combined by the following rules.
  614.  
  615.     //  stands for the one element set "" (not the empty set).
  616.     /c/ for a character c is the one element set "c".
  617.  
  618.     /rs/  is all elements of /r/ concatenated with all 
  619.           elements of /s/.
  620.  
  621.     /r|s/ is the set union of /r/ and /s/.
  622.  
  623.     /r*/  called the closure of r is // union /rr/ union /rrr/ ...
  624.           In words, r repeated zero or more times.
  625.  
  626. The above operations are sufficient to describe all regular expressions,
  627. but for ease of notation awk defines additional operations and notation.
  628.  
  629.     /r?/  // union /r/.  In words r 0 or 1 time.
  630.     /r+/  Positive closure of r.  R 1 or more times.
  631.     (r)   Same as r -- allows grouping.
  632.     .     Stands for any character (for mawk this means 
  633.           ascii 1 through ascii 255)
  634.     [c1c2..cn]    A character class same as (c1|c2|...|cn) where
  635.           ci's are single characters.
  636.  
  637.     [^c1c2..cn]   Complement of the class [c1c2..cn].  For mawk
  638.           complement in the ascii character set 1 to 255.
  639.  
  640. Ranges c1-cn are allowed in character classes.  For example,
  641.  
  642.     /[_a-zA-Z][_a-zA-Z0-9]*/
  643.  
  644. expresses the set of possible identifiers in awk.
  645.  
  646. The operators have increasing precedence:
  647.  
  648.        |
  649.        implicit concatenation
  650.        + * ?
  651.  
  652. So /a|b+/ means a or (1 or more b's), and /(a|b)+/ means (a or b) one or
  653. more times.  The so called regular expression metacharacters are \ ^ $ .
  654. [ ] | ( ) * + ? .  To stand for themselves as characters they have to be
  655. escaped.  (They don't have to be escaped in classes, inside classes the 
  656. meta-meaning is off).  The same escape sequences that are recognized in 
  657. strings (see above) are recognized in regular expressions.  For mawk, 
  658. the escape rule for \c changes to c.  
  659.  
  660. For example,
  661.  
  662.     /[ \t]*/   is optional space
  663.     /^[-+]?([0-9]+\.?|\.[0-9])[0-9]*([eE][-+]?[0-9]+)?$/
  664.            is numbers in the Awk language.
  665.            Note,  . must be escaped to have
  666.            its meaning as decimal point.
  667.  
  668. For building regular expressions, you can think of ^ and $ as phantom 
  669. characters at the front and back of every string.  So /(^a|b$|^A.*B$)/ 
  670. is the set of strings that start with a or end with b or (start with A 
  671. and end with B).  
  672.  
  673. Dynamic regular expressions are new.  You can write 
  674.  
  675.     x ~ expr
  676.  
  677. and expr is interpreted as a regular expression.  The result of x ~ y 
  678. can vary with the variable y; so 
  679.  
  680.     x ~ /a\+b/   and   x ~ "a\+b"
  681.  
  682. are the same, or are they? In mawk, they are; in some other awk's they 
  683. are not.  In the second expression, "a\+b" is scanned twice: once as a 
  684. string constant and then again as a regular expression.  In mawk the 
  685. first scan gives the four character string 'a' '\' '+' 'b' because mawk 
  686. treats \+ as \+; the second scan gives a regular expression matched by 
  687. the three character string 'a' '+' 'b' because on the second scan \+ 
  688. becomes +.  
  689.  
  690. If \c becomes c in strings, you need to double escape metacharacters, 
  691. i.e., write 
  692.  
  693.     x ~ "a\\+b".
  694.  
  695. Exercise: what happens if you double escape in mawk?
  696.  
  697. In strings if you only escape characters with defined escape sequences 
  698. such as \t or \n or meta-characters when you expect to use a string as a
  699. regular expression, then mawk's rules are intuitive and simple.  See 
  700. example/cdecl.awk and example/gdecl.awk for the same program with single
  701. and double escapes, the first is clearer.  
  702.  
  703.  
  704. 9. How Mawk splits lines, records and files.
  705.  
  706. Mawk uses the essentially the same algorithm to split lines into pieces 
  707. with split(), records into fields on FS, and files into records on RS.  
  708.  
  709. Split( s, A, sep ) splits string s into array A with separator sep as 
  710. follows: 
  711.  
  712.     Sep is interpreted as a regular expression.
  713.  
  714.     If s = "", there are no pieces and split returns 0.
  715.  
  716.     Otherwise s is split into pieces by the matches with sep
  717.     of positive length treated as a separator between pieces,
  718.     so the number of pieces is the number of matches + 1.
  719.     Matches of the null string do not split.
  720.     So sep = "b+" and sep = "b*" split the same although the
  721.     latter executes more slowly.
  722.  
  723.     Split(s, A) is the same as split(s, A, FS).
  724.     With mawk you can write sep as a regular expression, i.e.,
  725.     split(s, A, "b+") and split(s, A, /b+/) are the same.
  726.  
  727.     Sep = " " (a single space) is special.  Before the algorithm is
  728.     applied, white-space is trimmed from the front and back of s.
  729.     Mawk defines white-space as SPACE, TAB, FORMFEED, VERTICAL TAB
  730.     or NEWLINE, i.e [ \t\f\v\n].  Usually this means SPACE or TAB
  731.     because NEWLINE usually separates records, and the other
  732.     characters are rare.  The above algorithm
  733.     is then applied with sep = "[ \t\f\v\n]+".
  734.  
  735.     If length(sep) = 1, then regular expression metacharacters do
  736.     not have to be escaped, i.e. split(s, A, "+") is the same as
  737.     split(s, A, /\+/).
  738.  
  739.  
  740. Splitting records into fields works exactly the same except the pieces 
  741. are loaded into $1, $2 ...  $NF.  
  742.  
  743. Records are also the same, RS is treated as a regular expression.  But 
  744. there is a slight difference, RS is really a record terminator (ORS is 
  745. really a terminator also).  
  746.  
  747.     E.g., if FS = ":" and $0 = "a:b:" , then
  748.     NF = 3 and $1 = "a", $2 = "b" and $3 = "", but
  749.     if "a:b:" is the contents of an input file and RS = ":", then
  750.     there are two records "a" and "b".
  751.  
  752.     RS = " " does not have special meaning as with FS.
  753.  
  754.  
  755. Not all versions of (new) awk support RS as a regular expression.  This 
  756. feature of mawk is useful and improves performance.  
  757.  
  758.     BEGIN { RS = "[^a-zA-Z]+" 
  759.         getline
  760.         if ( $0 == "" ) NR = 0 
  761.         else word[1] = $0
  762.     }
  763.  
  764.     { word[NR] = $0 }
  765.  
  766.     END { ... do something with word[1]...word[NR] }
  767.  
  768. isolates words in a document over twice as fast as reading one line at a
  769. time and then examining each field with FS = "[^a-zA-Z]+".  
  770.  
  771. To remove comments from C code: 
  772.  
  773.     BEGIN { RS = "/\*([^*]|\*[^/])*\*/"  # comment is RS
  774.         ORS = " "
  775.     }
  776.  
  777.     { print }
  778.  
  779.     END { printf "\n" }
  780.  
  781.  
  782. 10. Multi-line records
  783.  
  784. Since mawk interprets RS as a regular expression, multi-line records are
  785. easy.  Setting RS = "\n\n+", makes one or more blank lines separate 
  786. records.  If FS = " " (the default), then single newlines, by the rules 
  787. for space above, become space.  
  788.  
  789.    For example, if a file is "a b\nc\n\n", RS = "\n\n+" and
  790.    FS = " ", then there is one record "a b\nc" with three
  791.    fields "a", "b" and "c".  Changing FS = "\n", gives two
  792.    fields "a b" and "c"; changing FS = "", gives one field
  793.    identical to the record.
  794.  
  795. For compatibility with (old) awk, setting RS = "" has the same
  796. effect on determining records as RS = "\n([ \t]*\n)+".
  797.  
  798. Most of the time when you change RS for mult-line records, you
  799. will also want to change ORS to "\n\n".
  800.  
  801. 11. User functions.
  802.  
  803. User defined functions are new.  They can be passed expressions by value
  804. or arrays by reference.  Function calls can be nested and support 
  805. recursion.  The syntax is 
  806.  
  807.     function  funcname( args ) {
  808.  
  809.     .... body
  810.  
  811.     }
  812.  
  813. Newlines are ignored after the ')' so the '{' can start on a different 
  814. line.  Inside the body, you can use a return statement 
  815.  
  816.     return expr
  817.     return
  818.  
  819. As in C, there is no distinction between functions and procedures.  A 
  820. function does not need an explicit return.  Extra arguments act as local
  821. variables.  For example, csplit(s, A) puts each character of s in array 
  822. A.  
  823.  
  824.     function  csplit(s, A,     i)
  825.     {
  826.       for(i=1; i <= length(s) ; i++)
  827.         A[i] = substr(s, i, 1)
  828.     }
  829.  
  830. Putting lots of space between the passed arguments and the local 
  831. variables is a convention that can be ignored if you don't like it.  
  832.  
  833. Dynamic regular expressions allow regular expressions to be passed to 
  834. user defined functions.  The following function gobble() is the lexical 
  835. scanner for a recursive descent parser, the whole program is in 
  836. examples/cdecl.awk.  
  837.  
  838.     function gobble( r,   x) # eat regular expression 
  839.         #  r off the front of global variable line
  840.  
  841.     {
  842.       if ( match( line, "^(" r ")") )
  843.       {
  844.         x = substr(line, 1, RLENGTH)
  845.         line = substr(line, RLENGTH)
  846.       }
  847.       else  x = ""
  848.  
  849.       return x
  850.     }
  851.  
  852. You can call a function before it is defined, but the function name and 
  853. the '(' must not be separated by white space to avoid confusion with 
  854. concatenation.  
  855.  
  856. 12. Other differences in mawk
  857.  
  858. The main differences between mawk and other awks have been discussed, RS
  859. as a regular expression and regular expression metacharacters don't have
  860. to be double escaped.  Here are some others: 
  861.  
  862.   VERSION  -- built-in variable holding version number of mawk.
  863.  
  864.     mawk 'BEGIN{print VERSION}'       shows it.
  865.  
  866.  
  867.   -D  --  command line flag causes mawk to dump to stderr 
  868.       a mawk assembler listing of the current program.
  869.       The program is executed by a stack machine internal
  870.       to mawk.  The op codes are in code.h, the machine in
  871.       execute.c.
  872.  
  873.   srand() --    
  874.       During initialization, mawk seeds the random number generator
  875.       by silently calling srand(), so calling srand() yourself is
  876.       unnecessary.  The main use of srand is to use srand(x) to get
  877.       a repeatable stream of random numbers.  Srand(x) returns x
  878.       and srand() returns the value of the system clock in some form
  879.       of ticks.
  880.  
  881.  
  882. 13. MsDOS
  883.  
  884. For a number of reasons, entering a mawk program on the command line 
  885. using command.com as your shell is an exercise in futility, so under 
  886. MsDOS the command syntax is 
  887.  
  888.     mawk [-Fs] optional_list_of_files
  889.  
  890. You'll get a prompt, and then type in the program.  The -f option works 
  891. as before.  
  892.  
  893. If you use a DOS shell that gives you a Unix style command line, to use 
  894. it you'll need to provide a C function reargv() that retrieves argc and 
  895. argv[] from your shell.  The details are in msdos/INSTALL.  
  896.  
  897. Some features are missing from the DOS version of mawk: No system(), and
  898. no input or output pipes.  To provide a hook to stderr, I've added 
  899.  
  900.     errmsg( "string" )
  901.  
  902. which prints "string\n" to stderr which will be the console and only the
  903. console under command.com.  A better solution would be to associate a 
  904. file with handle 2, so print and printf would be available.  Consider 
  905. the errmsg() feature as temporary.  
  906.  
  907. For compatibility with Unix, CR are silently stripped from input and LF 
  908. silently become CRLF on output.  
  909.  
  910. WARNING: If you write an infinite loop that does not print to the 
  911. screen, then you will have to reboot.  For example 
  912.  
  913.     x = 1 
  914.     while( x < 10 )  A[x] = x
  915.     x++
  916.  
  917. By mistake the x++ is outside the loop.  What you need to do is type 
  918. control break and the keyboard hardware will generate an interrupt and 
  919. the operating system will service that interrupt and terminate your 
  920. program, but unfortunately MsDOS does not have such a feature.  
  921.  
  922.  
  923. 14. Bugs
  924.  
  925. Currently mawk cannot handle \0 (NUL) characters in input files 
  926. otherwise mawk is 8 bit clean.  Also "a\0b", doesn't work right -- you 
  927. get "a".  You can't use \0 in regular expressions either.  
  928.  
  929.    printf "A string%c more string\n" , 0
  930.  
  931. does work, but more by luck than design since it doesn't work with 
  932. sprintf().  
  933.  
  934.  
  935. 15. Releases
  936.  
  937. This release is version 0.97.  After a reasonable period of time, any 
  938. bugs that appear will be fixed, and this release will become version 
  939. 1.0.  
  940.  
  941. Evidently features have been added to awk by Aho, Kernighan and 
  942. Weinberger since the 1988 release of the AWK book.  Version 1.1 will add
  943. whatever features are necessary to remain compatible with the language 
  944. as defined by its designers.  
  945.  
  946. After that ...  ? 
  947.  
  948. 16. Correspondence
  949.  
  950. Send bug reports or other correspondence to
  951.  
  952. Mike Brennan
  953. brennan@bcsaic.boeing.com
  954.  
  955. If you have some interesting awk programs, contributions to the examples
  956. directory would be appreciated.  
  957. @//E*O*F mawk0.97/mawk.manual//
  958. chmod u=rw,g=r,o=r mawk0.97/mawk.manual
  959.  
  960. echo x - mawk0.97/array.c
  961. sed 's/^@//' > "mawk0.97/array.c" <<'@//E*O*F mawk0.97/array.c//'
  962.  
  963. /********************************************
  964. array.c
  965. copyright 1991, Michael D. Brennan
  966.  
  967. This is a source file for mawk, an implementation of
  968. the Awk programming language as defined in
  969. Aho, Kernighan and Weinberger, The AWK Programming Language,
  970. Addison-Wesley, 1988.
  971.  
  972. See the accompaning file, LIMITATIONS, for restrictions
  973. regarding modification and redistribution of this
  974. program in source or binary form.
  975. ********************************************/
  976.  
  977. /* $Log:    array.c,v $
  978.  * Revision 2.1  91/04/08  08:22:15  brennan
  979.  * VERSION 0.97
  980.  * 
  981. */
  982.  
  983. #include "mawk.h"
  984. #include "symtype.h"
  985. #include "memory.h"
  986. #include "bi_vars.h"
  987.  
  988. extern int returning ; 
  989.    /* flag -- on if returning from function call */
  990.  
  991. extern unsigned hash() ;
  992.  
  993. /* An array A is a pointer to a hash table of size
  994.    A_HASH_PRIME holding linked lists of ANODEs.
  995.  
  996.    When an index is deleted via  delete A[i], the
  997.    ANODE is not removed from the hash chain.  A[i].cp
  998.    and A[i].sval are both freed and sval is set NULL.
  999.    This method of deletion simplifies for( i in A ) loops.
  1000. */
  1001.  
  1002. /* is sval in A ? */
  1003. int array_test( A, sval)
  1004.   ARRAY A ; 
  1005.   STRING *sval ;
  1006. { char *s = sval->str ;
  1007.   register ANODE *p = A[ hash(s) % A_HASH_PRIME ] ;
  1008.   
  1009.   while ( p )
  1010.   { if ( p->sval && strcmp(s, p->sval->str) == 0 )  return 1 ;
  1011.     p = p->link ; }
  1012.   /* not there */
  1013.   return 0 ;
  1014. }
  1015.   
  1016. /* find x in array a
  1017.    if flag is ON x is a char* else a STRING*,
  1018.    computes a[x] as a CELL*
  1019. */
  1020.  
  1021. CELL *array_find( a, x, flag)
  1022.   ARRAY a ; PTR  x ; int flag ;
  1023. { register ANODE *p ;  /* search with p */
  1024.   ANODE *q ;  /* pts at a deleted node */
  1025.   unsigned h ;
  1026.   char *s ;
  1027.  
  1028.   s = flag ? (char *) x : ( (STRING *) x) -> str ;
  1029.   p = a[ h = hash(s) % A_HASH_PRIME ] ;
  1030.   q = (ANODE *) 0 ; 
  1031.  
  1032.   while ( p )
  1033.   { 
  1034.     if ( p->sval )
  1035.     {
  1036.       if ( strcmp(s,p->sval->str) == 0 )  /* found */
  1037.         return  p->cp ;
  1038.     }
  1039.     else /* a deleted node */
  1040.     if ( !q )  q = p ;
  1041.  
  1042.     p = p->link ;
  1043.   }
  1044.   
  1045.   /* not there make one  */
  1046.   if ( q )  p = q ; /* reuse the node */
  1047.   else
  1048.   { p = (ANODE *) zmalloc( sizeof(ANODE) ) ;
  1049.     p->link = a[h] ; a[h] = p ; }
  1050.  
  1051.   if ( flag )  p->sval = new_STRING(s) ;
  1052.   else
  1053.   { p->sval = (STRING *) x ; p->sval->ref_cnt++ ; }
  1054.   p->cp = new_CELL() ; p->cp->type = C_NOINIT ;
  1055.   return p->cp ;
  1056. }
  1057.  
  1058. void  array_delete( a, sval)
  1059.   ARRAY a ; STRING *sval ;
  1060. { char *s = sval->str ;
  1061.   register ANODE *p = a[ hash(s) % A_HASH_PRIME ] ;
  1062.  
  1063.   while ( p )
  1064.   { if ( p->sval && strcmp(s, p->sval->str)== 0 ) /* found */
  1065.     { 
  1066.       cell_destroy(p->cp) ;  free_CELL(p->cp) ;
  1067.       free_STRING(p->sval) ; p->sval = (STRING *) 0 ;
  1068.  
  1069.       break ;
  1070.     }
  1071.  
  1072.     p = p->link ;
  1073.   }
  1074. }
  1075.       
  1076.  
  1077. /* for ( i in A ) ,
  1078.    loop over elements of an array 
  1079.  
  1080. sp[0].ptr :  a pointer to A ( the hash table of A)
  1081. sp[-1] :  a pointer to i ( a cell ptr)
  1082.  
  1083. cdp[0] :  a stop op to catch breaks
  1084. cdp[1] :  offset from cdp of the code after the loop (n+2)
  1085. cdp[2] :  start of body of the loop
  1086. cdp[3..n] : the rest of the body
  1087. cdp[n+1]  : a stop op to delimit the body and catch continues
  1088. */
  1089.  
  1090. INST  *array_loop( cdp, sp, fp) /* passed code, stack and frame ptrs */
  1091.   INST *cdp ; 
  1092.   CELL *sp, *fp ;
  1093. { int i ;
  1094.   register ANODE *p ;
  1095.   ARRAY   A = (ARRAY) sp-- -> ptr ;
  1096.   register CELL *cp = (CELL *) sp-- -> ptr ;
  1097.  
  1098.   for ( i = 0 ; i < A_HASH_PRIME ; i++ )
  1099.   for ( p = A[i] ; p ; p = p->link )
  1100.   { if ( ! p->sval /* its deleted */ )  continue ;
  1101.   
  1102.     cell_destroy(cp) ;
  1103.     cp->type = C_STRING ;
  1104.     cp->ptr = (PTR) p->sval ;
  1105.     p->sval->ref_cnt++ ;
  1106.  
  1107.     /* execute the body of the loop */
  1108.     if ( execute(cdp+2, sp, fp) == cdp /* exec'ed a break statement */
  1109.          || returning  /* function return in body of loop */
  1110.        )  
  1111.            goto break2 /* break both for loops */ ; 
  1112.   }
  1113.  
  1114. break2 :
  1115.   return   cdp + cdp[1].op ;
  1116. }
  1117.  
  1118.  
  1119. /* cat together cnt elements on the eval stack to form
  1120.    an array index using SUBSEP */
  1121.  
  1122. CELL *array_cat( sp, cnt)
  1123.   register CELL *sp ;
  1124.   int cnt ;
  1125. { register CELL *p ;  /* walks the stack */
  1126.   CELL subsep ;  /* a copy of bi_vars[SUBSEP] */
  1127.   unsigned subsep_len ;
  1128.   char *subsep_str ;
  1129.   unsigned total_len ; /* length of cat'ed expression */
  1130.   CELL *top ;  /* sp at entry */
  1131.   char *t ; /* target ptr when catting */
  1132.   STRING *sval ;  /* build new STRING here */
  1133.  
  1134.   /* get a copy of subsep, we may need to cast */
  1135.   (void) cellcpy(&subsep, bi_vars + SUBSEP) ;
  1136.   if ( subsep.type < C_STRING ) cast1_to_s(&subsep) ;
  1137.   subsep_len = string(&subsep)->len ;
  1138.   subsep_str = string(&subsep)->str ;
  1139.   total_len = --cnt * subsep_len ;
  1140.  
  1141.   top = sp ;
  1142.   sp -= cnt ;
  1143.   for( p = sp ; p <= top ; p++ )
  1144.   {
  1145.     if ( p->type < C_STRING ) cast1_to_s(p) ;
  1146.     total_len += string(p)->len ;
  1147.   }
  1148.  
  1149.   sval = new_STRING((char *)0, total_len) ;
  1150.   t = sval->str ;
  1151.  
  1152.   /* put the pieces together */
  1153.   for( p = sp ; p < top ; p++ )
  1154.   { (void) memcpy(t, string(p)->str, string(p)->len) ;
  1155.     (void) memcpy( t += string(p)->len, subsep_str, subsep_len) ;
  1156.     t += subsep_len ;
  1157.   }
  1158.   /* p == top */
  1159.   (void) memcpy(t, string(p)->str, string(p)->len) ;
  1160.  
  1161.   /* done, now cleanup */
  1162.   free_STRING(string(&subsep)) ;
  1163.   while ( p >= sp )  { free_STRING(string(p)) ; p-- ; }
  1164.   sp->type = C_STRING ;
  1165.   sp->ptr = (PTR) sval ;
  1166.   return sp ;
  1167. }
  1168.  
  1169.  
  1170. /* free all memory used by an array,
  1171.    only used for arrays local to a function call
  1172. */
  1173.  
  1174. void  array_free(A)
  1175.   ARRAY  A ;
  1176. { register ANODE *p ;
  1177.   register int i ;
  1178.   ANODE *q ;
  1179.  
  1180.   for( i = 0 ; i < A_HASH_PRIME ; i++ )
  1181.   { p = A[i] ;
  1182.     while ( p )
  1183.     { /* check its not a deleted node */
  1184.       if ( p->sval )
  1185.       { free_STRING(p->sval) ;
  1186.         cell_destroy(p->cp) ;
  1187.         free_CELL(p->cp) ;
  1188.       }
  1189.  
  1190.       q = p ; p = p->link ;
  1191.       zfree( q, sizeof(ANODE)) ;
  1192.     }
  1193.   }
  1194.  
  1195.   zfree(A, sizeof(ANODE *) * A_HASH_PRIME ) ;
  1196. }
  1197. @//E*O*F mawk0.97/array.c//
  1198. chmod u=rw,g=r,o=r mawk0.97/array.c
  1199.  
  1200. echo x - mawk0.97/bi_funct.c
  1201. sed 's/^@//' > "mawk0.97/bi_funct.c" <<'@//E*O*F mawk0.97/bi_funct.c//'
  1202.  
  1203. /********************************************
  1204. bi_funct.c
  1205. copyright 1991, Michael D. Brennan
  1206.  
  1207. This is a source file for mawk, an implementation of
  1208. the Awk programming language as defined in
  1209. Aho, Kernighan and Weinberger, The AWK Programming Language,
  1210. Addison-Wesley, 1988.
  1211.  
  1212. See the accompaning file, LIMITATIONS, for restrictions
  1213. regarding modification and redistribution of this
  1214. program in source or binary form.
  1215. ********************************************/
  1216.  
  1217.  
  1218. /* $Log:    bi_funct.c,v $
  1219.  * Revision 2.3  91/04/17  06:34:00  brennan
  1220.  * index("","") should be 1 not 0 for consistency with match("",//)
  1221.  * 
  1222.  * Revision 2.2  91/04/09  12:38:42  brennan
  1223.  * added static to funct decls to satisfy STARDENT compiler
  1224.  * 
  1225.  * Revision 2.1  91/04/08  08:22:17  brennan
  1226.  * VERSION 0.97
  1227.  * 
  1228. */
  1229.  
  1230.  
  1231. #include "mawk.h"
  1232. #include "bi_funct.h"
  1233. #include "bi_vars.h"
  1234. #include "memory.h"
  1235. #include "init.h"
  1236. #include "files.h"
  1237. #include "fin.h"
  1238. #include "field.h"
  1239. #include "regexp.h"
  1240. #include "repl.h"
  1241. #include <math.h>
  1242.  
  1243. #ifndef  BSD43
  1244. void PROTO( srand48, (long) ) ;
  1245. double PROTO( drand48, (void) ) ;
  1246. #endif
  1247.  
  1248. /* statics */
  1249. static STRING *PROTO(gsub, (PTR, CELL *, char *, int) ) ;
  1250. static void  PROTO( fplib_err, (char *, double, char *) ) ;
  1251.  
  1252.  
  1253. /* global for the disassembler */
  1254. BI_REC  bi_funct[] = { /* info to load builtins */
  1255.  
  1256. "index" , bi_index , 2, 2 ,
  1257. "substr" , bi_substr, 2, 3,
  1258. "sprintf" , bi_sprintf, 1, 255,
  1259. "sin", bi_sin , 1, 1 ,
  1260. "cos", bi_cos , 1, 1 ,
  1261. "atan2", bi_atan2, 2,2,
  1262. "exp", bi_exp, 1, 1,
  1263. "log", bi_log , 1, 1 ,
  1264. "int", bi_int, 1, 1,
  1265. "sqrt", bi_sqrt, 1, 1,
  1266. "rand" , bi_rand, 0, 0,
  1267. "srand", bi_srand, 0, 1,
  1268. "close", bi_close, 1, 1,
  1269. "system", bi_system, 1, 1,
  1270.  
  1271. #if  DOS   /* this might go away, when pipes and system are added
  1272.           for DOS  */
  1273. "errmsg", bi_errmsg, 1, 1,
  1274. #endif
  1275.  
  1276. (char *) 0, (PF_CP) 0, 0, 0 } ;
  1277.  
  1278.  
  1279.  
  1280. void bi_funct_init()
  1281. { register BI_REC *p = bi_funct ;
  1282.   register SYMTAB *stp ;
  1283.  
  1284.   while ( p->name )
  1285.   { stp = insert( p->name ) ;
  1286.     stp->type = ST_BUILTIN ;
  1287.     stp->stval.bip = p++ ;
  1288.   }
  1289.   /* seed rand() off the clock */
  1290.   { CELL c ;
  1291.  
  1292.     c.type = 0 ; (void) bi_srand(&c) ;
  1293.   }
  1294.  
  1295.   stp = insert( "length") ;
  1296.   stp->type = ST_LENGTH ;
  1297. }
  1298.  
  1299. /**************************************************
  1300.  string builtins (except split (in split.c) and [g]sub (at end))
  1301.  **************************************************/
  1302.  
  1303. CELL *bi_length(sp)
  1304.   register  CELL *sp ;
  1305. { unsigned len ;
  1306.  
  1307.   if ( sp->type < C_STRING ) cast1_to_s(sp) ;
  1308.   len = string(sp)->len ;
  1309.  
  1310.   free_STRING( string(sp) ) ;
  1311.   sp->type = C_DOUBLE ;
  1312.   sp->dval = (double) len ;
  1313.  
  1314.   return sp ;
  1315. }
  1316.  
  1317. char *str_str(target, key , key_len)
  1318.   register char *target, *key ;
  1319.   unsigned key_len ;
  1320. { 
  1321.   switch( key_len )
  1322.   { case 0 :  return (char *) 0 ;
  1323.     case 1 :  return strchr( target, *key) ;
  1324.     case 2 :
  1325.         while ( target = strchr(target, *key) )
  1326.           if ( target[1] == key[1] )  return  target ;
  1327.           else target++ ;
  1328.         /*failed*/
  1329.         return (char *) 0 ;
  1330.   }
  1331.   key_len-- ;
  1332.   while ( target = strchr(target, *key) )
  1333.         if ( memcmp(target+1, key+1, key_len) == 0 ) return target ;
  1334.         else target++ ;
  1335.   /*failed*/
  1336.   return (char *) 0 ;
  1337. }
  1338.  
  1339.  
  1340.  
  1341. CELL *bi_index(sp)
  1342.   register CELL *sp ;
  1343. { register int idx ;
  1344.   unsigned len ;
  1345.   char *p ;
  1346.  
  1347.   sp-- ;
  1348.   if ( TEST2(sp) != TWO_STRINGS )
  1349.         cast2_to_s(sp) ;
  1350.  
  1351.   if ( len = string(sp+1)->len )
  1352.     idx = (p = str_str(string(sp)->str,string(sp+1)->str,len))
  1353.           ? p - string(sp)->str + 1 : 0 ;
  1354.  
  1355.   else  /* index of the empty string */
  1356.     idx = 1 ;
  1357.   
  1358.   free_STRING( string(sp) ) ;
  1359.   free_STRING( string(sp+1) ) ;
  1360.   sp->type = C_DOUBLE ;
  1361.   sp->dval = (double) idx ;
  1362.   return sp ;
  1363. }
  1364.  
  1365. /*  substr(s, i, n)
  1366.     if l = length(s)
  1367.     then get the characters
  1368.     from  max(1,i) to min(l,n-i-1) inclusive */
  1369.  
  1370. CELL *bi_substr(sp)
  1371.   CELL *sp ;
  1372. { int n_args, len ;
  1373.   register int i, n ;
  1374.   char *s ;    /* substr(s, i, n) */
  1375.   STRING *sval ;
  1376.  
  1377.   n_args = sp->type ;
  1378.   sp -= n_args ;
  1379.   if ( sp->type < C_STRING )  cast1_to_s(sp) ;
  1380.   s = (sval = string(sp)) -> str ;
  1381.  
  1382.   if ( n_args == 2 )  
  1383.   { n = 0x7fff  ;  /* essentially infinity */
  1384.     if ( sp[1].type != C_DOUBLE ) cast1_to_d(sp+1) ; 
  1385.   }
  1386.   else
  1387.   { if ( sp[1].type + sp[2].type != TWO_STRINGS ) cast2_to_d(sp+1) ;
  1388.     n = (int) sp[2].dval ;
  1389.   }
  1390.   i = (int) sp[1].dval - 1 ; /* i now indexes into string */
  1391.  
  1392.  
  1393.   if ( (len = strlen(s)) == 0 )  return sp ;
  1394.   /* get to here is s is not the null string */
  1395.   if ( i < 0 ) { n += i ; i = 0 ; }
  1396.   if ( n > len - i )  n = len - i ;
  1397.  
  1398.   if ( n <= 0 )  /* the null string */
  1399.   { free_STRING( sval ) ;
  1400.     sp->ptr = (PTR) &null_str ;
  1401.     null_str.ref_cnt++ ;
  1402.   }
  1403.   else  /* got something */
  1404.   { 
  1405.     sp->ptr = (PTR) new_STRING((char *)0, n) ;
  1406.     (void) memcpy(string(sp)->str, s+i, n) ;
  1407.     string(sp)->str[n] = 0 ;
  1408.   }
  1409.   return sp ;
  1410. } 
  1411.  
  1412. /*
  1413.   match(s,r)
  1414.   sp[0] holds s, sp[-1] holds r
  1415. */
  1416.  
  1417. CELL *bi_match(sp)
  1418.   register CELL *sp ;
  1419. { double d ;
  1420.   char *p ;
  1421.   unsigned length ;
  1422.  
  1423.   if ( sp->type != C_RE )  cast_to_RE(sp) ;
  1424.   if ( (--sp)->type < C_STRING )  cast1_to_s(sp) ;
  1425.  
  1426.   if ( p = REmatch(string(sp)->str, (sp+1)->ptr, &length) )
  1427.       d = (double) ( p - string(sp)->str + 1 ) ;
  1428.   else  d = 0.0 ;
  1429.  
  1430.   cell_destroy( & bi_vars[RSTART] ) ;
  1431.   cell_destroy( & bi_vars[RLENGTH] ) ;
  1432.   bi_vars[RSTART].type = C_DOUBLE ;
  1433.   bi_vars[RSTART].dval = d ;
  1434.   bi_vars[RLENGTH].type = C_DOUBLE ;
  1435.   bi_vars[RLENGTH].dval = (double) length ;
  1436.  
  1437.   free_STRING(string(sp)) ;
  1438.     
  1439.   sp->type = C_DOUBLE ;  sp->dval = d ;
  1440.   return sp ;
  1441. }
  1442.  
  1443.  
  1444. /************************************************
  1445.   arithemetic builtins
  1446.  ************************************************/
  1447.  
  1448. static void fplib_err( fname, val, error)
  1449.   char *fname ;
  1450.   double val ;
  1451.   char *error ;
  1452. {
  1453.   rt_error("%s(%g) : %s" , fname, val, error) ;
  1454. }
  1455.  
  1456.  
  1457. CELL *bi_sin(sp)
  1458.   register CELL *sp ;
  1459. { 
  1460. #if ! STDC_MATHERR
  1461.   if ( sp->type != C_DOUBLE )  cast1_to_d(sp) ;
  1462.   sp->dval = sin( sp->dval ) ;
  1463.   return sp ;
  1464. #else
  1465.   double x ;
  1466.  
  1467.   errno = 0 ;
  1468.   if ( sp->type != C_DOUBLE )  cast1_to_d(sp) ;
  1469.   x = sp->dval ;
  1470.   sp->dval = sin( sp->dval ) ;
  1471.   if ( errno )  fplib_err("sin", x, "loss of precision") ;
  1472.   return sp ;
  1473. #endif
  1474. }
  1475.  
  1476. CELL *bi_cos(sp)
  1477.   register CELL *sp ;
  1478. { 
  1479. #if ! STDC_MATHERR
  1480.   if ( sp->type != C_DOUBLE )  cast1_to_d(sp) ;
  1481.   sp->dval = cos( sp->dval ) ;
  1482.   return sp ;
  1483. #else
  1484.   double x ;
  1485.  
  1486.   errno = 0 ;
  1487.   if ( sp->type != C_DOUBLE )  cast1_to_d(sp) ;
  1488.   x = sp->dval ;
  1489.   sp->dval = cos( sp->dval ) ;
  1490.   if ( errno )  fplib_err("cos", x, "loss of precision") ;
  1491.   return sp ;
  1492. #endif
  1493. }
  1494.  
  1495. CELL *bi_atan2(sp)
  1496.   register CELL *sp ;
  1497. { 
  1498. #if  !  STDC_MATHERR
  1499.   sp-- ;
  1500.   if ( TEST2(sp) != TWO_DOUBLES ) cast2_to_d(sp) ;
  1501.   sp->dval = atan2(sp->dval, (sp+1)->dval) ;
  1502.   return sp ;
  1503. #else
  1504.  
  1505.   errno = 0 ;
  1506.   sp-- ;
  1507.   if ( TEST2(sp) != TWO_DOUBLES ) cast2_to_d(sp) ;
  1508.   sp->dval = atan2(sp->dval, (sp+1)->dval) ;
  1509.   if ( errno ) rt_error("atan2(0,0) : domain error") ;
  1510.   return sp ;
  1511. #endif
  1512. }
  1513.  
  1514. CELL *bi_log(sp)
  1515.   register CELL *sp ;
  1516. { 
  1517. #if ! STDC_MATHERR
  1518.   if ( sp->type != C_DOUBLE )  cast1_to_d(sp) ;
  1519.   sp->dval = log( sp->dval ) ;
  1520.   return sp ;
  1521. #else
  1522.   double  x ;
  1523.  
  1524.   errno = 0 ;
  1525.   if ( sp->type != C_DOUBLE )  cast1_to_d(sp) ;
  1526.   x = sp->dval ;
  1527.   sp->dval = log( sp->dval ) ;
  1528.   if ( errno )  fplib_err("log", x, "domain error") ;
  1529.   return sp ;
  1530. #endif
  1531. }
  1532.  
  1533. CELL *bi_exp(sp)
  1534.   register CELL *sp ;
  1535. { 
  1536. #if  ! STDC_MATHERR
  1537.   if ( sp->type != C_DOUBLE )  cast1_to_d(sp) ;
  1538.   sp->dval = exp(sp->dval) ;
  1539.   return sp ;
  1540. #else
  1541.   double  x ;
  1542.  
  1543.   errno = 0 ;
  1544.   if ( sp->type != C_DOUBLE )  cast1_to_d(sp) ;
  1545.   x = sp->dval ;
  1546.   sp->dval = exp(sp->dval) ;
  1547.   if ( errno && sp->dval)  fplib_err("exp", x, "overflow") ;
  1548.      /* on underflow sp->dval==0, ignore */
  1549.   return sp ;
  1550. #endif
  1551. }
  1552.  
  1553. CELL *bi_int(sp)
  1554.   register CELL *sp ;
  1555. { if ( sp->type != C_DOUBLE )  cast1_to_d(sp) ;
  1556.   sp->dval = sp->dval >= 0.0 ? floor( sp->dval ) : ceil(sp->dval)  ;
  1557.   return sp ;
  1558. }
  1559.  
  1560. CELL *bi_sqrt(sp)
  1561.   register CELL *sp ;
  1562. { 
  1563. #if  ! STDC_MATHERR
  1564.   if ( sp->type != C_DOUBLE )  cast1_to_d(sp) ;
  1565.   sp->dval = sqrt( sp->dval ) ;
  1566.   return sp ;
  1567. #else
  1568.   double x ;
  1569.  
  1570.   errno = 0 ;
  1571.   if ( sp->type != C_DOUBLE )  cast1_to_d(sp) ;
  1572.   x = sp->dval ;
  1573.   sp->dval = sqrt( sp->dval ) ;
  1574.   if ( errno )  fplib_err("sqrt", x, "domain error") ;
  1575.   return sp ;
  1576. #endif
  1577. }
  1578.  
  1579. #ifdef  __TURBOC__
  1580. long  biostime(int, long) ;
  1581. #define  time(x)  (biostime(0,0L)<<4)
  1582. #else
  1583. #include <sys/types.h>
  1584.  
  1585. #if 0
  1586. #ifndef  STARDENT
  1587. #include <sys/timeb.h>
  1588. #endif
  1589. #endif
  1590.  
  1591. #endif
  1592.  
  1593. CELL *bi_srand(sp)
  1594.   register CELL *sp ;
  1595. { register long l ; 
  1596.   void srand48() ;
  1597.  
  1598.   if ( sp-- -> type )  /* user seed */
  1599.   { if ( sp->type != C_DOUBLE )  cast1_to_d(sp) ;
  1600.     l = (long) sp->dval ; }
  1601.   else
  1602.   { l = (long) time( (time_t *) 0 ) ;
  1603.     (++sp)->type = C_DOUBLE ;
  1604.     sp->dval = (double) l ;
  1605.   }
  1606.   srand48(l) ;
  1607.   return sp ;
  1608. }
  1609.     
  1610. CELL *bi_rand(sp)
  1611.   register CELL *sp ;
  1612. { 
  1613.  
  1614.   (++sp)->type = C_DOUBLE ;
  1615.   sp->dval = drand48() ;
  1616.   return sp ;
  1617. }
  1618.  
  1619. /*************************************************
  1620.  miscellaneous builtins
  1621.  close, system and getline
  1622.  *************************************************/
  1623.  
  1624. CELL *bi_close(sp)
  1625.   register CELL *sp ;
  1626. { int x ;
  1627.  
  1628.   if ( sp->type < C_STRING ) cast1_to_s(sp) ;
  1629.   x = file_close( (STRING *) sp->ptr) ;
  1630.   free_STRING( string(sp) ) ;
  1631.   sp->type = C_DOUBLE ;
  1632.   sp->dval = (double) x ;
  1633.   return sp ;
  1634. }
  1635.  
  1636. #if   ! DOS
  1637. CELL *bi_system(sp)
  1638.   CELL *sp ;
  1639. { int pid ;
  1640.   unsigned ret_val ;
  1641.  
  1642.   if ( !shell ) shell = (shell = getenv("SHELL")) ? shell : "/bin/sh" ;
  1643.   if ( sp->type < C_STRING ) cast1_to_s(sp) ;
  1644.  
  1645.   switch( pid = fork() )
  1646.   { case -1 :  /* fork failed */
  1647.  
  1648.        errmsg(errno, "could not create a new process") ;
  1649.        ret_val = 128 ;
  1650.        break ;
  1651.  
  1652.     case  0  :  /* the child */
  1653.        (void) execl(shell, shell, "-c", string(sp)->str, (char *) 0) ;
  1654.        /* if get here, execl() failed */
  1655.        errmsg(errno, "execute of %s failed", shell) ;
  1656.        fflush(stderr) ;
  1657.        _exit(128) ;
  1658.  
  1659.     default   :  /* wait for the child */
  1660.        ret_val = wait_for(pid) ;
  1661.        if ( ret_val & 0xff ) ret_val = 128 ;
  1662.        else  ret_val = (ret_val & 0xff00) >> 8 ;
  1663.        break ;
  1664.   }
  1665.  
  1666.   cell_destroy(sp) ;
  1667.   sp->type = C_DOUBLE ;
  1668.   sp->dval = (double) ret_val ;
  1669.   return sp ;
  1670. }
  1671.  
  1672. #else   /*  DOS   */
  1673.  
  1674. CELL *bi_system( sp )
  1675.   register CELL *sp ;
  1676. { rt_error("no system call in MsDos --yet") ;
  1677.   return sp ;
  1678. }
  1679.  
  1680. /* prints errmsgs for DOS  */
  1681. CELL *bi_errmsg(sp)
  1682.   register CELL *sp ;
  1683. {
  1684.   cast1_to_s(sp) ;
  1685.   fprintf(stderr, "%s\n", string(sp)->str) ;
  1686.   free_STRING(string(sp)) ;
  1687.   sp->type = C_DOUBLE ;
  1688.   sp->dval = 0.0 ;
  1689.   return sp ;
  1690. }
  1691. #endif
  1692.  
  1693.  
  1694. /*  getline()  */
  1695.  
  1696. /*  if type == 0 :  stack is 0 , target address
  1697.  
  1698.     if type == F_IN : stack is F_IN, expr(filename), target address
  1699.  
  1700.     if type == PIPE_IN : stack is PIPE_IN, target address, expr(pipename)
  1701. */
  1702.  
  1703. CELL *bi_getline(sp)
  1704.   register CELL *sp ;
  1705. { 
  1706.   CELL tc , *cp ;
  1707.   char *p ;
  1708.   unsigned len ;
  1709.   FIN *fin_p ;
  1710.  
  1711.  
  1712.   switch( sp->type )
  1713.   { 
  1714.     case 0 :
  1715.         sp-- ;
  1716.         if ( main_fin == (FIN *) -1 && ! open_main() )
  1717.                 goto open_failure ;
  1718.     
  1719.         if ( ! main_fin || !(p = FINgets(main_fin, &len)) )
  1720.                 goto  eof ;
  1721.  
  1722.         cp = (CELL *) sp->ptr ;
  1723.         if ( TEST2(bi_vars+NR) != TWO_DOUBLES ) cast2_to_d(bi_vars+NR) ;
  1724.         bi_vars[NR].dval += 1.0 ;
  1725.         bi_vars[FNR].dval += 1.0 ;
  1726.         break ;
  1727.  
  1728.     case  F_IN :
  1729.         sp-- ;
  1730.         if ( sp->type < C_STRING ) cast1_to_s(sp) ;
  1731.         fin_p = (FIN *) file_find(sp->ptr, F_IN) ;
  1732.         free_STRING(string(sp) ) ;
  1733.         sp-- ;
  1734.  
  1735.         if ( ! fin_p )   goto open_failure ;
  1736.         if ( ! (p = FINgets(fin_p, &len)) )  goto eof ; 
  1737.         cp = (CELL *) sp->ptr ;
  1738.         break ;
  1739.  
  1740.     case PIPE_IN :
  1741.         sp -= 2 ;
  1742.         if ( sp->type < C_STRING ) cast1_to_s(sp) ;
  1743.         fin_p = (FIN *) file_find(sp->ptr, PIPE_IN) ;
  1744.         free_STRING(string(sp)) ;
  1745.  
  1746.         if ( ! fin_p )   goto open_failure ;
  1747.         if ( ! (p = FINgets(fin_p, &len)) )  goto eof ; 
  1748.         cp = (CELL *) (sp+1)->ptr ;
  1749.         break ;
  1750.  
  1751.     default : bozo("type in bi_getline") ;
  1752.  
  1753.   }
  1754.  
  1755.   /* we've read a line , store it */
  1756.  
  1757.     if ( len == 0 )
  1758.     { tc.type = C_STRING ; 
  1759.       tc.ptr = (PTR) &null_str ; 
  1760.       null_str.ref_cnt++ ;
  1761.     }
  1762.     else
  1763.     { tc.type = C_MBSTRN ;
  1764.       tc.ptr = (PTR) new_STRING((char *) 0, len) ;
  1765.       (void) memcpy( string(&tc)->str, p, len) ;
  1766.     }
  1767.  
  1768.     if ( cp  >= field && cp < field+NUM_FIELDS )
  1769.            field_assign(cp-field, &tc) ;
  1770.     else
  1771.     { cell_destroy(cp) ;
  1772.       (void) cellcpy(cp, &tc) ;
  1773.     }
  1774.  
  1775.     cell_destroy(&tc) ;
  1776.  
  1777.   sp->dval = 1.0  ;  goto done ;
  1778.  
  1779. open_failure :
  1780.   sp->dval = -1.0  ; goto done ;
  1781.  
  1782. eof :
  1783.   sp->dval = 0.0  ;  /* fall thru to done  */
  1784.  
  1785. done :
  1786.   sp->type = C_DOUBLE  ;
  1787.   return sp ;
  1788. }
  1789.  
  1790. /**********************************************
  1791.  sub() and gsub()
  1792.  **********************************************/
  1793.  
  1794. /* entry:  sp[0] = address of CELL to sub on
  1795.            sp[-1] = substitution CELL
  1796.            sp[-2] = regular expression to match
  1797. */
  1798.  
  1799. CELL *bi_sub( sp )
  1800.   register CELL *sp ;
  1801. { CELL *cp ; /* pointer to the replacement target */
  1802.   CELL tc ;  /* build the new string here */
  1803.   CELL sc ;  /* copy of the target CELL */
  1804.   char *front, *middle, *back ; /* pieces */
  1805.   unsigned front_len, middle_len, back_len ;
  1806.  
  1807.   sp -= 2 ;
  1808.   if ( sp->type != C_RE )  cast_to_RE(sp) ;
  1809.   if ( sp[1].type != C_REPL && sp[1].type != C_REPLV )
  1810.               cast_to_REPL(sp+1) ;
  1811.   cp = (CELL *) (sp+2)->ptr ;
  1812.   /* make a copy of the target, because we won't change anything
  1813.      including type unless the match works */
  1814.   (void) cellcpy(&sc, cp) ;
  1815.   if ( sc.type < C_STRING ) cast1_to_s(&sc) ;
  1816.   front = string(&sc)->str ;
  1817.  
  1818.   if ( middle = REmatch(front, sp->ptr, &middle_len) )
  1819.   { 
  1820.     front_len = middle - front ;
  1821.     back = middle + middle_len ; 
  1822.     back_len = string(&sc)->len - front_len - middle_len ;
  1823.  
  1824.     if ( (sp+1)->type == C_REPLV ) 
  1825.     { STRING *sval = new_STRING((char *) 0, middle_len) ;
  1826.  
  1827.       (void) memcpy(sval->str, middle, middle_len) ;
  1828.       (void) replv_to_repl(sp+1, sval) ;
  1829.       free_STRING(sval) ;
  1830.     }
  1831.  
  1832.     tc.type = C_STRING ;
  1833.     tc.ptr = (PTR) new_STRING((char *) 0, 
  1834.              front_len + string(sp+1)->len + back_len ) ;
  1835.  
  1836.     { char *p = string(&tc)->str ;
  1837.  
  1838.       if ( front_len )
  1839.       { (void) memcpy(p, front, front_len) ;
  1840.         p += front_len ;
  1841.       }
  1842.       if ( string(sp+1)->len )
  1843.       { (void) memcpy(p, string(sp+1)->str, string(sp+1)->len) ;
  1844.         p += string(sp+1)->len ;
  1845.       }
  1846.       if ( back_len )  (void) memcpy(p, back, back_len) ;
  1847.     }
  1848.  
  1849.     if ( cp  >= field && cp < field+NUM_FIELDS )
  1850.            field_assign(cp-field, &tc) ;
  1851.     else
  1852.     { cell_destroy(cp) ;
  1853.       (void) cellcpy(cp, &tc) ;
  1854.     }
  1855.  
  1856.     free_STRING(string(&tc)) ;
  1857.   }
  1858.  
  1859.   free_STRING(string(&sc)) ;
  1860.   repl_destroy(sp+1) ;
  1861.   sp->type = C_DOUBLE ;
  1862.   sp->dval = middle != (char *) 0 ? 1.0 : 0.0 ;
  1863.   return sp ;
  1864. }
  1865.  
  1866. static  unsigned repl_cnt ;  /* number of global replacements */
  1867.  
  1868. /* recursive global subsitution 
  1869.    dealing with empty matches makes this mildly painful
  1870. */
  1871.  
  1872. static STRING *gsub( re, repl, target, flag)
  1873.   PTR  re ;
  1874.   CELL *repl ;  /* always of type REPL or REPLV */
  1875.   char *target ;
  1876.   int flag ; /* if on, match of empty string at front is OK */
  1877. { char *front, *middle ;
  1878.   STRING *back ;
  1879.   unsigned front_len, middle_len ;
  1880.   STRING  *ret_val ;
  1881.   CELL xrepl ; /* a copy of repl so we can change repl */
  1882.  
  1883.   if ( ! (middle = REmatch(target, re, &middle_len)) )
  1884.       return  new_STRING(target) ; /* no match */
  1885.  
  1886.   (void) cellcpy(&xrepl, repl) ;
  1887.  
  1888.   if ( !flag && middle_len == 0 && middle == target ) 
  1889.   { /* match at front that's not allowed */
  1890.  
  1891.     if ( *target == 0 )  /* target is empty string */
  1892.     { null_str.ref_cnt++ ;
  1893.       return & null_str ;
  1894.     }
  1895.     else
  1896.     { char xbuff[2] ;
  1897.  
  1898.       front_len = 0 ;
  1899.       /* make new repl with target[0] */
  1900.       repl_destroy(repl) ;
  1901.       xbuff[0] = *target++ ;  xbuff[1] = 0 ;
  1902.       repl->type = C_REPL ;
  1903.       repl->ptr = (PTR) new_STRING( xbuff ) ;
  1904.       back = gsub(re, &xrepl, target, 1) ;
  1905.     }
  1906.   }
  1907.   else  /* a match that counts */
  1908.   { repl_cnt++ ;
  1909.  
  1910.     front = target ;
  1911.     front_len = middle - target ;
  1912.  
  1913.     if ( *middle == 0 )  /* matched back of target */
  1914.     { back = &null_str ; null_str.ref_cnt++ ; }
  1915.     else back = gsub(re, &xrepl, middle + middle_len, 0) ;
  1916.       
  1917.     /* patch the &'s if needed */
  1918.     if ( repl->type == C_REPLV )
  1919.     { STRING *sval = new_STRING((char *) 0, middle_len) ;
  1920.  
  1921.       (void) memcpy(sval->str, middle, middle_len) ;
  1922.       (void) replv_to_repl(repl, sval) ;
  1923.       free_STRING(sval) ;
  1924.     }
  1925.   }
  1926.  
  1927.   /* put the three pieces together */
  1928.   ret_val = new_STRING((char *)0,
  1929.               front_len + string(repl)->len + back->len); 
  1930.   { char *p = ret_val->str ;
  1931.  
  1932.     if ( front_len )
  1933.     { (void) memcpy(p, front, front_len) ; p += front_len ; }
  1934.     if ( string(repl)->len )
  1935.     { (void) memcpy(p, string(repl)->str, string(repl)->len) ;
  1936.       p += string(repl)->len ;
  1937.     }
  1938.     if ( back->len ) (void) memcpy(p, back->str, back->len) ;
  1939.   }
  1940.  
  1941.   /* cleanup, repl is freed by the caller */
  1942.   repl_destroy(&xrepl) ;
  1943.   free_STRING(back) ;
  1944.  
  1945.   return ret_val ;
  1946. }
  1947.  
  1948. /* set up for call to gsub() */
  1949. CELL *bi_gsub( sp )
  1950.   register CELL *sp ;
  1951. { CELL *cp ;  /* pts at the replacement target */
  1952.   CELL sc  ;  /* copy of replacement target */
  1953.   CELL tc  ;  /* build the result here */
  1954.  
  1955.   sp -= 2 ;
  1956.   if ( sp->type != C_RE ) cast_to_RE(sp) ;
  1957.   if ( (sp+1)->type != C_REPL && (sp+1)->type != C_REPLV )
  1958.           cast_to_REPL(sp+1) ;
  1959.  
  1960.   (void) cellcpy(&sc, cp = (CELL *)(sp+2)->ptr) ;
  1961.   if ( sc.type < C_STRING ) cast1_to_s(&sc) ;
  1962.  
  1963.   repl_cnt = 0 ;
  1964.   tc.ptr = (PTR) gsub(sp->ptr, sp+1, string(&sc)->str, 1) ;
  1965.  
  1966.   if ( repl_cnt )
  1967.   { tc.type = C_STRING ;
  1968.  
  1969.     if ( cp >= field && cp < field + NUM_FIELDS )
  1970.         field_assign(cp-field, &tc) ;
  1971.     else
  1972.     { cell_destroy(cp) ; (void) cellcpy(cp, &tc) ; }
  1973.   }
  1974.  
  1975.   /* cleanup */
  1976.   free_STRING(string(&sc)) ; free_STRING(string(&tc)) ;
  1977.   repl_destroy(sp+1) ;
  1978.  
  1979.   sp->type = C_DOUBLE ;
  1980.   sp->dval = (double) repl_cnt ;
  1981.   return sp ;
  1982. }
  1983. @//E*O*F mawk0.97/bi_funct.c//
  1984. chmod u=rw,g=r,o=r mawk0.97/bi_funct.c
  1985.  
  1986. echo x - mawk0.97/bi_funct.h
  1987. sed 's/^@//' > "mawk0.97/bi_funct.h" <<'@//E*O*F mawk0.97/bi_funct.h//'
  1988.  
  1989. /********************************************
  1990. bi_funct.h
  1991. copyright 1991, Michael D. Brennan
  1992.  
  1993. This is a source file for mawk, an implementation of
  1994. the Awk programming language as defined in
  1995. Aho, Kernighan and Weinberger, The AWK Programming Language,
  1996. Addison-Wesley, 1988.
  1997.  
  1998. See the accompaning file, LIMITATIONS, for restrictions
  1999. regarding modification and redistribution of this
  2000. program in source or binary form.
  2001. ********************************************/
  2002.  
  2003.  
  2004. /* $Log:    bi_funct.h,v $
  2005.  * Revision 2.2  91/04/22  08:00:13  brennan
  2006.  * prototype for bi_errmsg() under DOS
  2007.  * 
  2008.  * Revision 2.1  91/04/08  08:22:20  brennan
  2009.  * VERSION 0.97
  2010.  * 
  2011. */
  2012.  
  2013. #ifndef  BI_FUNCT_H
  2014. #define  BI_FUNCT_H  1
  2015.  
  2016. #include "symtype.h"
  2017.  
  2018. extern BI_REC  bi_funct[] ;
  2019.  
  2020. void PROTO(bi_init, (void) ) ;
  2021.  
  2022. /* builtin string functions */
  2023. CELL *PROTO( bi_print, (CELL *) ) ;
  2024. CELL *PROTO( bi_printf, (CELL *) ) ;
  2025. CELL *PROTO( bi_length, (CELL *) ) ;
  2026. CELL *PROTO( bi_index, (CELL *) ) ;
  2027. CELL *PROTO( bi_substr, (CELL *) ) ;
  2028. CELL *PROTO( bi_sprintf, (CELL *) ) ;
  2029. CELL *PROTO( bi_split, (CELL *) ) ;
  2030. CELL *PROTO( bi_match, (CELL *) ) ;
  2031. CELL *PROTO( bi_getline, (CELL *) ) ;
  2032. CELL *PROTO( bi_sub, (CELL *) ) ;
  2033. CELL *PROTO( bi_gsub, (CELL *) ) ;
  2034.  
  2035. /* builtin arith functions */
  2036. CELL *PROTO( bi_sin, (CELL *) ) ;
  2037. CELL *PROTO( bi_cos, (CELL *) ) ;
  2038. CELL *PROTO( bi_atan2, (CELL *) ) ;
  2039. CELL *PROTO( bi_log, (CELL *) ) ;
  2040. CELL *PROTO( bi_exp, (CELL *) ) ;
  2041. CELL *PROTO( bi_int, (CELL *) ) ;
  2042. CELL *PROTO( bi_sqrt, (CELL *) ) ;
  2043. CELL *PROTO( bi_srand, (CELL *) ) ;
  2044. CELL *PROTO( bi_rand, (CELL *) ) ;
  2045.  
  2046. /* other builtins */
  2047. CELL *PROTO( bi_close, (CELL *) ) ;
  2048. CELL *PROTO( bi_system, (CELL *) ) ;
  2049.  
  2050. #if  DOS
  2051. CELL *PROTO(bi_errmsg, (CELL *) ) ;
  2052. #endif
  2053.  
  2054. #endif  /* BI_FUNCT_H  */
  2055.  
  2056. @//E*O*F mawk0.97/bi_funct.h//
  2057. chmod u=rw,g=r,o=r mawk0.97/bi_funct.h
  2058.  
  2059. echo x - mawk0.97/bi_vars.c
  2060. sed 's/^@//' > "mawk0.97/bi_vars.c" <<'@//E*O*F mawk0.97/bi_vars.c//'
  2061.  
  2062. /********************************************
  2063. bi_vars.c
  2064. copyright 1991, Michael D. Brennan
  2065.  
  2066. This is a source file for mawk, an implementation of
  2067. the Awk programming language as defined in
  2068. Aho, Kernighan and Weinberger, The AWK Programming Language,
  2069. Addison-Wesley, 1988.
  2070.  
  2071. See the accompaning file, LIMITATIONS, for restrictions
  2072. regarding modification and redistribution of this
  2073. program in source or binary form.
  2074. ********************************************/
  2075.  
  2076. /* $Log:    bi_vars.c,v $
  2077.  * Revision 2.1  91/04/08  08:22:22  brennan
  2078.  * VERSION 0.97
  2079.  * 
  2080. */
  2081.  
  2082.  
  2083. /* bi_vars.c */
  2084.  
  2085. #include "mawk.h"
  2086. #include "symtype.h"
  2087. #include "bi_vars.h"
  2088. #include "field.h"
  2089. #include "init.h"
  2090. #include "memory.h"
  2091.  
  2092. /* the builtin variables */
  2093. CELL  bi_vars[NUM_BI_VAR] ;
  2094.  
  2095. /* the order here must match the order in bi_vars.h */
  2096.  
  2097. static char *bi_var_names[NUM_BI_VAR] = {
  2098. "ARGC" ,
  2099. "FILENAME" ,
  2100. "NR" ,
  2101. "FNR" ,
  2102. "OFS" ,
  2103. "ORS" ,
  2104. "RLENGTH" ,
  2105. "RSTART" ,
  2106. "SUBSEP",
  2107. "VERSION"
  2108. } ;
  2109.  
  2110. /* insert the builtin vars in the hash table */
  2111.  
  2112. void  bi_vars_init()
  2113. { register int i ;
  2114.   register SYMTAB *s ;
  2115.  
  2116.   for ( i = 0 ; i < NUM_BI_VAR ; i++ )
  2117.   { s = insert( bi_var_names[i] ) ;
  2118.     s->type = ST_VAR ; s->stval.cp = bi_vars + i ;
  2119.     /* bi_vars[i].type = 0 which is C_NOINIT */
  2120.   }
  2121.   /* set defaults */
  2122.  
  2123.   bi_vars[FILENAME].type = C_STRING ;
  2124.   bi_vars[FILENAME].ptr = (PTR) new_STRING( "" ) ; 
  2125.  
  2126.   bi_vars[ OFS ].type = C_STRING ;
  2127.   bi_vars[OFS].ptr = (PTR) new_STRING( " " ) ;
  2128.   
  2129.   bi_vars[ ORS ].type = C_STRING ;
  2130.   bi_vars[ORS].ptr = (PTR) new_STRING( "\n" ) ;
  2131.  
  2132.   bi_vars[ SUBSEP ].type = C_STRING ;
  2133.   bi_vars[SUBSEP].ptr =  (PTR) new_STRING( "\034" ) ;
  2134.  
  2135.   bi_vars[VERSION].type = C_STRING ;
  2136.   bi_vars[VERSION].ptr = (PTR) new_STRING( VERSION_STRING ) ;
  2137.  
  2138.   bi_vars[NR].type = bi_vars[FNR].type = C_DOUBLE ;
  2139.   /* dval is already 0.0 */
  2140.  
  2141.   cell_zero.type = C_DOUBLE ;
  2142.   cell_one.type = C_DOUBLE ;
  2143.   cell_one.dval = 1.0 ;
  2144. }
  2145.  
  2146. CELL cell_zero ;
  2147. CELL cell_one ;
  2148. @//E*O*F mawk0.97/bi_vars.c//
  2149. chmod u=rw,g=r,o=r mawk0.97/bi_vars.c
  2150.  
  2151. echo x - mawk0.97/bi_vars.h
  2152. sed 's/^@//' > "mawk0.97/bi_vars.h" <<'@//E*O*F mawk0.97/bi_vars.h//'
  2153.  
  2154. /********************************************
  2155. bi_vars.h
  2156. copyright 1991, Michael D. Brennan
  2157.  
  2158. This is a source file for mawk, an implementation of
  2159. the Awk programming language as defined in
  2160. Aho, Kernighan and Weinberger, The AWK Programming Language,
  2161. Addison-Wesley, 1988.
  2162.  
  2163. See the accompaning file, LIMITATIONS, for restrictions
  2164. regarding modification and redistribution of this
  2165. program in source or binary form.
  2166. ********************************************/
  2167.  
  2168.  
  2169. /* $Log:    bi_vars.h,v $
  2170.  * Revision 2.1  91/04/08  08:26:30  brennan
  2171.  * VERSION 0.97
  2172.  * 
  2173. */
  2174.  
  2175.  
  2176. /* bi_vars.h */
  2177.  
  2178. #ifndef  BI_VARS_H
  2179. #define  BI_VARS_H  1
  2180.  
  2181. #define  VERSION_STRING  \
  2182.   "mawk 0.97 Mar 1991, Copyright (C) Michael D. Brennan"
  2183.  
  2184. /* If use different command line syntax for DOS
  2185.    mark that in VERSION  */
  2186.  
  2187. #if  DOS  &&  ! HAVE_REARGV
  2188. #undef   VERSION_STRING
  2189. #define  VERSION_STRING  \
  2190.   "mawk 0.97DOS Mar 1991, Copyright (C) Michael D. Brennan"
  2191. #endif
  2192.  
  2193. /* builtin variables NF, RS, FS, OFMT are stored
  2194.    internally in field[], so side effects of assignment can
  2195.    be handled 
  2196. */
  2197.  
  2198. #define  ARGC      0
  2199. #define  FILENAME  1
  2200. #define  NR        2  /* NR must be exactly one in front of FNR */
  2201. #define  FNR       3
  2202. #define  OFS       4
  2203. #define  ORS       5
  2204. #define  RLENGTH   6
  2205. #define  RSTART    7
  2206. #define  SUBSEP    8
  2207. #define  VERSION   9
  2208. #define  NUM_BI_VAR  10
  2209.  
  2210. extern CELL bi_vars[NUM_BI_VAR] ;
  2211.  
  2212.  
  2213. #endif
  2214. @//E*O*F mawk0.97/bi_vars.h//
  2215. chmod u=rw,g=r,o=r mawk0.97/bi_vars.h
  2216.  
  2217. echo x - mawk0.97/cast.c
  2218. sed 's/^@//' > "mawk0.97/cast.c" <<'@//E*O*F mawk0.97/cast.c//'
  2219.  
  2220. /********************************************
  2221. cast.c
  2222. copyright 1991, Michael D. Brennan
  2223.  
  2224. This is a source file for mawk, an implementation of
  2225. the Awk programming language as defined in
  2226. Aho, Kernighan and Weinberger, The AWK Programming Language,
  2227. Addison-Wesley, 1988.
  2228.  
  2229. See the accompaning file, LIMITATIONS, for restrictions
  2230. regarding modification and redistribution of this
  2231. program in source or binary form.
  2232. ********************************************/
  2233.  
  2234.  
  2235. /*   $Log:    cast.c,v $
  2236.  * Revision 2.1  91/04/08  08:22:44  brennan
  2237.  * VERSION 0.97
  2238.  * 
  2239. */
  2240.  
  2241.  
  2242. /*  cast.c  */
  2243.  
  2244. #include "mawk.h"
  2245. #include "field.h"
  2246. #include "memory.h"
  2247. #include "scan.h"
  2248. #include "repl.h"
  2249. #include <string.h>
  2250.  
  2251. int pow2[NUM_CELL_TYPES] = {1,2,4,8,16,32,64,128,256,512} ;
  2252.  
  2253. void cast1_to_d( cp )
  2254.   register CELL *cp ;
  2255. {
  2256.   switch( cp->type )
  2257.   { case C_NOINIT :  cp->dval = 0.0 ; break ;
  2258.  
  2259.     case C_DOUBLE :  return ;
  2260.  
  2261.     case C_MBSTRN :
  2262.     case C_STRING :  
  2263.           { register STRING *s = (STRING *) cp->ptr  ;
  2264.  
  2265. #if FPE_TRAPS  /* look for overflow error */
  2266.             errno = 0 ;
  2267.             cp->dval = strtod(s->str,(char **)0) ;
  2268.             if ( errno && cp->dval != 0.0 ) /* ignore underflow */
  2269.                 rt_error("overflow converting %s to double", s) ;
  2270. #else
  2271.             cp->dval = strtod(s->str,(char **)0) ;
  2272. #endif
  2273.             free_STRING(s) ;
  2274.           }
  2275.             break ;
  2276.  
  2277.     case C_STRNUM :  
  2278.       /* don't need to convert, but do need to free the STRING part */
  2279.             free_STRING( string(cp) ) ;
  2280.             break ;
  2281.  
  2282.  
  2283.     default :
  2284.             bozo("cast on bad type") ;
  2285.   }
  2286.   cp->type = C_DOUBLE ;
  2287. }
  2288.  
  2289. void cast2_to_d( cp )
  2290.   register CELL *cp ;
  2291. { register STRING *s ;
  2292.  
  2293.   switch( cp->type )
  2294.