; This is the message file for the Developer's Toolkit Help program
;
; Authors:  Carolyn Lowenthal, Thomas Ball, Bob Nattenberg
; Version:  HelpMsg.txt ODV_DTKx1.0 08188910:30
;
;
; The form of the messages in this file is as follows:
;
;   Messages 0 thru 99 are the system messages.
;
;   Message  Line   Column  Frame   Max Message Length (including macros)
;             
;      0      0        0      0            30
;      1      0       66      0            13
;      2      0       31      0            35
;      3      1        0      2            29
;      4      2        0      2            29
;      5      1       30      2            50
;      6      2       30      2            25
;
; Top line (Frame 0)
;
:0: |Developer's Toolkit Help|
:1: |Page d of d|
:2: |Topic  s|
;
; Bottom lines (Frame 2)
;
:3: |Press Return for Index|
:4: |Press Finish when done|
:5: |Press Next Page or Prev Page to browse|
:6: |Enter Tool or Topic    >|
;
;
;    Discussion of Colors
;
;    The colors displayed in frames 0 and 2 (top and bottom) are hard wired.
;
;    However, in frame 1 (middle), video byte stream escape sequences can
;    be used to produce any combination of eight colors: White, Grey, Cyan,
;    Blue, Amber, Green, Yellow, and Red.  The default color is White.
;    The above colors are numerically represented from 0 (White) to 7 (Red).
;
;    On an NGEN monitor, the attribute bits are as follows:
;
;		       Attribute
;	Bit	(color)		(monochrome)
;
;	0	p0		Half bright
;	1	Underline	Underline
;	2	Reverse video	Reverse video
;	3	Blinking	Blinking
;	4	Bold		Bold
;	5	Struckthrough	Struckthrough
;	6	p1		not used
;	7	p2		not used
;
;    Bits p2, p1, and p0 taken together define the color desired.  Thus, if
;    p2 is set, p1 is not set and p0 is set, the number 101 in binary
;    corresponds to color 5 or green.  For example, if text to be displayed
;    is to be green, bold, and blinking, the binary number needed is 10011001
;    or 99 hexidecimal.  The character represented by 99h is followed by
;    a  and a B to achieve the desired result: B    For more
;    information on video byte stream sequences, see the CTOSVM Reference
;    manual.
;
;    One final note, on WYSIWYG monochrome monitors, the odd numbered colors
;    appear dull and difficult to read.  Since those monitors do not display
;    colors, color 0 or White is recommended.  (The above example would produce
;    halfbright, bold, and blinking.)
;
;
;
;
; Message 10 is the Error message
;
:10:
|AA





		
							   
		   BThe tool or topic you requested wasAA	   
		   Bnot found in the index.  PleaseAA	   
		   Bcorrect your entry and try again.AA	   
							   
		
|
;
; Message 11 is the IntroductoryHelp message.
; It also contains the version number of this help message file.
;
:11:
|AA
	HelpMsg.bin ODV_DTKx1.0 08188910:30


			Description of keys

	BNext PageAA \______	Advance to next page
	BScroll upAA 

	BPrev PageAA   \____	Revert to previous page
	BScroll DownAA  

	BReturnAA \		First page of Index  (With blank entry)
		>	First page of Topic  (With valid entry)
	BGoAA     		Error message Page   (With bogus entry)

	BFinishAA >	Quit program

	BHelpAA >	This page

|
;
;   Messages 50+ are the Index messages
;
;   The construction of the index is not done by Tool Kit Help.  Rather, the
;   user decides exactly how she wants the index to look.
;
;   The form is as follows:
;
;   :50: |Index name|
;   :51: |Index description...Page 1|
;   :52: |Index description...Page 2|
;   :n:  |Index description...Page n where n < 99|
;   :n+1: |END|
;
:50: |Index|
:51:
|
				ACText ProcessorsB

	Awk			Convert DOS File	Diff
	Find			Grep			Last
	Pr			Print Source File	Replace
	SDiff			Sed			Sort
	Source File Compare	Stream Editor		Translate Characters


				ACSource Code ToolsB

	Build Makefile		C Beautifer		C Preprocessor
	Cb			Compare Version		Cpp
	Create Message Source	Lex			M4
	Macro Processor		Make			Make Edf
	Make Prototype File	ObjMunge		YaccAA
|
:52:
|
				ACDebugging UtilitiesB

	Check Errors		Cross Reference		Ctrace
	Dump Object File	List Line Addresses	Request Monitor


				ACMiscellaneous UtilitiesB

	Coed			Convert and Copy	Cpio In
	Cpio Out		Dd			Pack
	Print Packed File	Touch			Unpack


				ACTOPICSB

	Redirecting IO		Regular Expressions	UNIX ParametersAA|
