home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 6 / FreshFish_September1994.bin / bbs / gnu / gawk-2.15.5-src.lha / GNU / src / amiga / gawk-2.15.5 / gawk.info-9 < prev    next >
Encoding:
GNU Info File  |  1994-06-13  |  18.3 KB  |  360 lines
  1. This is Info file gawk.info, produced by Makeinfo-1.55 from the input
  2. file /gnu/src/amiga/gawk-2.15.5/gawk.texi.
  3.  
  4.    This file documents `awk', a program that you can use to select
  5. particular records in a file and perform operations upon them.
  6.  
  7.    This is Edition 0.15 of `The GAWK Manual',
  8. for the 2.15 version of the GNU implementation
  9. of AWK.
  10.  
  11.    Copyright (C) 1989, 1991, 1992, 1993 Free Software Foundation, Inc.
  12.  
  13.    Permission is granted to make and distribute verbatim copies of this
  14. manual provided the copyright notice and this permission notice are
  15. preserved on all copies.
  16.  
  17.    Permission is granted to copy and distribute modified versions of
  18. this manual under the conditions for verbatim copying, provided that
  19. the entire resulting derived work is distributed under the terms of a
  20. permission notice identical to this one.
  21.  
  22.    Permission is granted to copy and distribute translations of this
  23. manual into another language, under the above conditions for modified
  24. versions, except that this permission notice may be stated in a
  25. translation approved by the Foundation.
  26.  
  27. 
  28. File: gawk.info,  Node: Index,  Prev: Glossary,  Up: Top
  29.  
  30. Index
  31. *****
  32.  
  33. * Menu:
  34.  
  35. * $ (field operator):                   Fields.
  36. * -assign option:                       Options.
  37. * -compat option:                       Options.
  38. * -copyleft option:                     Options.
  39. * -copyright option:                    Options.
  40. * -field-separator option:              Options.
  41. * -file option:                         Options.
  42. * -help option:                         Options.
  43. * -lint option:                         Options.
  44. * -posix option:                        Options.
  45. * -source option:                       Options.
  46. * -usage option:                        Options.
  47. * -version option:                      Options.
  48. * AWKPATH environment variable:         AWKPATH Variable.
  49. * awk language:                         This Manual.
  50. * awk program:                          This Manual.
  51. * BEGIN special pattern:                BEGIN/END.
  52. * break statement:                      Break Statement.
  53. * continue statement:                   Continue Statement.
  54. * delete statement:                     Delete.
  55. * END special pattern:                  BEGIN/END.
  56. * exit statement:                       Exit Statement.
  57. * for (x in ...):                       Scanning an Array.
  58. * for statement:                        For Statement.
  59. * if statement:                         If Statement.
  60. * next file statement:                  Next File Statement.
  61. * next statement:                       Next Statement.
  62. * printf statement, syntax of:          Basic Printf.
  63. * printf, format-control characters:    Control Letters.
  64. * printf, modifiers:                    Format Modifiers.
  65. * print statement:                      Print.
  66. * return statement:                     Return Statement.
  67. * while statement:                      While Statement.
  68. * /dev/fd/:                             Special Files.
  69. * /dev/pgrpid:                          Special Files.
  70. * /dev/pid:                             Special Files.
  71. * /dev/ppid:                            Special Files.
  72. * /dev/stderr:                          Special Files.
  73. * /dev/stdin:                           Special Files.
  74. * /dev/stdout:                          Special Files.
  75. * /dev/user:                            Special Files.
  76. * BBS-list file:                        Sample Data Files.
  77. * inventory-shipped file:               Sample Data Files.
  78. * #!:                                   Executable Scripts.
  79. * #:                                    Comments.
  80. * -F option:                            Field Separators.
  81. * -f option:                            Long.
  82. * -v option:                            Options.
  83. * -W option:                            Options.
  84. * print $0:                             Very Simple.
  85. * accessing fields:                     Fields.
  86. * acronym:                              History.
  87. * action, curly braces:                 Actions.
  88. * action, default:                      Very Simple.
  89. * action, definition of:                Actions.
  90. * action, separating statements:        Actions.
  91. * addition:                             Arithmetic Ops.
  92. * and operator:                         Boolean Ops.
  93. * anonymous ftp:                        Extracting.
  94. * anonymous uucp:                       Extracting.
  95. * applications of awk:                  When.
  96. * ARGIND:                               Auto-set.
  97. * arguments in function call:           Function Calls.
  98. * arguments, command line:              Command Line.
  99. * ARGV:                                 Other Arguments.
  100. * arithmetic operators:                 Arithmetic Ops.
  101. * array assignment:                     Assigning Elements.
  102. * array reference:                      Reference to Elements.
  103. * arrays:                               Array Intro.
  104. * arrays, definition of:                Array Intro.
  105. * arrays, deleting an element:          Delete.
  106. * arrays, multi-dimensional subscripts: Multi-dimensional.
  107. * arrays, presence of elements:         Reference to Elements.
  108. * arrays, special for statement:        Scanning an Array.
  109. * assignment operators:                 Assignment Ops.
  110. * assignment to fields:                 Changing Fields.
  111. * associative arrays:                   Array Intro.
  112. * backslash continuation:               Statements/Lines.
  113. * basic function of gawk:               Getting Started.
  114. * body of a loop:                       While Statement.
  115. * boolean expressions:                  Boolean Ops.
  116. * boolean operators:                    Boolean Ops.
  117. * boolean patterns:                     Boolean Patterns.
  118. * buffering output:                     I/O Functions.
  119. * buffers, flushing:                    I/O Functions.
  120. * built-in functions:                   Built-in.
  121. * built-in variables:                   Built-in Variables.
  122. * built-in variables, user modifiable:  User-modified.
  123. * call by reference:                    Function Caveats.
  124. * call by value:                        Function Caveats.
  125. * calling a function:                   Function Calls.
  126. * case sensitivity:                     Read Terminal.
  127. * changing contents of a field:         Changing Fields.
  128. * close:                                Close Input.
  129. * close:                                Close Output.
  130. * closing input files and pipes:        Close Input.
  131. * closing output files and pipes:       Close Output.
  132. * command line:                         Command Line.
  133. * command line formats:                 Running gawk.
  134. * command line, setting FS on:          Field Separators.
  135. * comments:                             Comments.
  136. * comparison expressions:               Comparison Ops.
  137. * comparison expressions as patterns:   Comparison Patterns.
  138. * computed regular expressions:         Regexp Usage.
  139. * concatenation:                        Concatenation.
  140. * conditional expression:               Conditional Exp.
  141. * constants, types of:                  Constants.
  142. * continuation of lines:                Statements/Lines.
  143. * control statement:                    Statements.
  144. * conversion of strings and numbers:    Conversion.
  145. * conversion of strings and numbers:    Values.
  146. * conversions, during subscripting:     Numeric Array Subscripts.
  147. * CONVFMT:                              Numeric Array Subscripts.
  148. * CONVFMT:                              Comparison Ops.
  149. * CONVFMT:                              Conversion.
  150. * curly braces:                         Actions.
  151. * default action:                       Very Simple.
  152. * default pattern:                      Very Simple.
  153. * defining functions:                   Definition Syntax.
  154. * deleting elements of arrays:          Delete.
  155. * deprecated features:                  Obsolete.
  156. * deprecated options:                   Obsolete.
  157. * differences: gawk and awk:            Getline.
  158. * directory search:                     AWKPATH Variable.
  159. * division:                             Arithmetic Ops.
  160. * documenting awk programs:             Comments.
  161. * dynamic regular expressions:          Regexp Usage.
  162. * element assignment:                   Assigning Elements.
  163. * element of array:                     Reference to Elements.
  164. * empty pattern:                        Empty.
  165. * ENVIRON:                              Auto-set.
  166. * ERRNO:                                Getline.
  167. * escape sequence notation:             Constants.
  168. * examining fields:                     Fields.
  169. * executable scripts:                   Executable Scripts.
  170. * explicit input:                       Getline.
  171. * exponentiation:                       Arithmetic Ops.
  172. * expression:                           Expressions.
  173. * expression, conditional:              Conditional Exp.
  174. * expressions, assignment:              Assignment Ops.
  175. * expressions, boolean:                 Boolean Ops.
  176. * expressions, comparison:              Comparison Ops.
  177. * field separator, FS:                  Field Separators.
  178. * field separator, choice of:           Field Separators.
  179. * field separator: on command line:     Field Separators.
  180. * field, changing contents of:          Changing Fields.
  181. * fields:                               Fields.
  182. * fields, separating:                   Field Separators.
  183. * file descriptors:                     Special Files.
  184. * file, awk program:                    Long.
  185. * FILENAME:                             Reading Files.
  186. * flushing buffers:                     I/O Functions.
  187. * FNR:                                  Records.
  188. * format specifier:                     Control Letters.
  189. * format string:                        Basic Printf.
  190. * formatted output:                     Printf.
  191. * FS:                                   Field Separators.
  192. * ftp, anonymous:                       Extracting.
  193. * function call:                        Function Calls.
  194. * function definition:                  Definition Syntax.
  195. * functions, user-defined:              User-defined.
  196. * getline:                              Getline.
  197. * getting gawk:                         Extracting.
  198. * gsub:                                 String Functions.
  199. * history of awk:                       History.
  200. * how awk works:                        Two Rules.
  201. * increment operators:                  Increment Ops.
  202. * input:                                Reading Files.
  203. * input file, sample:                   Sample Data Files.
  204. * input redirection:                    Getline.
  205. * input, getline command:               Getline.
  206. * input, explicit:                      Getline.
  207. * input, multiple line records:         Multiple Line.
  208. * input, standard:                      Read Terminal.
  209. * installation, atari:                  Atari Installation.
  210. * installation, ms-dos:                 MS-DOS Installation.
  211. * installation, unix:                   Quick Installation.
  212. * installation, vms:                    VMS Installation.
  213. * interaction, awk and other programs:  I/O Functions.
  214. * invocation of gawk:                   Command Line.
  215. * language, awk:                        This Manual.
  216. * length:                               String Functions.
  217. * logical operations:                   Boolean Ops.
  218. * long options:                         Command Line.
  219. * loop:                                 While Statement.
  220. * loops, exiting:                       Break Statement.
  221. * lvalue:                               Assignment Ops.
  222. * manual, using this:                   This Manual.
  223. * match:                                String Functions.
  224. * match:                                String Functions.
  225. * metacharacters:                       Regexp Operators.
  226. * modifiers (in format specifiers):     Format Modifiers.
  227. * multi-dimensional subscripts:         Multi-dimensional.
  228. * multiple line records:                Multiple Line.
  229. * multiple passes over data:            Other Arguments.
  230. * multiple statements on one line:      Statements/Lines.
  231. * multiplication:                       Arithmetic Ops.
  232. * NF:                                   Fields.
  233. * not operator:                         Boolean Ops.
  234. * NR:                                   Records.
  235. * number of fields, NF:                 Fields.
  236. * number of records, NR or FNR:         Records.
  237. * numbers, used as subscripts:          Numeric Array Subscripts.
  238. * numeric constant:                     Constants.
  239. * numeric value:                        Constants.
  240. * obsolete features:                    Obsolete.
  241. * obsolete options:                     Obsolete.
  242. * OFMT:                                 Conversion.
  243. * OFMT:                                 OFMT.
  244. * OFS:                                  Output Separators.
  245. * one-liners:                           One-liners.
  246. * operator precedence:                  Precedence.
  247. * operators, $:                         Fields.
  248. * operators, arithmetic:                Arithmetic Ops.
  249. * operators, assignment:                Assignment Ops.
  250. * operators, boolean:                   Boolean Ops.
  251. * operators, increment:                 Increment Ops.
  252. * operators, regexp matching:           Regexp Usage.
  253. * operators, relational:                Comparison Patterns.
  254. * operators, relational:                Comparison Ops.
  255. * operators, string:                    Concatenation.
  256. * operators, string-matching:           Regexp Usage.
  257. * options, command line:                Command Line.
  258. * options, long:                        Command Line.
  259. * or operator:                          Boolean Ops.
  260. * ORS:                                  Output Separators.
  261. * output:                               Printing.
  262. * output field separator, OFS:          Output Separators.
  263. * output record separator, ORS:         Output Separators.
  264. * output redirection:                   Redirection.
  265. * output, buffering:                    I/O Functions.
  266. * output, formatted:                    Printf.
  267. * output, piping:                       File/Pipe Redirection.
  268. * passes, multiple:                     Other Arguments.
  269. * path, search:                         AWKPATH Variable.
  270. * pattern, case sensitive:              Read Terminal.
  271. * pattern, comparison expressions:      Comparison Patterns.
  272. * pattern, default:                     Very Simple.
  273. * pattern, definition of:               Patterns.
  274. * pattern, empty:                       Empty.
  275. * pattern, regular expressions:         Regexp.
  276. * patterns, BEGIN:                      BEGIN/END.
  277. * patterns, END:                        BEGIN/END.
  278. * patterns, boolean:                    Boolean Patterns.
  279. * patterns, range:                      Ranges.
  280. * patterns, types of:                   Kinds of Patterns.
  281. * pipes for output:                     File/Pipe Redirection.
  282. * precedence:                           Precedence.
  283. * printing:                             Printing.
  284. * program file:                         Long.
  285. * program, awk:                         This Manual.
  286. * program, definition of:               Getting Started.
  287. * program, self contained:              Executable Scripts.
  288. * programs, documenting:                Comments.
  289. * quotient:                             Arithmetic Ops.
  290. * range pattern:                        Ranges.
  291. * reading files:                        Reading Files.
  292. * reading files, getline command:       Getline.
  293. * reading files, multiple line records: Multiple Line.
  294. * record separator:                     Records.
  295. * records, multiple line:               Multiple Line.
  296. * redirection of input:                 Getline.
  297. * redirection of output:                Redirection.
  298. * reference to array:                   Reference to Elements.
  299. * regexp:                               Regexp.
  300. * regexp as expression:                 Comparison Ops.
  301. * regexp operators:                     Comparison Ops.
  302. * regexp search operators:              Regexp Usage.
  303. * regular expression matching operators: Regexp Usage.
  304. * regular expression metacharacters:    Regexp Operators.
  305. * regular expressions as field separators: Field Separators.
  306. * regular expressions as patterns:      Regexp.
  307. * regular expressions, computed:        Regexp Usage.
  308. * relational operators:                 Comparison Ops.
  309. * relational operators:                 Comparison Patterns.
  310. * remainder:                            Arithmetic Ops.
  311. * removing elements of arrays:          Delete.
  312. * RLENGTH:                              String Functions.
  313. * RS:                                   Records.
  314. * RSTART:                               String Functions.
  315. * rule, definition of:                  Getting Started.
  316. * running awk programs:                 Running gawk.
  317. * running long programs:                Long.
  318. * sample input file:                    Sample Data Files.
  319. * scanning an array:                    Scanning an Array.
  320. * script, definition of:                Getting Started.
  321. * scripts, executable:                  Executable Scripts.
  322. * scripts, shell:                       Executable Scripts.
  323. * search path:                          AWKPATH Variable.
  324. * self contained programs:              Executable Scripts.
  325. * shell scripts:                        Executable Scripts.
  326. * side effect:                          Assignment Ops.
  327. * single quotes, why needed:            One-shot.
  328. * split:                                String Functions.
  329. * sprintf:                              String Functions.
  330. * standard error output:                Special Files.
  331. * standard input:                       Read Terminal.
  332. * standard input:                       Reading Files.
  333. * standard input:                       Special Files.
  334. * standard output:                      Special Files.
  335. * strftime:                             Time Functions.
  336. * string constants:                     Constants.
  337. * string operators:                     Concatenation.
  338. * string-matching operators:            Regexp Usage.
  339. * sub:                                  String Functions.
  340. * subscripts in arrays:                 Multi-dimensional.
  341. * SUBSEP:                               Multi-dimensional.
  342. * substr:                               String Functions.
  343. * subtraction:                          Arithmetic Ops.
  344. * system:                               I/O Functions.
  345. * systime:                              Time Functions.
  346. * time of day:                          Time Functions.
  347. * time stamps:                          Time Functions.
  348. * tolower:                              String Functions.
  349. * toupper:                              String Functions.
  350. * use of comments:                      Comments.
  351. * user-defined functions:               User-defined.
  352. * user-defined variables:               Variables.
  353. * uses of awk:                          Preface.
  354. * using this manual:                    This Manual.
  355. * uucp, anonymous:                      Extracting.
  356. * variables, user-defined:              Variables.
  357. * when to use awk:                      When.
  358.  
  359.  
  360.