 
		CCL  -  CONSOLE COMMAND LANGUAGE
 
     If a command is not found by MCR either in its internal tables
 or as an external task installed with the name ...XYZ, the entire MCR
 command buffer is passed on to a catchall task ...CA.   CCL is a catchall
 task which has two parts.  The command is first scanned to see if it
 corresponds to any internal CCL commands.  If a command is found it
 is interpreted and sent to MCR.  If the command is not found, an attempt
 is made to decode the command using either a command procedure file
 on the user's UIC (SY:USERCCL.CCL) or a system command procedure file
 (LB:[1,5]SYSCCL.CCL).

     Further HELP using CCL may be obtained using the following keywords.

	COMMANDS
	COMMANDS BUILT_IN	Internal CCL commands you may use.
	COMMAND FILE		Creating a USERCCL.CCL command file.
	COMMAND FILE SYNTAX	Required structure for the command file.
	COMMAND FILE EXAMPLE	Detailed examples of CCL commands.
	ERRORS			The CCL errors
	INTRODUCTION		Introduction to how CCL works.
2	ERRORS

CCL -- Too many parameters
		Either more than 9 parameters are specified or the number
		of characters in all params. is more than 140.
CCL -- Error reading system file on LB1:	
		CCL could not read (or find) LB1:[1,5]SYSCCL.CCL
CCL -- No command line !	THIS IS A FATAL SYSTEM ERROR
CCL -- MCR syntax error or unknown command
		The command (first 8 char.) is not a valid MCR command CCL
		command, and was not found in USERCCl.CCL or SYSCCL.CCL.
CCL -- CCL command too long
		The number of parameters you typed in could not be formed
		into a command line of less than 79. characters.
CCL -- SPAWN failure to MCR	POSSIBLY A FATAL SYSTEM ERROR
CCL -- Illegal syntax in .CCL file
		The command you gave was found, But the lines following the
		"$" line have illegal syntax.
CCL -- Syntax error
		This error indicates improper syntax in the DLY command.
HEY -- Task XXXXXX not active or not found	
		A "-" commandline specified a taskname for a task not
		currently running.
