Notas tecnológicas de Rafael San José

Google
WWW rsanjose.webcindario.com

¡Recomienda esta página a tus amigos!
Powered by miarroba.com

Página Principal

IBM AS/400

Retroceder

dispositivos
tareas

Cambiar valor del sistema
Copia del sistema
dev.html (Sin descripción)
dispositivos.html (Sin descripción)
funcion.html (Sin descripción)
indice.html (Sin descripción)
Inicilizar una cinta
GO POWER
OPERATOR INSTRUCTIONS
Pero... ¿Qué es un AS/400?
Arranque de transcriptor remoto
STRSDA

OPERATOR INSTRUCTIONS
1.1.       Go to menu program - OPERATOR INSTRUCTIONS.   
           Introduction                                  
01-          The Go to menu program.                     
           Selection display.                            
02-          Command Keys. (CMD03, CMD04, CMD06, CMD09..)
03-          Request line. (*GO. *M, *C, *D, *A)         
           Additional functions                          
04-          Help text display.                          
05-          Confirm prompt.                             
01-                                                                            
1.1.1.      INTRODUCTION TO THE MENU DISPLAY PROGRAM                           
                                                                               
   This program displays Synon/1 menus.                                        
                                                                               
   Each  menu contains options which can be selected.  Selecting a menu option 
will either execute the program associated with the option, or display another 
menu.                                                                          
                                                                               
         MENU DISPLAY: OPTION ENTRY                                            
                                                                               
   For Column style menus, all  options,  except branching to other menus, may 
be selected by entering '1' or 'X'  in  the field provided by the desired menu 
options, followed by ENTER                                                     
                                                                               
   For both Column and Option style  menus  to  select  an option, type in the 
option  number  in  the  request  field shown at the bottom of the display and 
press ENTER.                                                                 + 

02-         Command Keys. (CMD03, CMD06, ...)                                  
                                                                               
**      Command    * CMD03    = Return to topmost menu.                        
        keys.      * CMD04    = Call command prompter program.                 
                   * CMD06    = Display workstation messages.                  
                   * CMD08    = Retrieve last request in reverse (Commands).   
                   * CMD09    = Retrieve last request (Commands).              
                   * CMD10    = Call OS/400 command entry program (QCMD) (Only 
                                of you are permitted).                         
                   * CMD12    = Display menu at next higher level.             
                   * CMD14    = Display submitted jobs.                        
                   * CMD16    = Display top menu.                              
                   * CMD22    = Display menu status display.                   
                   * CMD23    = Make current menu top, clear other levels.     
                   * CMD24    = Display more command key descriptions.         
                   * ROLLUP   = Show next page of menu, if present.            
                   * ROLLDOWN = Show previous page of menu, if present.        
                   * HELP     = Display Help Text.                           
                   * ENTER    = Execute option.

03-                                                                           
1.1.1.1.       Request data field.                                            
                                                                              
   All requests are entered in  the  request data field. The various functions
