:Info: io_call: io: 04/02/85 io_call, io Syntax as a command: io operation switchname {args} Syntax as an active function: [io operation switchname {args}] Function: performs diverse operations on specified I/O switches and returns a result. Arguments: operation designates the operation to be performed. See "List of operations" below. For a detailed description of each operation, type "help io_call.OPERATION", where OPERATION is the name of the specific operation. switchname is the name of the I/O switch through which the operation is performed. (In the next two sections SW means switchname.) args can be one or more arguments, depending on the particular operation to be performed. List of operations: attach SW attach_description uses attach_description to attach SW. attach_desc SW prints the attach description for SW. attached SW prints true if SW is attached. close SW closes SW. close_file SW {args} closes SW. closed SW prints true if SW is closed. control SW order {args} performs the named order operation on SW; args depend upon the particular order and I/O module through with SW is attached. delete_record SW, delete SW deletes the current record in the file to which SW is attached. destroy_iocb SW destroys SW. detach SW {args} detaches SW. detach_iocb SW detachs SW. detached SW prints true if SW is detached. find_iocb SW prints the location of SW. Switch is created if not already existing. get_chars SW {N} {-control_args} reads and prints the next N characters from SW; control_args can be: -segment, -allow_newline, -append_newline, -remove_newline, -lines. get_line SW {N} {-control_args} reads and prints the next line from SW; control_args can be: -segment, -allow_newline, -append_newline, -remove_newline, -lines. io_module SW prints the name of the I/O module through which SW is attached. look_iocb SW prints the location of SW. An error occurs if SW does not exist. modes SW {STR} {-brief} prints the old modes associates with SW and sets the new modes given in STR. move_attach SW SW2 moves the attachment from SW to SW2. SW is left in detached state. open SW mode opens SW with given mode. open_desc SW prints the current opening mode for SW. open_file SW mode {args} opens SW with given mode. opened SW prints true if SW is opened. position SW type positions the file to which SW is attached; type can be: bof; eof; forward J, fwd J, f J; reverse J, rev J, r J; I {J} (I and J are integers). print_iocb SW prints all data from the control block for SW. put_chars SW {STR} {-control_args} outputs STR to SW; control_args can be: -segment, -allow_newline, -append_newline, -remove_newline, -lines. If you omit STR, give -segment. read_key SW reads and prints key and record length of the next record in the indexed file to which SW is attached. read_length SW reads and prints the length of the next record in the structured file to which SW is attached. read_record SW {N} {-control_args}, read SW {N} {-control_args} reads and prints the next record from SW; control_args can be: -segment, -allow_newline, -append_newline, -remove_newline, -lines. rewrite_record SW {STR} {-control_args}, rewrite SW {STR} {-control_args} replaces with STR current record in file to which SW is attached; control_args can be: -segment, -allow_newline, -append_newline, -remove_newline, -lines. If you omit STR, give -segment. seek_key SW key positions the indexed file to which SW is attached to the record with the given key. If the record is not found, key becomes key for insertion of the new record. test_mode SW mode prints true if mode appears in modes string of SW; prints false if ^mode appears. Prints error if mode does not appear or is not an on/off mode. valid_mode SW mode prints true if mode or ^mode appears in modes string of SW; prints false if either does not appear. valid_op SW operation prints true if operation is valid for SW, given its current attachment and opening mode. write_record SW {STR} {-control_args}, write SW {STR} {-control_args} writes STR to SW; control_args can be: -segment, -allow_newline, -append_newline, -remove_newline, -lines. If you omit STR, give -segment. List of active function operations: [attach_desc SW {-no_quote}] returns the attach description for SW as a quoted string. [attached SW] returns true if SW is attached. [closed SW] returns true if SW is closed. [control SW order {args}] performs the named order operation on SW and returns the result. Result and args depend upon the particular order given and the I/O module in use. [detached SW] returns true if SW is detached. [find_iocb SW] returns the location of the control block for the I/O switch. [get_chars SW {N} {-control_args}] returns the data read as a quoted string; control_args can be: -no_quote, -allow_newline, -append_newline, -remove_newline. [get_line SW {N} {-control_args}] returns the data read as a quoted string; control_args can be: -no_quote, -allow_newline, -append_newline, -remove_newline. [io_module SW] returns the name of I/O module through which SW is attached. [look_iocb SW] returns true if SW exists. [modes SW new_modes] returns old modes, optionally sets new modes. [open_desc SW {-no_quote}] returns the current opening mode for SW. [opened SW] returns true if SW is opened. [position SW type] returns true if the indicated position operation succeeds. The type argument can be: bof; eof; forward J, fwd J, f J; reverse J, rev J, r J; I {J} (I and J are integers). [read_key SW {-no_quote}] returns the key of next record as a quoted string. [read_length SW] returns the length of next record in a structured file. [read_record SW {N} {-control_args}], [read SW {N} {-control_args}] returns the data read as a quoted string; control_args can be: -no_quote, -allow_newline, -append_newline, -remove_newline. [seek_key SW key] returns true if key exists. [test_mode SW mode] returns true if mode appears in modes string of SW; returns false if ^mode appears. An error occurs if mode does not appear or is not an on/off mode. [valid_mode SW mode] returns true if mode or ^mode appears in modes string of SW; returns false if either does not appear. [valid_op SW operation] returns true if operation is valid for SW, given its current attachment and opening mode. :Info: io_call.attach: io.attach: 04/02/85 io_call attach operation Syntax as a command: io attach switchname attach_description Function: attaches the I/O switch using the designated I/O module. If a control block for the I/O switch does not already exist, one is created. Arguments: attach_description is the concatenation of modulename and args separated by blanks. It must conform to the requirements of the I/O module. If the I/O modulename is specified by a pathname, it is initiated with a reference name equal to the entryname. If the entryname or reference name does not contain a dollar sign, the attachment is made by calling modulename$modulenameattach. If you supply a $, the entry point specified is called. (See "Entry Point Names" in the Programmer's Reference Manual.) :Info: io_call.attach_desc: io.attach_desc: 04/02/85 io_call attach_desc operation Syntax as a command: io attach_desc switchname Syntax as an active function: [io attach_desc switchname {-control_arg}] Function: prints or returns the attach description of the switch, quoted unless you give -no_quote. Control arguments: -no_quote, -nq does not enclose the returned data in quotes. :Info: io_call.attached: io.attached: 05/02/85 io_call attached operation Syntax as a command: io attached switchname Syntax as an active function: [io attached switchname] Function: prints or returns true if the switch is attached, false otherwise. :Info: io_call.close: io.close: 04/02/85 io_call close operation Syntax as a command: io close switchname Function: closes the I/O switch. :Info: io_call.close_file: io.close_file: 04/02/85 io_call close_file operation Syntax as a command: io close_file switchname {args} Function: closes the I/O switch with the specified description. The close_file description is the concatenation of all args separated by blanks. It must conform to the requirements of the I/O module. Arguments: args can be one or more arguments, depending on what is permitted by the particular I/O module. :Info: io_call.closed: io.closed: 04/02/85 io_call closed operation Syntax as a command: io closed switchname Syntax as an active function: [io closed switchname] Function: prints or returns true if the switch is closed, false otherwise. :Info: io_call.control: io.control: 04/02/85 io_call control operation Syntax as a command: io control switchname order {args} Syntax as an active function: [io control switchname order {args}] Function: applies only when the I/O switch is attached via an I/O module that supports the control I/O operation. The exact format of the command line depends on the order being issued and the I/O module being used. For more details see "Control Operations from Command Level" in the appropriate I/O module. If the I/O module supports the control operation and the paragraph just referenced does not appear, assume that only control orders that do not require an info_structure can be performed with the io_call command. This is true because this command/active function uses a null info_ptr. (See the iox_$control entry point in the Subroutines manual and "Performing Control Operations from Command Level" and the I/O module description in the Programmer's Reference Manual.) The active function returns a value that depends on the I/O module and the order specified. Arguments: order is one of the orders accepted by the I/O module used in the attachment of the I/O switch. args are additional arguments dependent upon the order being issued and the I/O module being used. :Info: io_call.delete_record: io.delete_record: io_call.delete: io.delete: 04/02/85 io_call delete_record operation Syntax as a command: io delete switchname Function: deletes the current record in the file to which the I/O switch is attached. The current record is determined as in rewrite_record. :Info: io_call.destroy_iocb: io.destroy_iocb: 04/02/85 io_call destroy_iocb operation Syntax as a command: io destroy_iocb switchname Function: destroys the I/O switch by deleting its control block. Be sure the switch is detached before using this command. Any pointers to the I/O switch become invalid. :Info: io_call.detach: io.detach: 04/02/85 io_call detach operation Syntax as a command: io detach switchname {args} Function: detaches the I/O switch with the specified description. The detach description is the concatenation of all args separated by blanks. It must conform to the requirements of the I/O module. Arguments: args can be one or more arguments, depending on what is permitted by the particular I/O module. Notes: If there are no arguments after switchname, this request is synonymous with the detach_iocb request. This means that if you supply no detach description on the command line, detach acts essentially as a short name for detach_iocb. :Info: io_call.detach_iocb: io.detach_iocb: 04/02/85 io_call detach_iocb operation Syntax as a command: io detach_iocb switchname Function: detaches the I/O switch. :Info: io_call.detached: io.detached: 04/04/85 io_call detached operation Syntax as a command: io detached switchname Syntax as an active function: [io detached switchname] Function: prints or returns true if the switch is detached, false otherwise. :Info: io_call.find_iocb: io.find_iocb: 04/02/85 io_call find_iocb operation Syntax as a command: io find_iocb switchname Syntax as an active function: [io find_iocb switchname] Function: prints or returns the location of the control block for the I/O switch. If it does not already exist, the control block is created. :Info: io_call.get_chars: io.get_chars: 08/06/86 io_call get_chars operation Syntax as a command: io get_chars switchname {N} {-control_args} Syntax as an active function: [io get_chars switchname {N} {-control_args}] Function: reads the next N characters from the file or device to which the I/O switch is attached. Arguments: N is a decimal number greater than zero specifying the number of characters to read. Control arguments: -allow_newline, -alnl does not add to nor delete from the end of the line any newline character. (Default, when you select -segment) -append_newline, -apnl adds a newline character to the end of the line if one is not present. (Default, when you choose no -segment) -lines specifies that the offset, if given, is measured in lines rather than in characters. This control argument has meaning only if you also supply -segment; you can't use it with the active function. -no_quote, -nq returns the data unquoted. (Default for active function only) -remove_newline, -rmnl deletes the newline character, if present, from the end of the line. (Default for active function) -segment path {offset}, -sm path {offset} specifies that the data read from the I/O switch is to be stored in the segment given by path. You can optionally describe the location at which to begin writing in path with the offset parameter. This is normally specified as a character offset (i.e., the number of characters to skip over before storing the new data in the segment). For example, an offset of 0 causes the new data to overwrite the entire file. When you also give -lines, then offset is a line offset (i.e., the number of lines to skip over before storing the new data in the segment). For example, an offset of 1 line begins storing data at the second line of the file. If you omit offset, new data is appended to the end of the segment. You can't use this control argument with the active function. Notes: The disposition of the characters read is the same as the one described under the get_line operation; that is, they are written upon user_output if you specify no -segment or stored in a segment if you give -segment. As an active function, returns the data read as a quoted string, unless you use -no_quote. A trailing newline character is deleted. If you don't supply the maximum number of characters N, the maximum segment size is assumed. :Info: io_call.get_line: io.get_line: 08/06/86 io_call get_line operation Syntax as a command: io get_line switchname {N} {-control_args} Syntax as an active function: [io get_line switchname {N} {-control_args}] Function: reads the next line from the file or device to which the I/O switch is attached. If you give N and the line is longer than N, then only the first N characters are read. The active function returns the data read as a quoted string, unless you supply -no_quote. A trailing newline character is deleted. If you don't supply the maximum number of characters N, the maximum segment size is assumed. Arguments: N is a decimal number greater than zero specifying the maximum number of characters to be read. Control arguments: -allow_newline, -alnl does not add to nor delete from the end of the line any newline character. (Default, when you select -segment) -append_newline, -apnl adds a newline character to the end of the line if one is not present. (Default, when you choose no -segment) -lines specifies that the offset, if given, is measured in lines rather than in characters. This control argument has meaning only if you also supply -segment; you can't use it with the active function. -no_quote, -nq returns the data unquoted. (Default for active function only) -remove_newline, -rmnl deletes the newline character, if present, from the end of the line. (Default for active function) -segment path {offset}, -sm path {offset} specifies that the data read from the I/O switch is to be stored in the segment given by path. You can optionally describe the location at which to begin writing in path with the offset parameter. This is normally specified as a character offset (i.e., the number of characters to skip over before storing the new data in the segment). For example, an offset of 0 causes the new data to overwrite the entire file. When you also give -lines, then offset is a line offset (i.e., the number of lines to skip over before storing the new data in the segment). For example, an offset of 1 line begins storing data at the second line of the file. If you omit offset, new data is appended to the end of the segment. You can't use this control argument with the active function. Notes: If you select no -segment, the line read is written onto the I/O switch user_output, with a newline character appended if one is not present and if you have supplied neither allow_newline nor -remove_newline. If you give -segment, the line is stored in the segment specified by path; if this segment does not exist, it is created. If you use offset, the line is stored at that position relative to the start of the segment; this is normally measured in characters, unless you have selected -lines. If you omit offset, the line is appended to the end of the segment. The bit count of the segment is always updated to a point beyond the newly added data. If the segment contains a trailing newline and you haven't chosen -remove_newline, that newline remains; if the segment does not contain a trailing newline and you haven't specified -append_newline, no newline is appended. :Info: io_call.io_module: io.io_module: 04/02/85 io_call io_module operation Syntax as a command: io io_module switchname Syntax as an active function: [io io_module switchname] Function: prints or returns the name of the I/O module through which the switch is attached. :Info: io_call.look_iocb: io.look_iocb: 04/02/85 io_call look_iocb operation Syntax as a command: io look_iocb switchname Syntax as an active function: [io look_iocb switchname] Function: prints, on user_output, the location of the control block for the I/O switch; if this switch does not exist, an error is printed. The active function returns true if the specified iocb exists, false otherwise. :Info: io_call.modes: io.modes: 04/02/85 io_call modes operation Syntax as a command: io modes switchname {string} {-control_arg} Syntax as an active function: [io modes switchname {string}] Function: sets only new modes specified in string and then prints the old modes on user_output; applies only when the I/O switch is attached via an I/O module that supports modes. The active function performs the specified modes operation and returns the old modes. Arguments: string is a sequence of modes separated by commas. The string must not contain blanks. See the description of the I/O module attached to the switch for a list of acceptable modes. Control arguments: -brief, -bf suppresses printing of the old modes. Notes: If the switch name is user_i/o, the command refers to the modes controlling your terminal. :Info: io_call.move_attach: io.move_attach: 04/02/85 io_call move_attach operation Syntax as a command: io move_attach switchname switchname2 Function: moves the attachment of the first I/O switch (switchname) to the second I/O switch (switchname2). The original I/O switch is left detached. Arguments: switchname2 is the name of a second I/O switch. :Info: io_call.open: io.open: 04/02/85 io_call open operation Syntax as a command: io open switchname mode Function: opens the I/O switch with the specified opening mode. List of modes: The following opening modes are accepted: direct_input, di direct_output, do direct_update, du keyed_sequential_input, ksqi keyed_sequential_output, ksqo keyed_sequential_update, ksqu sequential_input, sqi sequential_output, sqo sequential_input_output, sqio sequential_update, squ stream_input, si stream_output, so stream_input_output, sio :Info: io_call.open_desc: io.open_desc: 04/02/85 io_call open_desc operation Syntax as a command: io open_desc switchname Syntax as an active function: [io open_desc switchname {-no_quote}] Function: prints or returns the current open description (stream_input, etc.), quoted. :Info: io_call.open_file: io.open_file: 04/02/85 io_call open_file operation Syntax as a command: io open_file switchname mode {args} Function: open the I/O switch with the specified opening mode and description. The open_file description is the concatenation of all args separated by blanks. It must conform to the requirements of the I/O module. Arguments: args can be one or more arguments, depending on what is permitted by the particular I/O module. List of modes: The following opening modes are accepted: direct_input, di direct_output, do direct_update, du keyed_sequential_input, ksqi keyed_sequential_output, ksqo keyed_sequential_update, ksqu sequential_input, sqi sequential_output, sqo sequential_input_output, sqio sequential_update, squ stream_input, si stream_output, so stream_input_output, sio :Info: io_call.opened: io.opened: 04/02/85 io_call opened operation Syntax as a command: io opened switchname Syntax as an active function: [io opened switchname] Function: prints or returns true if the switch is open, false otherwise. :Info: io_call.position: io.position: 04/02/85 io_call position operation Syntax as a command: io position switchname type Syntax as an active function: [io position switchname type] Function: positions the file to which the I/O switch is attached. List of types: bof sets position to beginning of file. eof sets position to end of file. forward N, fwd N, f N sets position forward N records or lines (same as reverse -N). reverse N, rev N, r N sets position back N records (same as forward -N records). Any other numeric argument or pair of numeric arguments can be specified, but its function depends on the I/O module being used and cannot be implemented for all I/O modules. Notes: If type is bof, the file is positioned to its beginning, so that the next record is the first record (structured files) or the next byte is the first byte (unstructured files). If type is eof, the file is positioned to its end; the next record (or next byte) is at the end-of-file position. If type is forward or reverse, the file is positioned forwards or backwards over records (structured files) or lines (unstructured files). The number of records or lines skipped is determined by the absolute value of N. The active function returns true if it succeed, false otherwise. In the case of unstructured files, the next-byte position after the operation is at a byte immediately following a newline character (or at the first byte in the file or at the end of the file). The number of newline characters moved over is the absolute value of N. If the I/O switch is attached to a device, you are only allowed forward skips; this discards the next N lines input from the device. :Info: io_call.print_iocb: io.print_iocb: 04/02/85 io_call print_iocb operation Syntax as a command: io print_iocb switchname Function: prints, on user_output, all the data in the control block for the I/O switch, including all pointers and entry variables. :Info: io_call.put_chars: io.put_chars: 08/06/86 io_call put_chars operation Syntax as a command: io put_chars switchname {string} {-control_args} Function: outputs a character string or an entire segment to a specified I/O switch. Arguments: string can be any character string. Control arguments: -allow_newline, -alnl does not add to nor delete from the end of the line any newline character. -append_newline, -apnl adds a newline character to the end of the line if one is not present. (Default) -lines specifies that the offset and length operands of -segment are measured in lines rather than in characters. This control argument has meaning only if you also supply -segment. -remove_newline, -rmnl does not append a newline character to the end of the output string or segment even if one is not present at the end. -segment path {{offset} length}, -sm path {{offset} length} specifies that the data for the output operation is to be found in the segment specified by path. You can optionally describe the location and length of the data with offset and length parameters. These are normally specified as a character offset (i.e., 0 identifies the first character of the segment) and character length. When you also give -lines, they are specified as a line offset and line count. If you give no offset, 0 is assumed. If you give no length and offset, the entire segment is used. -string STR, -str STR specifies an output string that can have a leading hyphen. Notes: The string argument and -segment are mutually exclusive. If you supply a string, the contents of the string are output to the I/O switch. If you supply -segment, the data is taken from the segment specified by path, at the offset and length given. If the I/O switch is attached to a device, io_call transmits the characters from the string or the segment to the device. If the I/O switch is attached to an unstructured file, the data is added to the end of the file. :Info: io_call.read_key: io.read_key: 04/02/85 io_call read_key operation Syntax as a command: io read_key switchname Syntax as an active function: [io read_key switchname {-control_arg}] Function: prints, on user_output, the key and record length of the next record in the indexed file to which the I/O switch is attached. The file's position is not changed. The active function returns the value of the key, quoted unless you select -no_quote. Control arguments: -no_quote, -nq does not enclose the returned data in quotes. Data containing spaces is quoted by default. :Info: io_call.read_length: io.read_length: 04/02/85 io_call read_length operation Syntax as a command: io read_length switchname Syntax as an active function: [io read_length switchname] Function: prints, on user_output, the length of the next record in the structured file to which the I/O switch is attached. The file's position is not changed. The active function returns the length of the next record, in bytes. :Info: io_call.read_record: io.read_record: io_call.read: io.read: 08/06/86 io_call read_record operation Syntax as a command: io read switchname {N} {-control_args} Syntax as an active function: [io read switchname {N} {-control_args}] Function: reads the next record from the file to which the I/O switch is attached into a buffer of length N. Arguments: N is a decimal integer greater than zero specifying the size of the buffer to use. Control arguments: -allow_newline, -alnl does not add to nor delete from the end of the line any character. (Default for command) -append_newline, -apnl adds a newline character to the end of the line if one is not present. -lines specifies that the offset, if given, is measured in lines rather than in characters. This control argument has meaning only if you also supply -segment; you can't use it with the active function. -no_quote, -nq returns the data unquoted. Active function usage only. -remove_newline deletes the newline character, if present, from the end of the line. (Default for active function) -segment path {offset}, -sm path {offset} specifies that the data read from the I/O switch is to be stored in the segment given by path. You can optionally describe the location at which to begin writing in path with the offset parameter. This is normally specified as a character offset (i.e., the number of characters to skip over before storing the new data in the segment). For example, an offset of 0 causes the new data to overwrite the entire file. When you also give -lines, then offset is a line offset (i.e., the number of lines to skip over before storing the new data in the segment). For example, an offset of 1 line begins storing data at the second line of the file. If you omit offset, new data is appended to the end of the segment. You can't use this control argument with the active function. Notes: If you don't supply -segment, the record (or the part of it that fits into the buffer) is printed on user_output. If you give -segment, the record is stored in a segment as explained under the get_chars operation. The active function returns the data read as a quoted string, unless you select -no_quote. A trailing newline character is deleted. If you don't give the maximum number of characters N, the maximum segment size is assumed. :Info: io_call.rewrite_record: io.rewrite_record: io_call.rewrite: io.rewrite: 08/06/86 io_call rewrite_record operation Syntax as a command: io rewrite switchname {string} {-control_args} Function: replaces the current record in the file to which the I/O switch is attached. Arguments: string is any character string. Control arguments: -allow_newline, -alnl does not add to nor delete from the end of the line any newline character. (Default, when you select -segment) -append_newline, -apnl adds a newline character to the end of the line if one is not present. -lines specifies that the offset and length operands of -segment are measured in lines rather than in characters. This control argument has meaning only if you also supply -segment. -no_quote, -nq returns the data unquoted. Active function usage only. -remove_newline, -rmnl deletes the newline character, if present, from the end of the line. (Default if you give no -segment) -segment path {{offset} length}, -sm path {{offset} length} specifies that the data for the output operation is to be found in the segment specified by path. You can optionally describe the location and length of the data with offset and length parameters. These are normally specified as a character offset (i.e., 0 identifies the first character of the segment) and character length. When you also give -lines, they are specified as a line offset and line count. If you give no offset, 0 is assumed. If you give no length and offset, the entire segment is used. -string STR, -str STR specifies an output string that can have a leading hyphen. Notes: The string argument and -segment are mutually exclusive. If you supply a string, the contents of the string are output to the I/O switch. If you supply -segment, the data is taken from the segment specified by path, at the offset and length given. The current record must have been defined by a preceding read_record, seek_key, or position operation as follows: read_record the current record is the last record read. seek_key the current record is the record with the specified key. position the current record is the one preceding the record to which the file was positioned. :Info: io_call.seek_key: io.seek_key: 04/02/85 io_call seek_key operation Syntax as a command: io seek_key switchname key Syntax as an active function: [io seek_key switchname key] Function: positions the indexed file to which the I/O switch is attached to the record with the given key. The record's length is printed on user_output. Trailing blanks in the key are ignored. The active function returns true if the key exists, false otherwise. Arguments: key is a string of no more than 256 ASCII characters. The null string ("") is allowed as a key. Notes: If the file does not contain a record with the specified key, it becomes the key for insertion. A following write_record operation adds a record with this key. :Info: io_call.test_mode: io.test_mode: 04/02/85 io_call test_mode operation Syntax as a command: io test_mode switchname mode Syntax as an active function: [io test_mode switchname mode] Function: performs a modes operation and prints or returns true if mode appears in the mode string, false if ^mode appears. :Info: io_call.valid_mode: io.valid_mode: 04/02/85 io_call valid_mode operation Syntax as a command: io valid_mode switchname mode Syntax as an active function: [io valid_mode switchname mode] Function: performs a modes operation and prints or returns true if either mode or ^mode appears in the mode string, false otherwise. :Info: io_call.valid_op: io.valid_op: 04/02/85 io_call valid_op operation Syntax as a command: io valid_op switchname operation Syntax as an active function: [io valid_op switchname operation] Function: prints or returns true if the operation is defined on the switch. List of operations: The following operations are allowed: close control delete_record destroy_iocb detach_iocb find_iocb get_chars get_line look_iocb modes move_attach open position put_chars read_key read_length read_record rewrite_record seek_key write_record :Info: io_call.write_record: io.write_record: io_call.write: io.write: 08/06/86 io_call write_record operation Syntax as a command: io write switchname {string} {-control_args} Function: adds a record to the file to which the I/O switch is attached. If the string parameter is specified, the record is equal to the string. If the -segment control argument is specified, the record is extracted from the segment as described under the put_chars operation. If the file is a sequential file, the record is added at the end of the file. If the file is an indexed file, the record's key must have been defined by a preceding seek_key operation. Arguments: string is any character string. Control arguments: -allow_newline, -alnl does not add to nor delete from the end of the line any newline character. (Default, when you select -segment) -append_newline, -apnl adds a newline character to the end of the line if one is not present. -lines specifies that the offset and length operands of -segment are measured in lines rather than in characters. This control argument has meaning only if you also supply -segment. -no_quote, -nq returns the data unquoted. (Active function usage only) -remove_newline, -rmnl deletes the newline character, if present, from the end of the line. (Default if you give no -segment) -segment path {{offset} length}, -sm path {{offset} length} specifies that the data for the output operation is to be found in the segment specified by path. You can optionally describe the location and length of the data with offset and length parameters. These are normally specified as a character offset (i.e., 0 identifies the first character of the segment) and character length. When you also give -lines, they are specified as a line offset and line count. If you give no offset, 0 is assumed. If you give no length and offset, the entire segment is used. -string STR, -str STR specifies an output string that can have a leading hyphen. Notes: The string argument and -segment are mutually exclusive. If you supply a string, the contents of the string are output to the I/O switch. If you supply -segment, the data is taken from the segment specified by path, at the offset and length given. If the file is sequential, the record is added at the end of the file. If the file is indexed, the record's key must have been defined by a preceding seek_key operation. ----------------------------------------------------------- Historical Background This edition of the Multics software materials and documentation is provided and donated to Massachusetts Institute of Technology by Group BULL including BULL HN Information Systems Inc. as a contribution to computer science knowledge. This donation is made also to give evidence of the common contributions of Massachusetts Institute of Technology, Bell Laboratories, General Electric, Honeywell Information Systems Inc., Honeywell BULL Inc., Groupe BULL and BULL HN Information Systems Inc. to the development of this operating system. Multics development was initiated by Massachusetts Institute of Technology Project MAC (1963-1970), renamed the MIT Laboratory for Computer Science and Artificial Intelligence in the mid 1970s, under the leadership of Professor Fernando Jose Corbato. Users consider that Multics provided the best software architecture for managing computer hardware properly and for executing programs. Many subsequent operating systems incorporated Multics principles. Multics was distributed in 1975 to 2000 by Group Bull in Europe , and in the U.S. by Bull HN Information Systems Inc., as successor in interest by change in name only to Honeywell Bull Inc. and Honeywell Information Systems Inc. . ----------------------------------------------------------- Permission to use, copy, modify, and distribute these programs and their documentation for any purpose and without fee is hereby granted,provided that the below copyright notice and historical background appear in all copies and that both the copyright notice and historical background and this permission notice appear in supporting documentation, and that the names of MIT, HIS, BULL or BULL HN not be used in advertising or publicity pertaining to distribution of the programs without specific prior written permission. Copyright 1972 by Massachusetts Institute of Technology and Honeywell Information Systems Inc. Copyright 2006 by BULL HN Information Systems Inc. Copyright 2006 by Bull SAS All Rights Reserved