2	INTRODUCTION

          The normal user interface to an RSX11M operating  system  is
     via  MCR  (Monitor  Console  Routine).   If terminal input is not
     specifically requested by a task, all data, or commands typed  in
     at  a  user's terminal are sent by the terminal driver to MCR for
     decoding.  The MCR task (and its child ...SYS) decode  user  com-
     mands(ACT,  ABORT, RUN, DEV, etc.).  Tasks installed with special
     names of the form ...XYZ are treated as a external  MCR  command.
     Hence if a user types 
      
     			XYZ commandline
      
     the 'commandline' in its entirity(or at least up to 79 characters
     is  sent  as  input to the task ...xyz.  this is the conventional
     way of supplying most system commands and controling  the  opera-
     tion  of  the  RSX11M  utility programs.  The limitations of this
     method are that each task must be installed to be treated  as  an
     external  MCR  command, and each extra installed task, uses valu-
     able pool space.  Moreover, because installed tasks use a  criti-
     cal  system  resource(pool),  only privleged users are allowed to
     install and remove tasks from the system.   The  normal  user  is
     restricted  to  starting tasks via the RUN command or using those
     tasks already installed.
~

          To alleviate this problem a user tailorable Console  Command
     Language  (CCL)  has  been  implemented which allows each user to
     have a private task control  language  which  will  pass  command
     lines  to tasks which are not installed in the system as external
     MCR commands.  When a user types in a command line, MCR is  given
     first  crack  at decoding it.  If MCR does not recognize the com-
     mand(first 3 letters) as either an internal( like  SET  /UIC)  or
     external  command,  then the command line in its entirity is sent
     to CCL which is installed as ...CA., the the catchall task.   CCL
     in  turn  checks  to  see  if it can find the command(the command
     stops at the first space, comma, =, <, or carriage return encoun-
     tered).   First it looks in its internal command tables to see if
     the command matches.  If the command does not match it then scans
     a  user file USERCCL.CCL to see if the command is present.  If it
     isn't, it checks in file LB:[1,5]SYSCCL.CCL to see if the command
     is a system CCL command.  If the command is not found anywhere, a
     warning message is printed.

          Each user may have an  individual  CCL  (USERCCL.CCL)  file.
     Instructions on how to structure a CCL file and some worked exam-
     ples are in APPENDIX A.  In APPENDIX B passing a command line  to
     a task via the RUN command is discussed.

2	COMMANDS

          A wealth of CCL commands exist to  simplify  the  amount  of
     type  in  a  user  has to do, and to allow the user access to the
     wide variety of RSX utility programs which  are  not  perminently
     installed in the system.

          In addition a number of commonly  used  commands  are  built
     into  CCL.   The  commands  SORT, DELETE, DIRECTORY, LIST, PURGE,
     SPOOL, TRUNCATE, FREE, UIC, POOL, ATS, DLG, SHW, SHQ and HEY  are
     internally  decoded by CCL .  Many of these commands are executed
     as PIP file commands and their syntax is
     		COMMAND  [filespec] [,filespec] ...
      
     The commands DIR and SORT do not require  a  filespecifier.  
     For HELP with the BUILT_IN commands, type HELP CCL COMMANDS BUILT_IN.    
     For information on the system CCL commands available to the user,
     type HELP CCL COMMANDS SYSTEM.
3	BUILT_IN

     A large number of internal commands also exist to decrease the
 ammount of type in necessary at one's terminal.  These commands
 are(only the first 3 letters are required)
	If a filespec is required, but you omitted it then CCL will prompt
by asking    Files? .
 
  ATS [TTn:]		Display active tasks [for specified terminal].
  BELL			Rings terminal bell.
  DELETE filspec	Delete files.
  DLG			Display logged in terminals.
  DLY NNNU		Delay NNN U units of time
  DIRECTORY [filspec]	Provide a directory listing.
  FREE  [DDn:]		Provide a free block display of the disk
  HEY tsknam		Connect to a task and notify user on exit.
  HOLD			Sets VT52 to HOLD mode(SET /HOLD = TI:).
  LIST filspec	List a file at terminal.(uses ...LIS if installed).
  NOHOLD		Sets VT52 to HOHOLD mode(SET /NOHOLD = TI:).
  NOSCROLL		Sets VT100 to fast scroll.
  POOL			Display free pool.
  PURGE filspec		Purge files.
  SCROLL		Sets VT100 to slow scroll.
  SHOW			Show who us logged on and what they're doing.
  SHQ			Show print queue(QUE /LI)
~
  SORT [filspec]	Provide a rapid, sorted directory listing
  PRINT filspec		Prints files on the line printer
  SYS			Display system UIC.
  TRUNCATE filspec	Truncate files
  TYPE filespec		Lists a file at terminal(uses PIP)
  UIC 			Display terminal's UIC(SET /UIC).
  UIC grm mem		SET /UIC = [grm,mem]
  UIC [grp,mem]		 "    "      "   "



3	SYSTEM      

          Note:	Command lines for utilities started by CCL are
     		limited to 40-50 characters.
      
     ACCLOG			RUN $ACCLOG
     ACNT			RUN $ACNT
     BUF [nn]			SET /BUF = TI:[nn]
     CHKSUM filespec		PAT NL:=filespec/CS,filespec
     CDA dev:=MM0:/SW		CDA dev:=MM0:/SW,LB:[1,54]RSX11M.STB/STB
     CMP command line		Identical to CMP syntax
     CVL command line		Identical to CVL syntax
     DATEL			RUN $DATEL
     DIOP			RUN $DIOP
     DMP command line		Identical to DMP syntax
     DSP			RUN $RMSDSP
     FLX command line		Identical to FLX syntax
     FTB commandline		Identical to FTB syntax
     FOR commandline		Identical to F4P syntax
    FOR [switches] filename		Similar to DCL
     F4P commandline		Identical to F4P syntax
     LBR commandline		Identical to LBR syntax
     PAT commandline		Identical to PAT syntax
     RECOVER filespec		Use RECOVER syntax
     RNO commandline		Identical to RNO format.
~
     RST			RUN $RMSRST
     SHOW			#LB:[1,2]SHOW.PRC
     SLP @commandfile.slp	Identical to SLP syntax
     VFY commandline		Identical to VFY syntax
     VMR			Identical to VMR syntax
     ZAP			Identical to ZAP syntax

     PRIVLEGED SYSTEM COMMANDS

     ACS DEV:/BLKS=N		Identical to MCR
     DISKSAVE			@LB:[1,7]DISKSAVE
     ERF			Identical to MCR
     ERRORS			@LB:[1,6]ERROR
     INCBKP			@[1,7]INCBKP
     LOA(D) DEV:		LOA DEV:/PAR=DRVPAR
     PSE			Identical to MCR
     SHUTUP			@LB:[1,2]SHUTDOWN
     SYE			Identical to MCR
     UFD dev:[UIC]		Identical to MCR
     UNL(OAD) DEV:		Identical to MCR
3	FILE

          When ...CA.  is activated from MCR...  the  programs  obtain
     the  command  line from MCR and divides it into units.  The first
     unit is the KEYWORD which is used to select the command from  the
     definition(.CCL)  files.  The other units become parameters 1 to-
     9 in order, all of which may be up to 140  characters  in  length
     and  which  are separated by spaces, commas, or '=' symbols.  The
     keywords are matched up to 8 characters.  If a request for a  re-
     quired input is terminated with ^Z, CCL exits.

          A user command definition file(SY:USERCCL.CCL)  is  searched
     for.   If  present  it is opened and scanned for a keyword match.
     If  it  is  not  present,  the  system  command  definition  file
     (LB:[1,5]SYSCCL.CCL)  is opened and scanned.  If the user file is
     scanned and the command is not found, then it is closed  and  the
     system  file  is  scanned  in  turn.  If the command is not found
     after the scan of the system file completes and  the  keyword  is
     terminated by a '?' character, the files are rescanned for a com-
     mand '?' which is called with its first parameter as the origioal
     keyword(less  the  '?').  This was added as an additional form of
     help command.  The system CCL command  file  interprets  the  '?'
     command as 'HELP'.  Hence, PIP?  is the same as HELP PIP.
~

          The command definition files have three main types of lines,
      
     	1)  beginning '$' - keyword lines(identification line)
     	2)  beginning '?' - keyword lines(input querry line)
     	3)  beginning '*','+', or '-' lines(action lines).
	4)  beginning '.'  branch to another line
	5)	lines 1-4 may begin with  nnnn: as a label.
      

          The command file consists of a keyword  identification  line
     followed  by  optional  input  querry lines and finally by one or
     more action lines.  The match procedure consists of comparing the
     keyword  from  the  command  line with the keyword in the command
     file.  If the minnumum length of match is satisfied and the char-
     acters up to the end of the command line keyword match characters
     in the keyword line, the match is successful.  Otherwise  failure
     is  signaled  and another '$' keyword line is searched for.  When
     no more keyword lines are found in the file, the file  is  closed
     and the search has failed in finding that command line.