may be comprised of a single  entry,  for  example,  a menu option, or several
entries, such as a command with parameters, or a combination of a keyword with
or without parameters, as shown below.                                        
                                                                              
        - Menu option: the number(s) or  letter(s)  shown against the descrip-
             tion in the main body of the menu display.                       
                                                                              
        - *GO menu  name: to branch to other menus in the current member.     
             - Must  be  a  valid  menu  name, or one of the following special
               values:-                                                       
             - 'n'   :where 'n' is a  menu level which has already been estab-
               lished.                                                        
             - *TO   :go to top menu                                          
             - *PRV  :go to previous menu                                    +
             - '?'   :display a list of available menus.                       
        - *EXC command : execute the  request  string which follows.   request 
             - This keyword may be  omitted.  The  program  will  assume  that 
               entries which are not menu options are commands. If the command 
               prompter is used the program  will  assume  that the entry is a 
               command.                                                        
        - *SBM command  :  submit the specified request string or menu option. 
             Use  the default job description as specified by the JOBD parame- 
             ter on the 'Goto Menu' YGO command.                               
        - *JOB command :  submit the  request  string specified on the request 
         µØ Ø                                                                  
             parameter using the current job's attributes.                     
        - *DISPLAY option : display the request string which would result from 
             taking the specified option, but do not execute.                  
        - *CHECK option :  parse the request string associated with the option 
             specified on the menu option parameter, but do not execute.       
        - *AUT  option  :  Display object authorities for the object called by 
             the option specified on the menu option specified.              + 
        - *MNU   : edit the current menu.                                     
                                                                              
        - 'SO' will sign you off.                                             
                                                                              
        All the  above keywords may be abbreviated to the first two characters
             shown, e.g.  *G  *M  etc.                                        
                                                                              
        - Command : valid commands may be entered in the request field and the
             command prompter can be used  to  assist  entry  of parameters by
             pressing CMD04                                                   
             - If the command executes  without  error, the request string may
               be  retrieved later  using  CMD09 or  CMD08.  (CMD09  retrieves
               options in reverse  chronological order, whilst CMD08 retrieves
               them chronologically)                                          
                                                                              
        Special values for command line                                       
                                                                              
        The following special values  are provided to provide enhanced comma +
             line functionality.  All  the  special values recognised are case
             insensitive, however, note  that  abbreviations  are provided for
             many of the options.                                             
                                                                              
        * *CLEAR - clears the  commands  executed  at  this  invocation of the
             command line.                                                    
                                                                              
        * *FIRST - Retrieves a previously  executed  command from the stack of
             commands  in  chronological  order  (from  the  earliest  command
             forwards).  This special value  allows  a  generic  pattern to be
             specified which will be used to find the required command.       
                                                                              
             * Synonyms - '*F' or '>'                                         
                                                                              
             The processing program retrieves previous commands in chronologi-
               cal order and examines the  starting portion of the command for
               a match with the specified pattern.                            
             To select a matching command  other  than  the  first 'n' matches
               specify 'n' as part of the search pattern, as follows:         
                                                                              
             ===> >3 wrk                                                      
                                                                              
             This instructs the processing  program  to find the third command
               which starts with 'wrk'.  That command is returned:            
                                                                              
             ===> wrksbsjob qbatch                                            
                                                                              
        * *LAST - Retrieves a previously  executed  command  from the stack of
             commands in reverse chronological  order (from the latest command
             backwards).  This special value  allows  a  generic pattern to be
             specified which will be used to find the required command.       
                                                                              
             * Synonyms - '*L' or '<'                                         
                                                                              
             The processing program  retrieves  previous  commands  in rever +
               chronological order and examines  the  starting  portion of the 
               command for a match with the specified pattern.                 
                                                                               
             To select a matching command  other  than  the  first 'n' matches 
               specify 'n' as part of the search pattern, as follows:          
                                                                               
             ===> < 2 str                                                      
                                                                               
             This instructs the processing  program to find the second command 
               which starts with 'str'.  That command is returned:             
                                                                               
             ===> strdbg uuafefr updprod(*yes)                                 
                                                                               
        * *SCANF  -  Scan  for  first occurrence.  This special value allows a 
             scan string to be specified.  In this case the processing program 
             scans previous commands in chronological order (from the earliest 
             command) for the search pattern.                                  
                                                                             + 
             * Synonyms - '*SF' or '>>'                                        
                                                                               
             The processing program retrieves previous commands in chronologi- 
               cal  order and scans the entire command string for a match with 
               the specified pattern.                                          
                                                                               
             To select a matching command  other  than  the  first 'n' matches 
               specify 'n' as part of the search pattern, as follows:          
                                                                               
             ===> >> 2 uuae                                                    
                                                                               
             This instructs the processing  program to find the second command 
               string which contains 'uuae'.  That command is returned:        
                                                                               
             ===> strseu mylib/qrpgsrc srcmbr(uuaexfr)                         
                            cursor position - x                                
                                                                               
        * *SCANL - Scan for last occurrence.  This special value allows a sc + 
             string  to  be  specified.  In  this  case the processing program 
             scans  previous commands in reverse chronological order (from the 
             most recent command) for the search pattern.                      
                                                                               
             * Synonyms - '*SL' or '<<'                                        
                                                                               
             The  processing  program  retrieves  previous commands in reverse 
               chronological  order  and scans the entire command string for a 
               match with the specified pattern.                               
                                                                               
             To select a matching command  other  than  the  first 'n' matches 
               specify 'n' as part of the search pattern, as follows:          
                                                                               
             ===> << 1 uubd                                                    
                                                                               
             This  instructs  the processing program to find the first command 
               string which contains 'uubd'.  That command is returned:        
                                                                               
             ===> strseu mylib/qrpgsrc srcmbr(uubde1r)                         
                                                                               
        * *TAG x  -  When  added to the front of a command, it will cause that 
             command  to  be  tagged  on  the command stack with the character 
             entered  in  place of the x . This is useful when commands run at 
             different times may need to be easily grouped together.           
                                                                               
             * Synonyms - '*T' or '|'                                          
                                                                               
             The tagging is done  by  adding  the comment /* Tag = x */ to the 
               command.  Such  tagged  commands can then be manipulated by the 
                *EXECUTE , *PROMPT and *RTV commands.                          
                                                                               
             ===> *TAG ] strdbg uuabefr updprod(*yes)                          
                                                                               
             The STRDBG will  be  executed,  but on the command stack  will be 
               stored:                                                         
             ===> strdbg uuabefr updprod(*yes)   /* Tag = ] */                
                                                                              
        * *EXECUTE x - This will run  all  the  commands which have previously
             been tagged with the character x .                               
                                                                              
             * Synonyms - '*E'                                                
                                                                              
             If the following commands have been tagged with a Y :            
                                                                              
             ===> strdbg uuabefr updprod(*yes)   /* Tag = Y */                
                  addbkp 10800 pgmvar(w0rtn)   /* Tag = Y */                  
                  addbkp 24900 pgmvar(w0rtn)   /* Tag = Y */                  
                                                                              
             When the following command is entered, all three commands will be
               executed.                                                      
                                                                              
             ===> *E ]                                                        
        * *PROMPT x - This will prompt  all the commands which have previously 
             been tagged with the character x .                                
                                                                               
             * Synonyms - '*P'                                                 
                                                                               
             If the following commands have been tagged with a Y :             
                                                                               
             ===> strdbg uuabefr updprod(*yes)   /* Tag = Y */                 
                  addbkp 10800 pgmvar(w0rtn)   /* Tag = Y */                   
                  addbkp 24900 pgmvar(w0rtn)   /* Tag = Y */                   
                                                                               
             When the following command is entered, all three commands will be 
               prompted and then executed.                                     
                                                                               
             ===> *P ]                                                         
                                                                               
        * *RTV x -  his will retrieve all  the  commands which have previously 
             been tagged with the character x .                              + 
                                                                              
            * Synonyms - '*R'                                                 
                                                                              
            If the following commands have been tagged with a Y :             
                                                                              
            ===> strdbg uuabefr updprod(*yes)   /* Tag = Y */                 
                 addbkp 10800 pgmvar(w0rtn)   /* Tag = Y */                   
                 addbkp 24900 pgmvar(w0rtn)   /* Tag = Y */                   
                                                                              
            When a *RTV Y is entered,  the  following  command string will be 
              built and returned.                                             
                                                                              
            ===> strdbg uuabefr updprod(*yes);addbkp 10800 pgmvar(w0rtn);     
                 addbkp 24900 pgmvar(w0rtn)                                   
                                                                              
       * *TAG :: - This  special form of tagging will append the current time 
            to the command instead of a tag character.                        
                                                                              
             * Synonyms - '*T' or '|'                                         
                                                                              
             The time is  appended by adding the comment /* Time = 99:99:99 */
               to the command.                                                
                                                                              
             ===> *TAG :: wrkactjob                                           
                                                                              
             The WRKACTJOB will  be executed, but on the command stack will be
               stored:                                                        
                                                                              
             ===> wrkactjob   /* Time = 12:34:56 */                           
                                                                              
             * *Note: Commands tagged  with  the time cannot be manipulated by
               the previous tagging commands.                                 
                                                                              
        * *PAGERIGHT nnn  -  Will  move the command currently displayed on the
             command line nnn spaces to the right.  If a value is not entered,
             one  complete  page  to the right is performed.  Alternately, t +
                                                                              
             special  value * can be entered and the command will be paged all 
             the way to the end.                                               
                                                                               
             * Synonyms - '*PR' or '->'                                        
                                                                               
             * *Note:  *PAGERIGHT  can  only  be  done on a previously entered 
               command which  has be retrieved or redisplayed onto the command 
               line.  It cannot be used on a command currently being entered.  
                                                                               
             * *Note:  When  the  command  is  paged, any changes made are ig- 
               nored.  However,  changes  made after paging has completed will 
               be used.                                                        
                                                                               
        * *PAGELEFT nnn   Will  move  the  command  currently displayed on the 
             command line nnn spaces to the left.  If no value is entered, one 
             complete page to the left is performed.  Alternately, the special 
             value  * can be entered and the command will be paged all the way 
             to the beginning.                                               + 
                                                                              
            * Synonyms - '*PL' or '<-'                                        
                                                                              
            * *Note:  *PAGELEFT  can  only  be  done  on a previously entered 
              command which  has be retrieved or redisplayed onto the command 
              line.  It cannot be used on a command currently being entered.  
                                                                              
            * *Note:  When  the  command  is  paged, any changes made are ig- 
              nored.  However,  changes  made after paging has completed will 
              be used.                                                        
                                                                              
       * *SAVE nnnnnnnnnn -  Saves the command stack, where nnnnnnnnnn is the 
            name of the library in which the stack is saved.                  
                                                                              
            * *Note : The  library  which is used cannot be QTEMP as a perma- 
              nent library is required.                                       
                                                                              
       * *RESTORE nnnnnnnnnn - Restores the command stack previously saved  + 
             library nnnnnnnnnn.                                               
                                                                               
             * *Note : A  saved command stack can only be restored once as its 
               permanent version is deleted after the restore has completed.   
                                                                               
        * ';' - A  semicolon can be used to separate multiple commands entered 
             onto the command line.                                            
                                                                               
             ===> wrksbmjob;wrkactjob;wrksplf                                  
                                                                               
             When ENTER  is  pressed,  WRKSBMJOB  will  be  executed,  then  a 
               WRKACTJOB will be done, followed by a WRKSPLF .                 
                                                                               
             Alternately, F4  can  be  pressed  and  all  the commands will be 
               prompted.                                                       
                                                                               
             * *Note: The  commands  are  entered  separately onto the comamnd 
               stack as each is executed.                                    + 
                                                                               
                                                                              
        * '-' - A minus sign  signals  to  the  processing  program  that  the
             command is to be run  but not logged to the sequence of commands.
             This is useful to prevent the sequence from being clogged up with
             commonly used commands you  will  never  want  to retrieve later,
             such as 'wrkjob', 'dspmsg', etc.                                 
                                                                              
             ===> -wrkjob                                                     
                                                                              
        * '+' - A plus sign signals to the processing program that the command
             is to be logged to the sequence of commands but not run.  This is
             useful to prepare a  complicated  command  which  you are not yet
             ready to execute.  For example:                                  
                                                                              
             ===> +cpyf fromfile(myfile) tofile(yourfile)                     
                                                                              
             This partially complete command string can be retrieved later and
               completed, possibly after some intervening command has provid +
               some necessary additional details relating to the copy.        
                                                                              
             * Note  :  The + or - options can be used in conjunction with the
               TAG,  *RTV  ,  *EXECUTE  or  *PROMPT  commands.  When  entering
               multiple commands separated by the ;  , only one + or - need be
               entered at the beginning.                                      
                                                                              
        Notes on searching                                                    
                                                                              
        * Note :  Because of the  ability to specify some number of matches to
             omit during the search  you must take special action when search-
             ing for numeric patterns.  If  a  number is being scanned for you
             must always specify which occurrence is required.  Thus:         
                                                                              
             ===> >>1 577                                                     
                                                                              
        This search  pattern will find the first occurrence of '577'   in prev
             ous command strings.                                            +
      * Note :  Instead of a search  string  a  * can be entered.  This will
           repeat the last search performed. eg.                            
                                                                            
           ===> << *                                                        
                                                                            
           This will repeat the last  scan  entered,  checking  the  request
           in reverse chronological order.  Alternately, you could enter:   
                                                                            
           ===> >> *                                                        
                                                                            
           This repeats the same scan, but this time in chronological order.
                                                                            
      * Note :  Only one retrieve  or  scan  can  be remembered.  This means
           that the last scan  and retrieve request cannot both be recalled.
           The * also cannot be used  to  change  a retrieve into a scan, or
           visa versa.                                                      
        * Note :  Only the first  999  characters  in  the  command string are 
             scanned.                                                          
                                                                               
        * Note :  The cursor is  positioned to the start of the search pattern 
             for added convenience, unless  the  pattern  was found beyond the 
             end of the display length, in which case the cursor is set at the 
             beginning of the command string.                                  
                                                                               
        * Note : When specifying a search  pattern do not add a '*' to the end 
             of the pattern.  The  processing program will automatically treat 
             the string as generic.  You  may, however, specify a wild charac- 
             ter of '?' in any position.  Thus:                                
                                                                               
             ===> >uu??xfr                                                     
                                                                               
             This search pattern will find the first occurrence of ('uu' 'some 
             thing'  'something'  'xfr') in previous command strings and posi- 
             tion the cursor to the first 'u' if a match is found..          + 

        Notes on tagging                                                      
                                                                              
        * Note :  When tagged  commands  are  executed, prompted or retrieved,
             the tagging characters are  removed.  However, a *TAG can be used
             in conjunction with any on these to re-tag the commands.         
                                                                              
            If the following commands have been tagged with a Y :             
                                                                              
            ===> strdbg uuabefr updprod(*yes)   /* Tag = Y */                 
                 addbkp 10800 pgmvar(w0rtn)   /* Tag = Y */                   
                 addbkp 24900 pgmvar(w0rtn)   /* Tag = Y */                   
                                                                              
            If a *E Y is performed, the command string built and executed is: 
                                                                              
            ===> strdbg uuabefr updprod(*yes);addbkp 10800 pgmvar(w0rtn);     
                 addbkp 24900 pgmvar(w0rtn)                                   
            Alternately a *E Y *T Z will build and execute the command string:
                                                                              
            ===> *TAG Z strdbg uuabefr updprod(*yes);addbkp 10800 pgmvar(w0rtn
                 addbkp 24900 pgmvar(w0rtn)                                   
                                                                              
            This will tag the commands with a Z as they are run.              
                                                                              
        * Note :  When tagged commands are executed, prompted or retrieved, if
             no tag character is specified, all previously tagged commands are
             processed.                                                       
                                                                              
             If the following commands have been tagged:                      
                                                                              
             ===> wrksplf   /* Tag = @ */                                     
                  dspjob   /* Tag = Ñ */                                      
                  wrksbmjob   /* Tag = % */                                   
                                                                              
             If a *R is performed, the command string built and returned is: +
                                                                              
            ===> wrksplf;dspjob;wrksbmjob                                     
                                                                              
       * *Note:  A *TAG x can be entered before the command list, causing all 
            the all the commands entered to be tagged with x .                
                                                                              
           ===> *TAG ] wrksbmjob;wrkactjob;wrksplf                            
                                                                              
           Will result in:                                                    
                                                                              
           ===> wrksbmjob   /* Tag = ] */                                     
                wrkactjob   /* Tag = ] */                                     
                wrksplf   /* Tag = ] */                                       
                                                                              
                                                                              
  Note the following restrictions:                                            
                                                                              
  Command entry is only permitted if  CMDENT(*YES) is specified on the 'Go  + 
 menu' command.                                                                
                                                                               
    Direct transfer between menus is  only  permitted  if MNUENT(*YES) is spec-
 ified on the 'Go to menu' command.                                            

04-                                                                            
         HELP TEXT DISPLAY                                                     
                                                                               
   Help text  is  available  for most options. To display the help text for an 
option, move the cursor to the option line and press HELP.                     
                                                                               
   The  menu  display  program provides three types of help text, depending on 
where the cursor is when you press the HELP key.                               
                                                                               
  - If the cursor is in the request  data  field,  the  Help text for the menu 
    program itself will be displayed (i.e. this document).                     
                                                                               
  - If the  cursor is on the menu title line, the help text for the whole menu 
    will be displayed (providing that it has been set up correctly.)           
                                                                               
  - If the cursor is on one of the option lines of the menu, the help text for 
    the individual menu option will be displayed (providing it has been set up 
    correctly).                                                              + 

 05-                                                                           
          CONFIRMATION PROMPT                                                  
                                                                               
    Certain  options  require  confirmation:  when such an option is selected a
 prompt Confirm   will  be displayed;  this requires you to type 'Y' or  N , as
 appropriate, to confirm/cancel execution of the option.                       


(C)2.000-2.012 Rafael San José Tovar (trabajando en SEUR Sevilla)