:53: |END|
;
;
;   Topics section
;
;   The form of the topics is as follows:
;
;   :1xxxx: |Topic name where xxxx >= 100|
;   :xxxx: |Topic description...Page 1|
;   :xxxx+1: |Topic description...Page 2|
;   :n:  |Topic description...Page n where n < 19998|
;   :n+1: |END|
;
;   The last message in this file must be of the form:
;
;   :xxxxx:|EOF| where xxxxx is the highest number in the 
;                message file an less than 65536. (The loading time of
;                this file is directly proportional to this number.
;
;
;  *** Start of topics ***
;
:10100: |Awk|
:100:
|
	BAwkB is a text manipulation utility which provides a means 
	for pattern searching, selection, testing and filtering.  

	At its most basic, BAwkB selects a line from the input file
	based on some selection criteria found in either [Command file]
	or [Command].  The selection criteria are made up of Bregular
	expressionsB.  If a match is found, BAwkB performs specified
	actions on the selected text.

	The selectionaction process is as follows:

	    AApattern     { action }B

	and indicates that every line that matches the pattern will have
	the action performed on it.  Either of the pattern or action is
	optional.

	A complete description of BAwkB can be found in BAwk  AB
	BPattern Scanning and Text Processing LanguageB (Second
	Edition), by A. V. Aho, B. W. Kernighan, and P. J. Weinberger.AA
|
:101:
|
	BQDescription of parametersAA

	[Input File(s)]	    BThe input files to be processed.AA

	[Command file]	    BA file containing the BAwkB commands to be executed.AA

	[Commands]	    BAwkB commands to be executed.  Either the
			    [Command file] or [Commands] parameter is used,
			    but not both.AA

	[Output file]	    BFile or queue for output, default [vid].AA

	[Field separator]   BThe character used to break input lines into
			    separate fields; the default is whitespace (tabs
			    and spaces).AA|
;
;
:102: |END|
:10130: |Build Makefile|
:130:
|

	BBuild MakefileB is a submit file which uses tools such
	as BSedB, BAwkB and BGrepB to build a Makefile acceptable
	to BMakeB.  BBuild MakefileB's parameters are identical to
	the Executive Path command, and specify the directory
	where the source files for the new makefile are located.

	BBuild MakefileB prompts the user for a list of sources files
	for which the makefile is to be built.  The default is all
	the C files in the target directory.  Also, BBuild MakefileB
	asks for the name of the run file and makefile.  The
	defaults are AAdirectory.runB and AAMakefileB.

	BBuild MakefileB's output may not be complete for every
	application and may need to be edited according to the
	user's specific needs.AA
|
:131: |END|
;
;
:10140: |Cb|
:140:
|







	BCbB is the UNIX name of the BCTOSB BC BeautiferB
	utility.  See BC BeautiferB for a complete description.AA
|
:141: |END|
;
;
:10150: |Cpp|
:150:
|







	BCppB is the UNIX name of the BCTOSB BC PreprocessorB
	utility.  See BC PreprocessorB for a complete description.AA
|
:151: |END|
:10160: |C Beautifer|
:160:
|    BC BeautiferB is a pretty printer for syntactically correct C programs.  
    BC BeautiferB's output might not agree with your philosophy of formatting 
    code, but if used on a large software project involving many 
    programmers, BC BeautiferB can be used to enforce a standard format.  The
    following example shows before and after output from BC BeautiferB:

    include <stdio.h>          include <stdio.h>
    void main(argc)             void main(argc)
    int argc;                   int argc;
    {                           {
    int i;              	    	int i;
    for (i=0;i < argc; i++) {   	for (i=0;i < argc; i++) {
    if (i == 99)                		if (i == 99)
    printf(Hello\n);         			printf(Hello\n);
    else                        		else
    {                           		{
    while (i > 50)              			while (i > 50)
    i;                        				i;
    printf(i = d\n,i);       			printf(i = d\n,i);
    }                           		}
    printf(Done\n);          		printf(Done\n);
    }                           	}
    }                           }|
:161:
|
	BQDescription of parametersAA

	Input file		BC source file to be formatted.AA

	[Output file]		BName of the output file, default [Vid].AA

	[KR style?]		BFormatting style as used in BThe C ProgrammingAA
				BLanguageB, by Kernighan and Ritchie.AA

	[Join lines?]		BJoin multipleline statements when possible.AA

	[Maximum length]	BThe maximum length of a line,
				default 120 characters.AA

|
:162: |END|
:10170: |Check Errors|
:170:
|



	BCheck ErrorsB will search .LST andor .MAP files for key
	words indicating either compilation andor link errors
	occurred.

	Currently, BCheck ErrorsB will find errors generated by
	BConvergent'sB Basic compiler, Mark Williams C compiler,
	Metaware High C compiler, BTOS C compiler, MicroSoft's Pascal
	compiler, Intel's PLM compiler, BConvergent'sB Macro assembler,
	BConvergent'sB  Cobol compiler, and BConvergent'sB Linker.

	BCheck ErrorsB can be used in conjunction with BMakeB to
	halt further execution of BMakeB if compilation errors
	have occured.AA
|	
:171:
|
	BQDescription of parametersAA

	Input file(s)			BList of source or list files to be
					checked for reported compilation or
					link errors.  These files may be source
					files for any of BConvergent'sB
					distributed compilers, or map files.AA

	[Stop submit file on error?]	BIf any list files report errors, AAYESB
					to this field causes any submit in
					progress to stop.AA

	[Log file]			BA copy of the display is written to
					the file specified in this field.AA

	[Log errors only?]		BSuppresses Checking filename ...
					done. messages.AA|
:172:
|
	BQDescription of parameters  continuedAA

	[Error file]			BSeparate file where only the error
					messages are written.  Output is the
					same as Log file when [Log errors
					only?] option is used.AA

	[Map file errors to ignore]	BNumber of acceptable map errors.
					This is used to suppress reporting of
					normal map errors, such as acceptable
					multiplydefined symbols.AA
|
:173: |END|
:10180: |Coed|
:180:
|

	BCoedB is a submit file which converts CODE segment
	names to COED in object modules using BObjMungeB.

	BCoedB is used for programs in which memory allocation
	is done in order to force code into memory locations
	that can be later reused for other purposes.  BCTOSB uses
	this for initialization code that becomes part of user
	memory after the OS has finished initializing.



	BQDescription of parameterAA

	Input file(s)	    BList of object files to be converted.AA

|
:181: |END|
:10190: |Compare Version|
:190:
|

	BCompare VersionB is the BCTOSB version of the UNIX
	dircmp utility.  BCompare VersionB checks whether the
	listed files are the same, different or nonexistent.

	The output from BCompare VersionB is a list of files which
	are different.  If AA[Details?]B are specified, the output
	indicates whether the files are the same, different or
	nonexistent.

	Note: if AA[Details?]B are not specified and a named file
	does not exist with either of the prefixes, that file
	(the null file) is considered to be the same.  That is,
	its name will not appear in the	output.AA
|
:191:
|
	BQDescription of parametersAA

	File list	BList of source files to be compared in the
			two directories.AA

	Prefix(es)	BDirectory or prefix specifications of the two
			target directories or subdirectories.  If only one
			prefix is specified, the current default (pathed)
			directory is used as the first directory, and the
			specified prefix as the second one.AA

	[Output file]	BThe name of the file that the output is written
			to, default [vid].AA

	[Details?]	BThe default is to only print those files that are
			different between the two directories.  This option
			details whether each file specified is the same,
			different, or not found in a directory.AA
|
:192: |END|
:10200: |Dd|
:200:
|







	BDdB is the UNIX name of the BCTOSB BConvert and CopyB
	utility.  See BConvert and CopyB for a complete description.AA
|
:201: |END|
:10210: |Convert DOS File|
:210:
|
	BConvert DOS FileB converts the line endings of text files
	between carriage returnline feed, the DOS convention, and 
	line feed, the convention for BCTOSB and Unix.  When converting
	from DOS, any endoffile characters (CodeZ) are also removed.

	If BConvert DOS FileB converts any line endings, the original 
	file is saved in a old file in a manner similar to the Editor.


	BQDescription of parametersAA

	Input file(s)	    BList of files to be converted.AA

	[Convert to DOS?]   BIf AAYESB, line endings are converted from the
			    BCTOSBUnix LF (Ah) to the DOS CRLF (ChAh)
			    characters.  If AANOB, they are converted from the
			    DOS CRLF to the BCTOSB LF, and any ending DOS EOF
			    character (1Ah) is removed.AA
|
:211: |END|
:10220: |Cpio In|
:220:
|
	BCpio InB and BCpio OutB are restorebackup utilities used
	to readwrite tapes fromto a UNIX acceptible format.  BCpio InB
	and BCpio OutB are capable of selective restorebackup using
	Bregular expressionB pattern formats.AA

	BCpio InB and BCpio OutB have been ported to BCTOSB to provide
	a file transfer capability between Unix and BCTOSB.  Their use as an
	archive facility instead of Standard Software's backup and restore
	utilities under BCTOSB isn't supported, and is strongly discouraged.AA
|
:221:
|
	BQDescription of parametersAA

	[Input file or tape]	    BThe name of the file or device to be
				    read from.  The default is [Qic]0.AA

	[File patterns]		    BThe Bregular expressionB wildcard pattern
				    to match with filenames.  In patterns,
				    metacharacters ?, *, and [...] match the
				    slash \ character.  Multiple patterns may
				    be specified.  The default is *, as in
				    select all files.AA

	[Copy all except matches?]  BCopy only those files that fail to
				    match any of the specified file patterns.
				    This option inverts the meaning of the
				    specified file patterns.AA
|
:222:
|
	BQDescription of parameters  continuedAA

	[Overwrite always?]	    BOverwrite existing files with archive
				    version.  The default is to only overwrite
				    those files where the lastmodified date
				    of the archive file is later than the
				    lastmodified date of the existing file.AA

	[List files only?]	    BDisplay a table of contents of the
				    archive file without copying any files.AA

	[Create subdirectories?]    BIf AAYESB, zerolength subdirectory files
				    are created whenever a Unix directory
				    record is read.  If the name of the
				    directory conforms to DOS directory naming
				    conventions, these subdirectories will be
				    recognized by ClusterShare.AA

	[Suppress block mode?]	    BBlock mode writes to the archive file in
				    5k blocks.  If suppressed, the archive
				    record size is 512 bytes.  Block mode is
				    normally used for faster transfer rates.AA
|
:223: |END|
:10230: |Cpio Out|
:230:
|
	BQDescription of parametersAA

	Input file(s)		    BThe list of files to be archived.AA

	[Output file or tape]	    BThe name of the file or device to be
				    written to.  The default is [Qic]0.AA

	[Remove WP formatting?]     BIf AAYESB, only the text portion of any
				    Word Processing or Document Designer files
				    will be saved.AA

	[Suppress block mode?]	    BBlock mode writes to the archive file in
				    512k blocks.  If suppressed, the archive
				    record size is 5 bytes.  Block mode is
				    normally used for faster transfer rates.AA
|
:231: |END|
:10240: |C Preprocessor|
:240:
|
	BC PreprocessorB or BCPPB is the C language preprocessor.

	Input to BC PreprocessorB is C language source which may contain
	preprocessor directives such as macro substitution, conditional 
	compilation, and inclusion of named files.

	Output from BC PreprocessorB is in a form acceptable to the next
	phase of the C compiler.AA
|
:241:
|
	BQDescription of parametersAA

	Input file		    BThe name of the C, BYaccB, or
				    BLexB source file.AA

	[Output file]		    BThe name of the file where the expanded
				    output is written, default [Vid].AA

	[Error file]		    BThe name of the file where any error
				    messages are written, default [Vid].AA

	[Include prefixes]	    BDirectory or prefixes used as part of the
				    search path for include files.  Default
				    include path is [Sys]<h>.AA

	[Define (name=value)]	    BMacro definitions to be used during
				    expansion.  These may either be of the form
				    name=value or simply name.AA

	[Undefine (name)]	    BNames of macros to be undefined.AA|
:241:
|
	BQDescription of parameters  continuedAA

	[Suppress line numbers?]    BSuppresses line number definitions of
				    the form line nnn from being included in
				    the output.AA

	[Retain comments?]	    BNormally BCppB removes source file
				    comments, AAYESB to this field causes comments
				    to be written to the output file.AA

	[Allow macro recursion?]    BNormally, a recursive macro causes an
				    error to be generated, AAYESB to this field
				    allows recursion.AA

	[List included files?]	    BPrint names of any included files to
				    the error file.AA
|
:242: |END|
:10250: |Create Message Source File|
:250:
|
	BCreate Message Source FileB source tool generates message
	files (.txt and .bin) used by BCTOSB NLS routines.

	Input to BCreate Message Source FileB is a C source
	(.c or .h) file that contains an <enumspecifier> that
	associates <enumerator>s with message text contained within
	C comments.  This utility provides:
		a.  Flexibility of C <enumerator> construct for
		    specifying message numbers.
		b.  Common file for input to C compiler and Create
		    Message facility to create text (.txt), message
		    (.bin), and constant initialization (.c or .h) files.
		c.  Compatibility with existing Create Message File,
		    provided through use of Chain mechanism.AA
|
:251:
|
	BQDescription of parametersAA

	C enum file		BThe name of the file containing the C
				enumeration statement (see example below).AA

	[Message text file]	BThe name of the output file containing the
				source to the message file.  The default is to
				substitute the .c suffix (if any) from the
				previous parameter with .txt.AA

	[Message binary file]	BThe name of the output file containing the
				binary message file.  The default is to
				substitute the .c suffix (if any) from the
				previous parameter with .bin.AA
|
:252:
|
	BExample of C enum file inputB

	* Example of C header file input to Create Message Source File *

	enum NlsMsg {
		 BADOPEN = 1
		* Unable to open * 
		,NOENUMFILENAME
		* Please specify .c file containing enum list *
		,NOTEXTFILENAME
		* Please specify .txt file name *
		,EARLYEOF
		* Unexpected EndOfFile in comment after  *
		,FILESTART
		* At the beginning of the input enum c file. *
		,DOTSDONE
		*   ... done. *
		,MAXERRORMSG
		* Unspecified error message.  *
				    };AA
|
:253:
^
	BMessage text file output will containB
	;
	; CreateMsgSrcFileMsg.txt
	;  
	; BADOPEN
	:00001:  Unable to open 
	; NOENUMFILENAME
	:00002:  Please specify .c file containing enum list 
	; NOTEXTFILENAME
	:00003:  Please specify .txt file name 
	; EARLYEOF
	:00004:  Unexpected EndOfFile in comment after  
	; FILESTART
	:00005:  At the beginning of the input enum c file. 
	; DOTSDONE
	:00021:    ... done. 
	; MAXERRORMSG
	:00022:  Unspecified error message.  AA
^
:254: |END|
:10260: |Cross Reference|
:260:
|

	BCross ReferenceB takes a list of object modules andor
	libraries and prints a list of symbols either defined
	or externally referenced along with the object module 
	or modules they were identified in.

	Also, BCross ReferenceB supports restricted output in many
	different combinations by specifying the appropriate
	options of the last two parameters.  These options are
	ANDed together to achieve the desired result.  Note:
	specifying (U)nreferenced AND (U)ndefined output produces
	the empty set.  Thus, in this case only, the two options
	are ORed together.  Also, certain combinations of
	options achieve duplicate results.AA
|
:261:
|
	BQDescription of parametersAA

	Input file(s)			    BThe list of object files andor
					    libraries to be cross referenced.AA

	[Output file]			    BThe name of the file where the
					    output is to be written.  The
					    default is [Vid].AA

	[Separate by letter?]		    BIf AAYESB, separate files are
					    created for each letter of the
					    alphabet, each containing the
					    symbols which start with that
					    letter.AA

	[Keys]				    BList of symbols to check.AA

	[List symbols only?]		    BIf AAYESB, only list the names of
					    the public and external symbols.AA|
:262:
|
	BQDescription of parameters  continuedAA

	[List definition modules only?]     BIf AAYESB, only list the names of
					    those files that define (public)
					    symbols.AA

	[List reference modules only?]	    BIf AAYESB, only list the names of
					    those files that reference
					    (external) symbols.AA

	[(R)eferenced (U)nreferenced]	    BSpecifying 'AARB' to this parameter
					    causes only those symbols that are
					    referenced (external) by one or
					    more modules.  Specifying 'AAUB' lists
					    only those modules that are
					    unreferenced by any modules.  A
					    symbol which only referenced in
					    its own module is considered
					    unreferenced.  The default is both
					    'AARB' and 'AAUB'.AA|
:263:
|
	BQDescription of parameters  continuedAA

	[(D)efined (U)ndefined]		    BSpecifying 'AADB' to this parameter
					    causes only those symbols that are
					    defined (public) by one or more
					    modules.  Specifying 'AAUB' lists only
					    those modules that are undefined by
					    any modules.  The default is both
					    'AADB' and 'AAUB'.AA
|
:264: |END|
:10270: |CTrace|
:270:
|
	BThe BCTraceB utility is used by invoking BCTraceB with the 
	source file to be traced, then compiling the BCTraceB output file 
	in place of the original source file and relinking the application 
	with <toolkit>..\toolkit.lib.  When the application is run, the source 
	lines are displayed when executed, along with current values of all 
	variables.

	Trace output may be enabled or disabled interactively using the
	debugger.  The tr_ct_ variable can be set to 1 to enable trace
	output, and 0 to disable it.AA

|
:271:
|
	BQDescription of parametersAA

	Input file			BName of source file to be traced.AA

	[Output file]			BName of file where output is to be
					written.  Default is [Vid].AA

	[Functions to be traced]	BTrace only the listed functions.AA

	[Functions to not trace]	BSuppress tracing the listed functions.AA

	[Maximum loop count]		BCheck AAnB consecutively executed
					statements for looping trace output,
					instead of the default of 20.  Use 'AA0B'
					to get all the trace output from
					loops.AA

	[Maximum variables]		BTrace AAnB variables per statement
					instead of the default of 10 (the
					maximum number is 20).AA
|
:272:
|
	BQDescription of parameters  continuedAA

	[Print function]		BChange the trace print function.
					For example, 'fprintf(stderr,' would
					send the trace to the standard error
					output.AA

	[Runtime file]			BUse the specified file in place of
					CtraceRuntime.c.  This lets you change
					the entire print function, instead of
					just the name and leading arguments
					described in the previous parameter.AA
|
:273:
|
	BQDescription of parameters  continuedAA

	[Formats (o x u e)]		BIn addition to the default formats
					for printing variables, you can specify
					additional formats to be displayed
					using 'AAOB' for Octal, 'AAXB' for
					Hexadecimal, 'AAUB' for Unsigned, or 'AAEB'
					for Floating point.  The default
					formats are:  long and pointers as
					signed integers; char, short, and int
					variables as signed integers and, if
					appropriate, characters; double
					variables as floating point numbers in
					scientific notation.AA

	[Suppress redundant output?]	BSuppresses redundant trace output
					from simple assignment statements and
					string copy function calls.  This
					option can hide bugs caused by use of
					the = operator in place of the ==
					operator.AA
|
:274:
|
	BQDescription of parameters  continuedAA

	[Include prefixes]		BDirectory or prefixes used as part
					of the search path for include files.
					Default include path is [Sys]<h>.AA

	[Define (name=value)]		BMacro definitions to be used during
					expansion.  These may either be of the
					form name=value or simply name.AA

	[Undefine (name)]		BNames of macros to be undefined.AA

	[Preprocess?]			BRun the BC PreprocessorB on the input
					before tracing it.AA

|
:275: |END|
:10285: |Diff|
:285:
|
	BDiffB is a utility used for reporting differences between
	two similar text files.  The output from BDiffB contains lines
	of these forms:

			n1 AAaB n3,n4
			n1,n2 AAdB n3
			n1,n2 AAcB n3,n4

	where AAaB stands for append, AAdB for delete, and AAcB for 
	change.  n1 and n2 reference the old file (n,n indicates a line 
	range), while n3 and n4 reference the new file.  Following each 
	of these lines, the affected text lines are printed, flagged by
	'<' for lines from the old file, and '>' for lines from the new
	file.

	BDiffB returns 0 if the files are identical, 1 if they are different,
	and 2 if there were any errors accessing the files.
|
:286:
|
	BQDescription of parametersAA

	Old file		BThe name of the first file to be compared.AA

	New file		BThe name of the second file to be compared.AA

	[Output file]		BName of the output file, default [Vid].AA

	[Ignore whitespace?]	BTreat all spaces and tabs equally, useful
				for ignoring simple format changes.AA

	[Output Sed script?]	BIf AAYESB, the output is a list of commands
				BSedB utility, which will recreate the new
				file from the old file.AA
|
:287: |END|
:10290: |Convert and Copy|
:290:
|




	BConvert and CopyB converts the AAInput fileB according to the specific
	options given and puts the result into the AA[Output file]B.
	Many various combinations of conversions are possible with this
	utility.  For more details, refer to the BCTIX Operating SystemB
	BManual, Version C, Volume 1B.AA
|	
:291:
|
	BQDescription of parametersAA

	Input file			BFile to be converted.AA

	[Output file]			BFile where output is written,
					default [Vid].AA

	[Map to lower case?]		BConvert upper case alphabetical
					ASCII characters to lower case.AA

	[Map to upper case?]		BConvert lower case alphabetical
					ASCII characters to upper case.AA

	[Convert EBQDIC to ASCII?]	BConvert from 256 character EBQDIC
					set to 128 character ASCII.AA

	[Convert ASCII to IBM?]		BConvert from 128 character ASCII
					to 256 character EBQDIC set used by
					certain IBM print train conventions.AA|
:292:
|
	BQDescription of parameters  continuedAA

	[Conversion buffer size]	BFor ASCIIEBQDIC conversion, the
					conversion buffer size is the EBQDIC
					block size.  For example, 80byte
					EBQDIC punch card images would use a
					buffer size of 80.AA

	[Swap every pair of bytes?]	BFlips the ordering of each pair of
					bytes, used when converting from
					several mainframe systems.AA

	[Stop on error?]		BStop processing when a read error is
					encountered.AA

	[IO block size]		BSize of buffers used for input and
					output.  For best efficiency when
					using a conversion buffer, this value
					should be a multiple of the conversion
					buffer value.  Default is 512 bytes.AA|
:293:
|
	BQDescription of parameters  continuedAA

	[Count of blocks to copy]	BConvert only the specified number of
					blocks (lines).  Default is complete
					file.AA

	[Count of blocks to skip]	BConvert blocks (lines) starting from
					the specified number.  Default is the
					beginning of the file.AA

	[Pad blocks?]			BIf AAYESB, spaces are added to the end
					of each line to size of IO block.AA

	[Output blocks to start after]	BSpecifies the number of blocks in
					an existing output file to start new
					output.AA
|
:294: |END|
:10295: |Dump Object File|
:295:
|
	BDump Object FileB reports the information contained in either
	and Object Module File (.obj), a Library (.lib) or a Run File
	Header (.run).	It determines the type of file from its contents
	(not its suffix), to output the appropriate format.
	
	An object file dump provides information such as externals and
	size of code and data segments.  OMF record types are

		BLKDEF,  BLKEND,  COMDEF,  COMENT,  COMMON,  DEBSYM,
		ENDREC,  EXTDEF,  FIXUPP,  GRPDEF,  LEDATA,  LHEADR,
		LIBHED,  LIBDIC,  LIBLOC,  LIBNAM,  LIDATA,  LINNUM,
		LNAMES,  LOCSYM,  MODEND,  OVLDEF,  PEDATA,  PIDATA,
		PUBDEF,  REDATA,  REGINT,  RHEADR,  RIDATA,  SEGDEF,
		THEADR,  TYPDEF,  LEXTDEF, LPUBDEF, LCOMDEF, UNKNWN

	For information about OMF formats, please read	B8086B
	BRelocatable Object Module FormatsB, Intel Corporation,
	(part number 121748001).AA
|
:296:
|
	BA library file dump provides information about all the
	object modules within the library.
		  
	A run file dump describes the information contained in the
	run file header such as run file size, starting cs:ip, initial
	stack segment and offset.  Information about run file headers
	is contained in the BLinkerLibrarian ManualB.
|
:297:
|
	BQDescription of parametersAA

	Input file		BThe name of the object file, library, or run
				file to be dumped.AA

	[Output file]		BName of the output file, default [Vid].AA

	[Record type name(s)]	BNames of the Intel object module format
				record types to be displayed (default is all).
				If an invalid type is entered, a list of all
				the valid types is displayed.  Option not valid
				when dumping run files.AA

	[Details?]		BDisplays additional information.  When
				dumping run files, this includes the LDT.AA

|
:298:
|
	BQDescription of parameters  continuedAA


	[Suppress video?]	BIf AAYESB, output is written to the file
				without displaying to screen.AA

	[Symbol file]		BWhen dumping run files with [Details?] set
				to yes, all public symbols are listed for each
				LDT entry.  The symbol file parameter is
				optional; if not defined, the default is strip
				the .run suffix from the input file, append
				.sym, and check the current directory for
				that file.AA

|
:299: |END|
:10300: |Find|
:300:
|




	BFindB searches the input files for occurences of the
	tokens supplied by the user.  If BFindB is successful,
	the line number and the line itself are reported.  BFindB
	searches for case insensitive matches in the input
	files.  If more	complex search patterns are required,
	see BGrepB.AA
|
:301:
|
	BQDescription of parametersAA

	Input file(s)		BIs the list of source or text files to be
				searched.AA

	Tokens			BIs a list of character sequences to search for.AA

	[Output file]		BIs a file to which the results will be
				copied to, default [Vid].AA

	[Compile?]		BIf AAYESB, then the name of each file in which
				a match was found is appended to the file
				CompileSUF.fls, where SUF is the suffix of
				the input file, such as Plm for Find.plm.AA

	[Find once?]		BIf AAYESB, then the program stops searching the
				current file as soon as one match is made.AA
|
:302:
|
	BQDescription of parameters  continuedAA

	[Matches only?]		BIf AAYESB, only the lines containing matches
				will be displayed.AA

	[File names only?]	BIf AAYESB, only the names of files containing
				matches will be displayed.AA
|
:303: |END|
:10310: |Grep|
:310:
|
	BGrepB searches input files for lines matching specified
	Bregular expressionB patterns.  Unlike the Unix version,
	the BCTOSB BGrepB allows multiple patterns to be specified.


	BQDescription of parametersAA

	Input file(s)		    BIs the list of source or text files to
				    be searched.AA

	Search pattern(s)	    BIs the list of regular expression
				    patterns to search for.AA

	[Output file]		    BIs a file to which the results will be
				    copied to, default [Vid].AA

	[File names only?]	    BIf AAYESB, only the names of files
				    containing matches will be displayed.AA
|
:311:
|
	BQDescription of parameters  continuedAA

	[Relative line number?]     BIf AAYESB, the line number where is match
				    was found is displayed.AA

	[Count of matches only?]    BIf AAYESB, the number of matches will be
				    reported for each file.AA

	[Case sensitive?]	    BIf AAYESB, upper and lower case letters are
				    different.AA

	[Exceptions only?]	    BIf AAYESB, the search is inverted so that
				    only those lines not matching any patterns
				    are reported.AA

	[Block number?]		    BThe index of the 512 byte block the
				    match was found in.AA

	[Suppress errors?]	    BIf AAYESB, any errors accessing the files
				    are ignored.AA
|
:312: |END|
:10320: |Last|
:320:
|
	BLastB prints the last AAnB lines of the named input
	files.  Preceeding the output from BLastB is the name of
	the file being printed.


	BQDescription of parametersAA

	Input file(s)		BIs the list of files to be displayed.AA

	[Lines (default 10)]	BIs the number of lines from the end to be
				displayed (maximum of 64).AA

	[Log file]		BIs the name of the file to which a copy of
				the output will be appended.AA
|
:321: |END|
:10330: |Lex|
:330:
|
	BLexB is a utility used to generate programs that perform
	simple lexical analysis.

	BLexB may be used in conjunction with BYaccB to create
	a language processor.  If so, BLexB generates the scanner
	portion of the language processor, and BYaccB generates the
	parser.

	Input to BLexB specifies character string matching with
	corresponding actions, if any, written in C.  Output from
	BLexB is C source generated to recognize the character
	strings and perform the actions as specified.  The generated
	source contains the procedure yylex() which contains a state
	table to perform the token recognition.
	
	For example, the BLexB input may specify that '*'characters
	start a comment, and provide a procedure to scan the rest
	of the comment text until '*'.AA
|
:331:
|
	BQDescription of parametersAA

	Input file	BIs the name of the BLexB source file to be processed.AA

	[Statistics?]	BIf AAYESB, information regarding resource usage will be
			displayed.AA
|
:332: |END|
:10340: |List Line Addresses|
:340:
|
	BList Line AddressesB prints source files with the debugger
	addresses for each line of code.  To use BList Line AddressesB,
	source files must first be compiled so that line number records
	are stored in the object files.  When these files are linked, the
	[Line numbers?] field must be set to yes.  BList Line AddressesB
	is then invoked using the map output by this Link, in the directory
	where the source files reside.

	Line records are enabled in High C in several ways.  The easiest
	is to add pragma On(Emit_line_records); to [Sys]<h>hc.pro.
	Alternately, the above statement can be added to the hc.pro in
	the local source directory, or into the source file itself.  
	Finally, line records can be enabled at the command line using
	on Emit_line_records.

	With BCTOSB C, line records are enabled by entering yes in the
	[Debug?] parameter for the CC86 command.  For other compilers,
	check its manual to see if line record output is supported.AA
|
:341:
|
	BPLM source must be compiled with the following command form:

		V2.3PLM86
		  File list		source file(s)
		  [List source?]	AAYESB
		  [List code?]
		  [Debug?]		AAYESB
		  ...


	BQDescription of parametersAA

	Map file	BIs the name of the map file to be read.AA

	Output file	BIs the name of the file or printer queue where the
			output is to be written.AA

	[Modules]	BSpecifies the module names to be output, default is
			all.  A module name is normally either the source file
			name without a suffix, or the source file name with
			_Code appended, as listed in the map file.AA
|
:342: |END|
:10350: |Macro Processor|
:350:
|


	BThe BMacro ProcessorB command is a languagenonspecific macro processor.
	Its capabilities are similar to the C preprocessor.  Macro
	processors help in mechanizing the generation of tables often
	used by other languages.

	For a complete description of BMacro ProcessorB, refer to the
	BSystem V User's ManualB, the BCTIX Operating System Manual,AA
	BVersion C, Volume 2B, or the BCTOS Developer's Tool Kit ReferenceB
	manual.AA
|
:351:
|
	BQDescription of parametersAA

	Input file(s)		    BThe names of the files to be processed,
				    default is [Kbd].AA

	[Interactive mode?]	    BIf AAYESB, operate interactively.  Output
				    is unbuffered.AA

	[Line sync output?]	    BIf AAYESB, output line number macros
				    (line ...) for the BC PreprocessorB.AA

	[Pushback buffer size]     BSpecifies the size of the pushback and
				    argument collection buffers, default is
				    4,096 bytes.AA

	[Symbol table hash size]    BSpecifies the size of the symbol table
				    hash array, default of 199.  The size
				    should be prime.AA
|
:352:
|
	BQDescription of parameters  continuedAA

	[Callstack size]	    BSpecifies the size of the call stack,
				    default is 100 slots.  Macros take three
				    slots, and nonmacro arguments take one.AA

	[Token buffer size]	    BSpecifies the size of the token buffer,
				    default is 512 bytes.AA

	[Defines (name=value)]	    BMacro definitions to be used during
				    expansion.  These may either be of the form
				    name=value or simply name.AA

	[Undefines (name)]	    BNames of macros to be undefined.AA
|
:353: |END|
:10360: |M4|
:360:
|







	BM4B is the UNIX name of the BCTOSB BMacro ProcessorB
	utility.  See BMacro ProcessorB for a complete description.AA
|
:361: |END|
:10370: |Make|
:370:
|
	BMakeB executes commands in an input file to update one or 
	more target files designated by names.  A name is typically 
	program.run.  If no input file is specified, the input file 
	is makefile.

	BMakeB updates a target only if that file depends on other 
	newer files (the prerequisites for the target).  BMakeB recursively 
	adds all prerequisite files of a target to the list of targets.  
	BMakeB assumes that missing files are outofdate.

	The input file contains a sequence of entries that specify 
	dependencies (which files depend on other files).  The first 
	line of an entry is a blankseparated, nonnull list of targets, 
	then a :, then a (possibly null) list of dependent files or targets.  
	Text following a ; and all following lines that begin with a tab are 
	commands to be executed to update the target. Commands may be 
	continued across lines with the <backslash><newline> sequence.  
	Everything printed by BMakeB (except the initial tab) is written
	to [sys]<$>make0.sub with the following substitutions:

		\n is translated as Return
		\g is translated as GO
		\f is translated as Finish|
:371:
|
	After all processing is complete, BMakeB submits the file 
	[sys]<$>make0.sub for execution (with macro expansion).

	Sharp () and newline surround comments.  The first line that 
	does not begin with a tab or  begins a new dependency or macro 
	definition.

	The following makefile says that pgm.run depends on two files, 
	a.obj and b.obj, who in turn depend on their corresponding 
	source files (a.c and b.c) and a common file incl.h.  Because
	there are default rules for file suffixes, BMakeB can
	determine that a.obj is dependent on a.c and how to invoke
	the C compiler properly:

		pgm.run: a.obj b.obj
			Bind\n a.obj b.obj\n pgm.run \n\n\n\n\
			       	10000\n\n\nPMOSS\n\n clibl.lib\g

		a.obj: incl.h
		b.obj: incl.h
|
:372:
|
	Unlike its Unix counterpart, BMakeB does NOT execute command 
	lines one at a time.  All lines are written to the file 
	[sys]<$>make0.sub for later execution.  Note that BCTOSB filename 
	specifications (strings with embedded period) in target and 
	dependency lists are NOT case sensitive.  All other symbols not 
	in command lines ARE case sensitive.  Since the command lines are 
	passed to the submit facility, all symbols in command lines are 
	not normally case sensitive (except for such things as BMakeB 
	macros and command line datetime macros).


	BQDescription of parametersAA

	[Targets]				BThe list of target names to
						update.AA

	[Input file, default Makefile]	BThe name of the description
						file.  The contents of the
						description file override the
						builtin rules if they are
						present.AA
|
:373:
|
	BQDescription of parameters  continuedAA

	[Silent mode?]				BIf AAYESB, command lines aren't
						printed before execution.  This
						mode is also entered if the
						fake target name .SILENT
						appears in the description file.AA
	[List commands only?]			BIf AAYESB, commands are
						displayed but not executed.AA

	[Touch target file(s)?]			BIf AAYESB, the target files are
						touched (causing them to be up
						todate) rather than the usual
						commands being executed.AA

	[Suppress wildcarding?]			BIf AAYESB, skip wildcard
						searches.  Do not search for
						.c, .plm, .pas, .for or .asm
						files when .obj is specified as
						dependent.  This option shouldAA
|
:374:
|
	BQDescription of parameters  continuedAA

						Bbe used when all dependencies
						are explicit, and the makefile
						is very large.AA

	[Ignore builtin rules?]		BIf AAYESB, do not use the
						builtin rules.AA

	[Verify target file(s) as current?]	BIf AAYESB, BMakeB returns a zero
						or nonzero status code
						depending on whether the target
						file is or is not uptodate.AA

	[Print macros and descriptions?]	BIf AAYESB, prints out a
						complete set of macro
						definitions and target
						descriptions.AA
|
:375:
|
	BQDescription of parameters  continuedAA

	[Define (name=macro)]			BDefines any macros used by 
						Make.  If a macro definition 
						exists in the makefile, a new 
						definition defined in this 
						parameter field will overwrite 
						the one in the makefile.AA

	[Debug?]				BIf AAYESB, prints out detailed
						information on files and times
						examined.AA|
:376: |END|
:10380: |Make Edf|
:380:
|





	BMake EdfB takes a list of PLM style files and outputs
	an appropriate external definitions or header file.

	Currently, BMake EdfB will output either PLM edf files,
	MicroSoft Pascal header files, or Ansi C header files.AA
|
:381:
|
	BQDescription of parametersAA

	File list	    BIs the list of PLMstyle files that contain the
			    public functions to be declared.  Other languages
			    are only supported if they have a conditional
			    compilation facility.  Each procedure to be read
			    would contain a PLMstyle declaration in addition
			    to one used by the source language, and would be
			    surrounded by a conditional block.  For example, a
			    C function would look like this:

				if 0
				FGotNmi: PROCEDURE (param) FLAG PUBLIC;
				DECLARE
					param POINTER
					;
				END FGotNmi;
				endif

				FLAG FGotNmi(POINTER param) {
				* body of function *
				}
|
:382:
|
	BQDescription of parameters  continuedAA

	[Output file]	    BThe name of the file where output is to be
			    written.  The default is [Vid].AA

	[Pascal format?]    BIf AAYESB, the output will be formatted to be
			    compatible with the 10.0 Pascal compiler.  The
			    default is no, for PLM format.AA

	[ANSI C format?]    BIf AAYESB, the output will be formatted to be
			    compatible with the ANSI C compilers, such as High
			    C.  The default is no, for PLM format.  Either
			    Pascal or ANSI C formats may be selected, not both.AA
|
:383: |END|
:10390: |ObjMunge|
:390:
|
	BObjMungeB changes the names of object module classes.

	BQDescription of parametersAA

	Input file(s)	    BIs a list of object modules.AA

	Old class name	    BIs a valid class name such as CODE or DATA.AA

	New class name	    BIs a class name of the same length and with the
			    same letters as the name given above, such as COED
			    or DAAT.AA
|
:391: |END|
:10400: |Pack|
:400:
|	BPackB compresses files using Huffman (minimum redundancy)
	codes on a bytebybyte basis.  The amount of compression 
	obtained depends on the size of the file and its character
	distribution, but typical text and run files show a reduction
	to 6075 of their original size.

	Files compressed by BPackB can be read or printed using 
	either the BPrint Packed FileB or BUnpackB commands.

	BQDescription of parametersAA

	Input file(s)		BIs a list of files to be compressed.AA

	[Force packing?]	BIf AAYESB, all files are packed whether or not
				there is any actual size reduction.AA

	[Display statistics?]	BIf AAYESB, statistics are reporting showing the
				actual byte reduction, the number of distinct
				bytes, and information regarding the Huffman
				tree created.AA

	[Delete original file?]	BIf AAYESB, the original, unpacked version
				of the file will be deleted from the disk.AA
|
:401: |END|
:10405: |Pr|
:405:
|







	BPrB is the UNIX name of the BCTOSB BPrint Source FileB
	utility.  See BPrint Source FileB for a complete description.AA
|
:406: |END|
:10410: |Print Source File|
:410:
|


	BPrint Source FileB is a file preparation utility used to pretty a
	document before it is sent to the printer.  Unlike BC BeautiferB,
	BPrint Source FileB is a generic utility designed to be used
	on any type of file.

	BPrint Source FileB includes many options which allow the user
	to specify exactly how she wants to format a document being sent
	to the printer.AA
|
:411:
|
	BQDescription of parametersAA

	Input file(s)			    BIs the list of files to be
					    formatted.AA

	[Output file]			    BIs the name of the file or
					    device where output is written,
					    such as a printer queue.AA

	[Header]			    BSpecifies the title to print,
					    default is the file name.AA

	[First page to format]		    BBegin output at the specified
					    page, default is start of file.AA

	[Number of columns]		    BProduces multicolumn output,
					    default is one column.AA

	[Print files sidebyside?]	    BIf AAYESB, all files are printed
					    simultaneously, each in a separate
					    column.AA
|
:412:
|
	BQDescription of parameters  continuedAA

	[Left margin]			    BNumber of spaces to offset each
					    line by, default 0.AA

	[Text width]			    BThe maximum number of text
					    characters per line, default 72.AA

	[Page length]			    BThe number of lines per page,
					    default 66.AA

	[Tab width]			    BThe number of characters in an
					    expanded tab.  This value is used
					    both for the input and output tab
					    expansion values.  To use separate
					    values, use en for the input width
					    and in for the output width on the
					    first parameter line before any
					    files.AA
|
:413:
|
	BQDescription of parameters  continuedAA

	[Line numbering?]		    BIf AAYESB, print the line number at
					    the start of each line.AA

	[Column separator]		    BSeparate columns by the single
					    character specified instead of by
					    the appropriate number of spaces.AA

	[Doublespace?]			    BIf AAYESB, double space each line.AA

	[Suppress formfeed]?		    BIf AAYESB, use a sequence of line
					    feeds instead of a formfeed
					    character.AA

	[Suppress headers and trailers?]    BIf AAYESB, neither the fiveline
					    header nor the fiveline trailer
					    are printed.  Printing stops after
					    the last line of the file is
					    printed, instead of spacing to the
					    end of the page.AA
|
:414: |END|
:10420: |Print Packed File|
:420:
|
	BPrint Packed FileB displays files compressed using the
	BPackB utility, and can be used to print files.  It also
	can be used to expanded compressed files, a task normally 
	done with the BUnpackB command.


	BQDescription of parametersAA

	Input file(s)		    BIs a list of compressed files.  The
				    packed suffix (.z) is optional.AA

	[Output file or device]     BIs the name of the file or device, such
				    as a printer queue.AA
|
:421: |END|
:10425: |Replace|
:425:
|
	BReplaceB performs a global searchandreplace on a series
	of files using a specified BSedB command.  The original 
	version of each file is stored in a old file.


	BQDescription of parametersAA

	Input file(s)	BIs a list of files on which the above editing
			commands are to be executed.AA

	Search pattern	BSpecifies a BSedBstyle regular expression
			pattern used to match the strings to be modified.AA

	[Replace with]	BSpecifies the string which will replace any 
			strings which match the search pattern.AA
|
:426: |END|
:10430: |Request Monitor|
:430:
|
	BThe BRequest MonitorB filter is a debugging tool that
	enables the user to observe and interrogate request and
	response messages of processes on a request code basis.
	
	It monitors the request and response messages of the Master,
	or an application running in a different context of Context
	Manager.
	
	To monitor the request and response messages of an application
	running in a different partition:

	i.    Context Manager must be installed with at least two
	partitions active, one partition to run the application
	program, and one partition to run the BRequest MonitorB.

	ii.   Enter the context intended for your application.

	iii.  Start your application.

	iv.   Enter the context intended for the BRequest MonitorB.AA
|
:431:
|
	BThere are two ways to stop the BRequest MonitorB, depending
	on whether or not it is running as a system service.
	
	a.  If you are running the BRequest MonitorB as System Service:
	Press <Action>d to deinstall.  When the log file has been
	closed and deinstallation is complete, you will hear a Beep.
	
	b.  If you are not running the BRequest MonitorB as System Service:
	Press Finish OR <Action>Finish to stop the BRequest MonitorB.

	Video operation of the BRequest MonitorB:

	You will come up in RUN MODE.  The initial display will show
	the monitor statistics at the top and the requests themselves
	will be scrolling up, and the available function keys will be
	displayed on the bottom.

	a.  RUN MODE.  The default passive filter mode.  Display is
	dynamically updated with each request as it enters the filter.
	A '+' on a request line indicates the request has been sent.AA
|
:432:
|
	Bb.  SINGLESTEP MODE.  The processing of each request is
	held up until a STEP command is issued. Examination of
	requests is possible before requests are sent.

	c.  EXAMINE MODE.  The user may tour through the entire
	saved history of requests looking for whatever is of
	interest.  The PAGE, SCROLL, UP ARROW, and DOWN ARROW keys
	are used to tour the request list.

	d.  DISPLAY MODE.  The request data is displayed. 
	It may be scrolled through using the PAGE, SCROLL, UP ARROW,
	and DOWN ARROW keys.

		FUNCTIONS:
		<F1> '<PBCB'	Display previous PbCb.
		<F2> 'PBCB>'	Display next PbCb.
		<F5> 'SHWRQ'	Display Request header data.
		<F8> '< REQ'	Display previous Request.
		<F10> 'REQ >'	Display next Request.AA
|
:433:
|
	BQDescription of parametersAA

	Request code(s)     BIs a list of request code numbers.  These number
			    may be entered either as decimal, or hexadecimal
			    numbers with an trailing h.AA

	[Output file]	    BThe name of a file where the monitored requests
			    are written to.AA

	[Suppress video?]   BIf AAYESB, video output is suppressed while the
			    request monitor is running.AA

	[System service?]   BIf AAYESB, the BRequest MonitorB is installed as a
			    system service.  This is useful for workstations
			    not running Context Manager and for SRPs.  If a log
			    file isn't specified, log output will be written to
			    [Sys]<Sys>RequestMonitorLog.lst.AA
|
:434: |END|
:10440: |SDiff|
:440:

	BSDiffB outputs a sidebyside listing of two files
	indicating those lines that are different.  In the margin
	between the two columns, a '<' indicates that the line is
	only present in the old file, a '>' indicates that it is
	only present in the new file, and a '|' indicates that
	the line is different in the two files.

	BSDiffB can be used to merge two files interactively
	into a third merge file.  When a merge file is specified,
	BSDiffB reports each different line, prompts the user
	with a '', and waits for one of the following commands:

		AAlB	   use the left column in the merge file
		AArB	   use the right column in the merge file
		AAsB	   silent, do not print identical lines
		AAvB	   verbose, print identical lines
		AAqB	   quit from the program

:441:
|
	BQDescription of parametersAA

	Old file			    BThe name of the first file to be
					    compared.AA

	New file			    BThe name of the second file to
					    be compared.AA

	[Output file]			    BName of the output file, default
					    [Vid].AA

	[Output line width]		    BThe maximum width for the output.
					    The default is the screen width if
					    the output file is [Vid], otherwise
					    130 characters.AA
|
:442:
|
	BQDescription of parameters  continuedAA

	[Print identical lines on left?]    BIf AAYESB, lines that are identical
					    in both files will only be printed
					    in the left column.  The default is
					    to print the same text in both
					    columns.AA

	[Ignore identical lines?]	    BIf AAYESB, only those lines that
					    are different will be reported.AA

	[Merge file]			    BThe name of the file where the
					    merged output from an interactive
					    merge is stored.  AA
|
:443: |END|
:10450: |Stream Editor|
:450:
|



	BStream EditorB is a noninteractive text editor ideally used
	as a tool for transforming data from one state to another.  While
	BStream EditorB has relatively few options, its use of Bregular
	expressionsB makes it a powerful tool for mechanized tasks.
|
:451:
|
	BQDescription of parametersAA

	Input file(s)			BIs the list of files to be edited.AA

	[Output file]			BThe file to which a copy of the
					output is written.  AA

	[Script file]			BIs a file containing a script of
					editing commands.AA

	[Edit commands]			BIs a list of editing commands.
					Either this parameter or the
					[Script file] parameter must be filled
					in, but not both.AA

	[Global substitution?]		BIf AAYESB, all substitute commands are
					global.AA

	[Suppress default output?]	BIf AAYESB, default output is
					suppressed.  This means that output is
					only written when directed by the
					editing script.AA|
:452: |END|
:10460: |Sort|
:460:
|

	BSortB, as its name implies, sorts the contents of an
	input file in alphabetic or numeric order.  However, BSortB's
	power comes from its ability to sort on different types of 
	keys in any order in the text.  BSortB can discriminate between
	fields in the text using the field separator as a delimiter.

	For simple sorting tasks, BSortB can be used with little
	or no help.  For intricate sorting problems, refer to the
	BSystem V User's ManualB or the BCTIX Operating System Manual,AA
	BVersion C, Volume 2B.AA
|
:461:
|
	BQDescription of parametersAA

	Input file(s)				BIs a list of the files to be
						sorted.AA

	[Output file]				BIs the name of the file
						where the output is written.
						The default is [Vid].AA

	BThe following fields describe BSortB keys.  If multiple BSortB
	keys are desired, each key's parameters are described by the
	subparameter for that option.  For example, to BSortB the output
	of a Files command with details, first by size (field 3, ignore
	blanks, numeric) and then by name (field 0, ignore case), the
	following (abbreviated) form would be used:

	    Sort
	      [Start position]			2 0
	      [Stop position]			3 1
	      [Ignore leading blanks?]		yes no
	      [Ignore case?]			no yes
	      [Numeric key?]			yes noAA|
:462:
|
	BQDescription of parameters  continuedB

	For multiple parameters, the [Start position] and [End position]
	parameters must be filled in.  Any other parameters that are used
	by any one key must be specified for all keys.AA

	[Start position]			BIs the field index of the
						starting position of a key.
						Fields are delineated by the
						field separator, which is
						normally whitespace.  The first
						field has an index of 0, the
						next 1, and so on.  Optionally,
						a character index inside of a
						field may be used with the
						format m.n, such as 1.3
						specifying that the BSortB key
						begins at the fourth character
						(0 is the first) of the second
						field.AA
|
:463:
|
	BQDescription of parameters  continuedAA

	[Stop position]				BIs the field index of the
						field after the end of the
						key.  Normally this is the next
						field from the start position,
						but multiple fields may be
						grouped as a composite key.AA

	[Ignore leading blanks?]		BIf AAYESB, leading blanks are
						ignored for comparison purposes.AA
	[Case sensitive?]			BIf AAYESB, upper and lower case
						alphabetic characters are
						considered separately.AA

	[Dictionary sort?]			BIf AAYESB, Dictionary order
						is used, such that only
						letters, digits, and blanks
						(spaces and tabs) are
						significant in comparisons.AA|
:464:
|
	BQDescription of parameters  continuedAA

	[Reverse sort order?]			BIf AAYESB, the BSortB is in
						descending order.AA

	[Compare as months?]			BIf AAYESB, the first three non
						blank characters of the field
						are converted to uppercase and
						compared so that JAN < FEB
						< ... < DEC.  Invalid fields
						compare low to JAN.  If this
						parameter is yes, it implies
						that blanks are ignored.AA

	[Numeric key?]				BIf AAYESB, the field is treated
						as a number, consisting of
						optional blanks, optional minus
						sign, and zero or more digits
						with optional decimal point,
						and is sorted by arithmetic
						value.  If this parameter is
						yes, it implies that blanks are
						ignored.AA|
:465:
|
	BQDescription of parameters  continuedAA

	[Ignore nonASCII chars?]		BIf AAYESB, characters outside
						the range of 20h7Eh are
						ignored for comparison purposes.AA
    The following options are global in nature:

	[Suppress output if already sorted?]	BIf AAYESB, output is only
						written if the input isn't
						sorted according to the
						specified BSortB rules.AA

	[Merge files without sorting?]		BIf AAYESB, the input files are
						merged without sorting them
						first.AA

	[List unique records only?]		BIf AAYESB, only the first of a
						set of lines with a common
						field is output.AA
|
:466:
|
	BQDescription of parameters  continuedAA

	[Maximum record length?]		BDuring sorting, the maximum
						line length (used during
						merging) is recorded.  If the
						[Merge files without sorting?]
						is yes, the default maximum
						record length is 512
						characters.  If any lines in
						the input files are longer than
						this default, the maximum must
						be set.AA

	[Field separator]			BSpecifies a character to be
						used as a field separator.  The
						default is blanks (spaces and
						tabs).  Unlike blanks, each
						occurrence of the specified
						field separator is
						significant.  For example, if
						the field separator is a colon,
						:: indicates an empty field.AA|
:467: |END|
:10470: |Source File Compare|
:470:
|    BSource File CompareB locates differences between two files and
    prints the line number and the line of each file.  The differences
    are indicated by a  for the old file and a * for the new file.
    Also, a ] indicates the preceeding line of the differences while a
    [ indicates the following line of the differences.  Lines marked
    with () were found in a different place in the new file from their
    position in the old file.  For example, given the following two files:

		oldfile				newfile

		one				one
		two				2
		three				three

	the output from BSource File CompareB is:

		Old file:       oldfile
		New file:       newfile
		Output file:    compfile

		    1  ]	one
		   (2) 	two
		    2  *	2
		    3 [ 	threeAA|
:471:
|
	BQDescription of parametersAA

	Old file		BThe name of the first file to be compared.AA

	New file		BThe name of the second file to be compared.AA

	[Output file]		BName of the output file, default [Vid].AA

	[Differences only?]	BIf AAYESB, only those lines that are different
				will be output.AA

	[Ignore whitespace?]	BIf AAYESB, any combination of tabs and spaces
				will be treated as a single space.AA

	[Ignore case?]		BIf AAYESB, upper and lower case alphabetic
				characters are considered equal.AA
|
:472: |END|
:10480: |Sed|
:480:
|






	BSedB is the UNIX name of the BCTOSB BStream EditorB
	utility.  See BStream EditorB for a complete description.AA
|
:481: |END|
:10485: |Touch|
:485:
|
	BTouchB changes the lastmodified date of each specified
	file to the current date and time.  This command is normally
	used in conjunction with BMakeB to force recompilation
	and linking.


	BQDescription of parametersAA

	File list   BIs the list of files to be touched, that is, have their
		    lastmodified date changed to the current date and time.AA

|
:486: |END|
:10490: |Translate Characters|
:490:
|


	BTranslate CharactersB is the BCTOSB name of the UNIX
	BTrB utility.  BTranslate CharactersB is used to substitute
	or delete characters from the named input file based on the AA
	[Input character string] BandAA [Output character string]B
	parameters.  For more details, refer to the BSystem V User'sB
	BManualB or the BCTIX Operating System Manual, Version C,B
	Volume 2B.AA

| 
:491:
|
	BQDescription of parametersAA

	Input file			BIs the name of the file to be
					translated.AA

	[Output file]			BIs the name of the file where the
					output is written.  The default is
					[Vid].AA

	[Input character string]	BSpecifies the characters to
					translate in the input stream.  AA

	[Output character string]	BSpecifies the characters to
					translate in the output stream.  AA

	[Complement input characters?]	BIf AAYESB, the complement of the
					specified input character string is
					used, using all characters but the ones
					specified.AA
|
:492:
|
	BQDescription of parameters  continuedAA

	[Delete input characters?]	BIf AAYESB, deletes all characters in
					the input string found in the input.AA

	[Squeeze output characters?]	BIf AAYESB, squeezes all strings of
					repeated output characters that are in
					the output character string to single
					characters.AA

	BRanges of characters in the input and output character
	string parameters may be specified as follows:

	[az]	    Stands for the string of characters whose ASCII
		    codes run from character a to character z, inclusive.

	[a*n]	    Stands for n repetitions of a.  If the first digit
		    of n is 0, n is considered octal, otherwise decimal.
		    A zero or missing n is taken to be huge; this
		    facility is useful for padding the output string.AA
|
:493:
|

	BThe escape character \ may be used to remove special meaning
	from any character in a string.  In addition, \ followed by
	1, 2, or 3 octal digits stands for the character whose ASCII
	code is that value, similar to C.AA
|
:494: |END|
:10510: |Unpack|
:510:
|
	BUnpackB is used to expand files compressed using the BPackB
	utility.


	BQDescription of parametersAA

	File list   BIs a list of compressed files.  The packed suffix (.z)
		    is optional.AA
|
:511: |END|
:10520: |Yacc|
:520:
|
	BYaccB is a utility used to generate programs that perform
	language parsing for the front end of a compiler.  BYaccB
	is an acronym for AAYBet AAABnother AACBompilerAAC
	Bompiler.  It can be used in conjunction with Lex.  If so, 
	BLexB generates the scanner portion of the language processor,
	and BYaccB generates the parser.

	Input to BYaccB specifies sequences of grammer rules for
	input tokens, along with corresponding actions, if any, 
	written in C.  Output from BYaccB is converted into a LALR
	parser, written in C, including the corresponding actions.

	For example, BYaccB input may specify input for a desk
	calculator.  It can include specification of precedence
	rules and error recovery.
|
:521:
|

	BCreation of language processor with BYaccB

	<yacc source>.y 	> YACC UTILITY	> yyparse() in y.tab.c
				
				*		> token codes in y.tab.h

	yylex()      \
	yyerror()     \
	main()         \
	y.tab.c	 	*> C COMPILER>LINKER	> y.tab.run

	input stream   > y.tab.run		> processed language results
							(e.g. an .obj file )
|
:522:
|
	BQDescription of parametersAA

	Input file			BIs the name of a BYaccB source file.AA

	[Output header file?]		BIf AAYESB, the file y.tab.h is created
					containing a series of BC PreprocessorB
					define statements for each of the
					parser tokens and its value.AA

	[Output summary file?]		BIf AAYESB, the file y.output is created
					containing a description of the parsing
					tables and a report on conflicts caused
					by ambiguities in the grammar.AA

	[Suppress line constructs?]	BIf AAYESB, BC PreprocessorB line
					statements are not generated.AA

	[Enable parser debugging?]	BIf AAYESB, runtime debugging code is
					included.  The debugging output is
					enabled when the YYDEBUG variable is
					nonzero.AA
|
:523: |END|
:10530: |Regular Expressions|
:530:
|
	BRegular expressionsB are patterns or templates used
	to match with text.  BCTOSB wildcards are an example of
	Bregular expressionsB, but utilities such as BGrepB,
	BAwkB, and BSedB use a more powerful version of them.

	Two of the simplest metacharacters to use are the circumflex
	(^), which matches the beginning of the line, and the dollar 
	sign ($), which matches the end of the line.  The pattern
	^$ would therefore match any empty line.

	The period (.) will match any single character, and is 
	equivalent to the BCTOSB '?' wildcard character.  Note that
	the question mark is used in Bregular expressionsB as
	detailed on the next page.AA
|
:531:
|
	BRepeated character matches, or closures, can be defined by 
	surrounding the number of repeats with braces.  For example, 
	you can match a pattern of four a's with a{4}.  The 
	general format is {m,n}, where m is the minimum number of 
	repeats and n is the maximum.  

	Several metacharacters are used as a shorthand way of
	describing common closures.  They are:

		* (asterisk)	is equivalent to {0, }, meaning that
				the preceding character pattern is 
				to be repeated AAzero or more timesB;
		+ (plus sign)	is equivalent to {1, }, meaning that
				the preceding character pattern is 
				to be repeated AAone or more timesB; and
		? (question)	is equivalent to {0,1}, meaning that
				the preceding character pattern is 
				to be repeated AAzero or once onlyB.				

	Many utilities do not support the formal method of defining
	closures, but they all support the shorthand metacharacters.AA
|
:532:
|
	BCharacter classes define a set of valid characters that can
	match a single character, and are specified by surrounding
	the characters with brackets, '[' and ']'.  To find the 
	word the, for example, the pattern [Tt]he would find
	the word regardless of whether it started a sentence or not.

	Ranges of characters may be defined by using a hyphen ()
	between the first and last character of the range.  Multiple
	ranges may be specified; for example, [AZaz] will match any
	alphabetic character.  

	If you wish to invert a character class (match on any 
	character NOT specified), start the class with a circumflex 
	(^).  [^09] will match on any nonnumeric text, for example.AA
|
:533: |END|
:10540: |UNIX Parameters|
:540:
|
	BThe Developer's Tool Kit utilities ported from Unix System V
	have been modified to support both BCTOSB Executive command
	forms and their original Unix parameter handling.  This allows
	developers familiar with the utilities in a Unix environment
	(or existing BMakeB scripts) to use the utilities without
	learning BCTOSB command forms.  

	BUnix parametersB are all entered in the first parameter
	of the command form.  As an simple example, BCbB can be 
	invoked with the KR and join lines options in two ways:

		Cb
		  Input file		AAtest.cB
		  [Output file]
		  [KR style?]		AAyesB
		  [Join lines?]		AAyes			GOB

	or

		Cb
		  Input file		AAs j test.c		GOAA
|
:541: |END|
:10550: |Redirecting IO|
:550:
|
	BMost Unix utilities are developed with the assumption that
	the shell they are invoked by supports input and output 
	redirection and piping, where the output of one utility can 
	be directed to the input of another.  The BCTOSB Executive
	doesn't directly support redirection, but there is a way
	to emulate its basic functions.

	The Unix utilities that send their output to standard out
	(stdout, [Vid] is the default) have an output file parameter
	under BCTOSB.  Specifying a file or spooler queue in this
	parameter redirects the output to that file or device.  To
	emulate a pipe between utilities, the redirected file can
	be used as the input file for the next utility.

	These steps may be automated using a submit file, specifying
	temporary files ([Scr]<$>name) for the intermediary files.AA
|
:551:
|
	BFor example, to get a list of directory names on a BCTOSB
	volume, first run:

	Volume Status
	  [Volume or Device name]	(volume name)
	  [Details?]
	  [Print file]			AA[Scr]<$>dirsB

	Next, invoke Awk, specifying that we want the first field
	of each directory line:

	Awk
	  Input file(s) 	AA[Scr]<$>dirsB
	  [Command file]
	  [Commands]    	AA'NF == 3  $1  Directory { print $1 }'B
	  [List file]   	(final output file name)

	Using a submit file, the volume name parameter would be 0,
	and the final output file name would be 1.  Both parameters
	would be optional, with the volume defaulting to the default
	path, and the output file being [Vid].AA
|
:552: |END|
:10560: |Make Prototype File|
:560:
|
	BMake Prototype FileB reads a list of High C .lst files
	containing function prototypes and outputs those prototypes
	to a header file.  The High C compiler generates these
	prototype entries in its list file when either the statement:

			pragma On(Print_protos); 

	is included in the hc.pro file or the source files, or when:

			on Print_protos

	is specified as a command line option.


	BQDescription of parametersAA

	File list	    BIs the list of High C .lst files containing
			    function prototype statements.AA

	[Output file]	    BThe name of the file where output is to be
			    written.  The default is [Vid].AA
|
:561: |END|
:10570:|EOF|