4	SYNTAX

          The keyword line is as follows,
      
     $<m1><dummy><mp><ap>KEYWORD
      
     		First line of a command set.  There may be many
     		keyword lines for the same action line.
      
     	<m1>	Minimum number of characters to match.
     	<dummy>	Maximum number of characters to match (extra ignored).
     		(ignored in current version but must be present).
     	<mp>	Minimum number of parameters required.
     		If this number of parameters is not present then
     		parameters will be prompted for.
     	<ap>	Maximum number of parameters to question for if 
     		less than <mp> parameters are input.  In the case
      		where prompting this number is the highest prompt
     		 to be requested.
      
             KEYWORD is the command keyword.
~      
      
     	The keyword may consist of up to 8 characters to be 
     	matched identically by the CCL processor. The only 
     	terminators for the keyword typed by the user are <space> 
     	and <carriage return>.  Once the appropriate keyword is found
	and a non "$" line has been processed, another keyword line
	is flagged as an error.
      
     ?<n>QUESTION-TEXT
      
     	Where <n> is the parameter number (they can be in any order)
     	in the range 1-9 . If the correct number of parameters are
     	supplied no questions are asked, otherwise questions are
     	asked and the associated parameters are filled in.
     	If parameters are skipped then they will only have values
     	if they were given on the original command line.
	If +n is used a a parameter number it refers to the first parameter
	found after an "=" sign or "<" Unix redirect.  Likewise -n is the
	first parameter before (to left of) "=" or "<".  If there are 2 params.
	before "=" and 2 after then -3 and +3 are undefined, but 3 + 4 are not.
	<A> may be used to refer to the entire typed in line.
      
      
     < >KEYWORD command-line   	where < > is one of '-', '+', or '*'.

          Action lines come in two varieties.   '-'  lines  are  lines
     which  instruct  the  program to wait for a given task.  The task
     name is an absolute name and does not take on a  terminal  quali-
     fied  name(V3.2  does  not have executive task dispatching).  CCL
     will issue a connect directive to the specified task and  if  the
~
     task  is  found and is active, it will stop itself until the task
     exits.  The format for the wait line is
      
     		-<6-char-taskname>
 
	If a task has been spawned with event flag synchronization then
-$n will wait for event flag n.
      

          The '*' and '+' command lines differ only in  that  the  '+'
     line  signals  that  further command lines follow in the file.  A
     '*' signals that the command is the last or  only  command  line.
     The  text in the action line is copied except that any parameters
     present are substituted into the text  line.   The  action  lines
     consist  of  valid  MCR  commands  which must not involve further
     calls to CCL.  Special parameters are '%' followed  by  a  single
     character,  while substitution of the parameters 1-9 is performed
     by a parameter format described below.  If the first character after
     "*" or "+" is ";" then the line is a comment.  The resulting command
     line after parsing is typed on the terminal.  This is very useful in
     debug situations.   You need only preface the desired command string
     by ; and then you can look at the command line spawned to MCR, wihout
     any further action being taken.
		In addition ?; is treated a comment and is typed if either
     the number of parameters or the number to prompt for is unsatisfied.
     ?<n>; is a comment which is typed if only parameter <n> is unsatisfied.

          	%<pn><option1><option 2>%
     where
     	<pn>		is the parameter to be substituted(1-9)
			, "-n"  , "+n"  ,  or  "A"
     	<option 1>	is one of (null, '=', or ',')
     	<option 2>	is one of (null, <test char>text string)
     or
     	%<spec-char>	is one of '%','U','G','M', or 'T'.
~

          The '%' denote a parameter substitution argument.  The  <pn>
     is  the  number  of the associated parameter to be substituted or
     one of the special parameters.   Each  terminal  input  parameter
     must  be seperated by a delimiter.  Valid delimiters are:  space,
     comma(','), '=','<', '<-'.  A [UIC] is treated as a special  case
     in  that the comma seperating the group and member numbers is not
     treated as a delimiter(all of the UIC) can be one parameter.
  In addition spaces next to other separators are squeezed out of
  the command line as wll as spaces after "[","(", or "{".  Spaces
     before "]","}",")",".",":",";".

          The first group of optional elements denote a  character  to
     be  inserted  before  the parameter if the parameter is not null.
     Only ',' or '=' may appear in this  position(ie  be  inserted  in
     front  of the parameter).  The second group denote elements to be
     appended if their initial character is not present in  the  input
     parameter  string.   Typically  these are only those which denote
     file extensions and version numbers.  If the <test char>  is  not
     found  in  the  body of the parameter then that character and the
     text string following it are inserted after the body of the  par-
     ameter.  The first group may be omitted and no confusion will result.
~

          The special parameters are as follows,
      
     	
     	%G	The group number of the UIC.
     	%M	The member number of the UIC.
     	%T	The user's terminal ID(Tnn or Vnn where 'nn' is the
     		terminal number and 'Tnn' or 'Vnn' are for real terminals
     		and virtual terminals respectively.
     	%U	The user's UIC including '[,]'.
      
     examples:
     	%U	->	[12,10]
     	%G	->	12
     	%M	->	10
     	%T	->	T14 if TT14:, V1 if VT01:
     			useful for creating multi-terminal tasks(ie BAST2)
     			using INS/TASK=nnn%T.
~
      
          After a + CCL command is issued CCL  stops  itself  until  the
     command  is  complete.   When  the task completes it returns exit
     status back to CCL, which then processes a new line in the .CCL file.
     A "*" CCL command on the other hand causes CCL to exit after spawning
     the commandline to MCR.  When the invoked task exits the exit status
     is passed back to the task which invoked CCL (such as ...AT.).
     If you want wakeup notification when the proceedure is finished make
     the last line *;%B or *; comment line %B.
 
    	If you want to run several programs at once the symbol %$n% may be
    used on a "+" command line.  If n is omitted the line is spawned to MCR with
    event flag 0.  CCL will not wait and it processed the next line.  If n is
    specified (1-9) then an event flag is used.  CCL will not stop, but will
    process the next command.  Later a "-$n" line can be used to wait for the
    task spawned with the "+........%$n%" line to finish.
     
~
    	More complex command structures may be parsed using the "."
    command line.  The syntax of this line is.
     
    	. <nnnnn:> <pn> <Mssssss>
     
    	nnnn: is a label of up to 6 octal digits (max of 177777).  This is
    the label to search for after testing pn for the string ssss.  If nnn=0
    and a label search is necessary, then an input syntax error message is
    issued.  pn is 1-9,A,-n,+n as in ?<pn> etc.  M is a match char of
    "=","*","\", or " ".  = and * mean go to the labelled line if the
    string matches the <pn> and \ " " mean go to if it doesn't match.
    "=" and "\" mean try to match sss to <pn> starting from the beginning of
    <pn> and do not search any further if match fails.  "*" and " " mean
    try to match sss to any arbitrary subpart of <pn>.
    	sss is terminated by a "null".  If sss has zero length then
    the match turns into a test of existence of <pn>.  If <pn> exists then
    "*" or "=" will cause a search for label nnnn:.  Conversely "\" will
    cause a search if <pn> doesn't exist.
    	If in the course of a search a "$" line is encountered
    the line is typed and a .CCL syntax error is issued.
~
     
	   One last word of caution,  Be sure to test out all .CCL files using
     "*;"  or  "+;"   and never put extraneous blanks into your commandline.
     Extra blanks are likely to cause the command line to be too long.
4	EXAMPLES

 Sample CCL command file
      
     	$1111M
     	$2811ASSEMBLE
     	?1Filename
     	*MAC %1%=LB:[1,1]EXEMC/Ml,[11,10]RSXMC/PA:1,LB:%U%1%
     	$1411TYPE
     	$2411LIST
     	?1File
     	*PIP TI:=%1.MAC%%2,.MAC%%3,.MAC%
     	$2822COMPARE
     	?1Files
     	?2Output
     	*CMP %2.SLP%/SL=%1;-1%,%1;0%
     	$5511BUILD
     	?1FILE
     	+F4P %1.OBJ;1%=1%
     	+TKB %1.TSK;1/CP/FP%=%1%,LB:[1,1]F4POTS/LB
     	+PIP %1.OBJ;1%/DE
     	+RUN %1%
     	-%1%
     	*PIP %1.TSK;1%/DE
~
          The commands " M file " and "ASSEMBLE FILE"  have  the  same
     effect,  they  create  an object file from the source in [12,10].
     The command ASSEMBLE given without any parameters would result in
     the  prompt  "Filename?"  since the specification for the command
     requires at least one parameter, and it is to prompt for one par-
     ameter if it is not present.  The specification ensures that "M "
     is matched by the single character alone,  and  ASSEMBLE  by  the
     characters AS ASS ASSE ASSEM thru ASSEMBLE.

     In ASSEMBLE / M the filename given would normally be a plain name
     eg MCRDIS which would result in(UIC=[12,10]) 
      
     	MAC MCRDIS=LB:[1,1]EXEMC/ML,[11,10]RSXMC/PA:1,SY:[12,10]MCRDIS
     
~
     In LIST or TYPE since the required number of arguments is set  to
     one,  and  the  number of arguments to be prompted for is one the
     results are
      
     TY file		-> PIP TI:=file.MAC
     T file.slp		-> PIP TI:=file.slp
     TYPE file,file2	-> PIP TI:=file.MAC,file2.MAC
     TYPE
     FILE?myfile	-> PIP TI:=myfile.MAC
      
     COMPARE MCRDIS
     Output? TI:	-> CMP TI:.SLP/SL=MCRDIS;-1,MCRDIS
     CO
     Files? INDROT
     Output? INDROT	-> CMP INDROT.SLP/SL=INDROT;-1,INDROT
      
     or alternatively with the definition
      
     	$2722COMPARE
     	?1Files
     	?2Output
     	*CMP %2%%1.SLP%/SL=%1;-1%,%;0%
~
      
     one then has
     MCR>COM
     Files? INDROT
     Output? 		-> CMP INDROT.SLP/SL=INDROT;-1,INDROT;0
     or
     MCR>COM
     Files?INDROT
     Output?TI:		-> CMP TI:INDROT.SLP/SL=INDROT;-1,INDROT;0
~
      
      however altering this to
      
     	$2712COMPARE
     	..........
      leads to
     MCR> COM INDROT	-> CMP INDROT.SLP/SL=INDROT;-1,INDROT;0
     MCR> COM INDROT TI:-> CMP TI:INDROT.SLP/SL=INDROT;-1,INDROT;0
     and
     MCR> COMPARE
     Files?INDROT
     Output?TI:		->       ditto
      
     Because the number of parameters to prompt for was set to 2 
     if the required of 1 was not present.
      
     EXAMPLE:
      
     1.  UIC		==>  SET /UIC
     2.  UIC  [G,M]	==>  SET /UIC=[G,M]
     3.  UIC =[G,M]	==>  SET /UIC=[G,M]
~
      
          The following entries in SYSCCL.CCL produce the above
      syntax.
      
     		$3300UIC
     		*SET /UIC %2=%1=%
      
       Case 1.	No parameters present so   SET /UIC sent out.
      
       Case 2.	Since only one parameter is present ([G,M} {Remember
     		the comma in a UIC is not a delimiter.}, %2=% evaluates
     		to a null and %1=% evaluates to  =[G,M].
      
       Case 3.	The = sign (UIC =[G,M]) acts as the first delimiter
     		which means parameter 1 is evaluated to a null and
     		parameter 2 is evaluated to be =[G,M].
~      
      
     EXAMPLE:
      
     DIRECTORY filespec		==>PIP filespec/BR
      
          The CCL entries to produce this command would be
      
     		$3900DIRECTORY
     		*PIP %1;*%/BR
      
       Case 1.	The command DIRECTORY would have parameter 1 as 
     		null so the MCR command would be  PIP /BR.
      
       Case 2.	The command DIR *.CMD would have appended a ;* 
     		since there is no ';' in the command line typed in.  
     		So the command is passed back to MCR would be  
     		PIP *.cmd;*/BR.
      
       Case 3.	The command DIR *.CMD;1  would have nothing appended 
     		since a ';' is found in the input commnad.  Hence, 
     		the command PIP *.CMD;1/BR  would be sent to MCR
     		by CCL.
3	PASSING

               PASSING COMMAND LINES VIA THE RUN COMMAND


     Running a task via the RUN filespec facility causes the system to
     RUN  the  task and remove it on exit.  In reality MCR decodes the
     RUN command and then  issues  an  INS  filespec/RUN=REM/TASK=TTn.
     The /RUN=REM switch specifies that the task is to be removed from
     the installed task list when it exits.  In a standard RSX11M sys-
     tem  there  is no way to pass the task an MCR command line unless
     it is installed as an external MCR command(...XYZ).

          To partially bypass this restriction, a new switch has  been
     added   to   INS(and   hence   the   RUN   command),   the   /PRM
     switch(parameter).  The syntax is
      
     		RUN filespec/PRM=txt
     or
     		RUN filespec/PRM="txt"
      
     where 'txt' is an ASCII command string.  Both forms of  the  /PRM
     switch  do  the same thing.  However, if the command to be passed
     to the task when it is running is to include a switch(ie  a  '/')
     then the form using the "txt" is required.
~

          It should be pointed out that a normal MCR command line  may
     be  up  to 80 characters long.  The longest command line possible
     via the RUN command is 53 characters(if filespec is 9  characters
     long).  Adding a /TASK=TSKANM switch , or a /PRI=N switch further
     decreases the maximum length in a command by 12 and 7  characters
     respectively.   CCL  checks to see if an expanded command line is
     <80  characters  long.   If  not  it  issues  an  error  message.
     However, when used CCL is used with the RUN command, error check-
     ing is more difficult because of  the  implicit  /RUN=REM  switch
     which  is  automatically inserted into the command line by SYS as
     the command is passed on to INS to Install, Run, and  Remove  the
     task.   If  it is desired to have CCL do as much checking on com-
     mand line length as possible, prototype command lines  in  either
     USERCCL.CCL  or SYSCCL.CCL should avoid using the RUN command and
     should replace it with INS filspec/RUN=REM.


     EXAMPLE:
      
     	RUN LB:[1,53]DMP/TASK=...DMP/PRM="TI:=3831.ARC/AS"
        or
     	INS LB:[1,53]DMP/TASK=...DMP/RUN=REM/PRM="TI:=3831.ARC/AS"
      
~
          If command lines are not expected to be long and the task is
     frequently  used  by a large number of users, the CCL command can
     RUN (INS /RUN=REM) the task with a taskname of the  form  ...XYZ.
     This  means  when  the next user goes to use the task, and if the
     first user is still using the task, multiple copies of  the  task
     will  be  created, one for each terminal using the task.  As each
     task exits it will be removed from the installed task list.  This
     cuts  down  somewhat  on  the overhead of looking through the CCL
     command files.  A simple example of this is BASIC on our  system.
     BASIC  is not normally an instaled task, rather when a user types
     BASIC, CCL runs BASIC and installes  it  with  the  name  ...BAS.
     Once  the origional copy of ...BAS is active, multiple copies can
     be created at various terminals.  For tasks  which  require  long
     command  lines(BASIC  requires none), this method is not suitable
     and it may be necessary  to  RUN  the  task  without  the  /TASK=
     switch.   This  means  that the task will be run with the name of
     the terminal(TTN).  

