?? RIGHT := 110 ??                                                                                            
?? NEWTITLE := 'NOS/VE Dump Analyzer : Change Processor Command' ??                                           
MODULE dum$change_pr_command;                                                                                 
                                                                                                              
{ PURPOSE:                                                                                                    
{   This module contains the code for the change_processor command.                                           
                                                                                                              
?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??                                      
?? PUSH (LISTEXT := ON) ??                                                                                    
*copyc due$exception_condition_codes                                                                          
?? POP ??                                                                                                     
*copyc dup$evaluate_parameters                                                                                
*copyc osp$append_status_integer                                                                              
*copyc osp$set_status_abnormal                                                                                
?? EJECT ??                                                                                                   
*copyc duv$dump_environment_p                                                                                 
*copyc duv$execution_environment                                                                              
?? OLDTITLE ??                                                                                                
?? NEWTITLE := 'dup$change_pr_command', EJECT ??                                                              
                                                                                                              
{ PURPOSE:                                                                                                    
{   This procedure changes values related to the processor.                                                   
                                                                                                              
  PROCEDURE [XDCL] dup$change_pr_command                                                                      
    (    parameter_list: clt$parameter_list;                                                                  
     VAR status: ost$status);                                                                                 
                                                                                                              
{ PROCEDURE change_processor, chapr, chap (                                                                   
{   job_process_state, jps: integer 0..0ffffffff(16)                                                          
{   monitor_process_state, mps: integer 0..0ffffffff(16)                                                      
{   page_size_mask, psm: integer 0..7f(16)                                                                    
{   page_table_address, pta: integer 0..0ffffffff(16)                                                         
{   page_table_length, ptl: integer 0..03fff(16)                                                              
{   processor, p: any of                                                                                      
{       key                                                                                                   
{         (all a)                                                                                             
{       keyend                                                                                                
{       integer 0..3                                                                                          
{     anyend = 0                                                                                              
{   status)                                                                                                   
                                                                                                              
?? PUSH (LISTEXT := ON) ??                                                                                    
?? FMT (FORMAT := OFF) ??                                                                                     
  VAR                                                                                                         
    pdt: [STATIC, READ, cls$declaration_section] record                                                       
      header: clt$pdt_header,                                                                                 
      names: array [1 .. 13] of clt$pdt_parameter_name,                                                       
      parameters: array [1 .. 7] of clt$pdt_parameter,                                                        
      type1: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
      recend,                                                                                                 
      type2: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
      recend,                                                                                                 
      type3: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
      recend,                                                                                                 
      type4: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
      recend,                                                                                                 
      type5: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$integer_type_qualifier,                                                                
      recend,                                                                                                 
      type6: record                                                                                           
        header: clt$type_specification_header,                                                                
        qualifier: clt$union_type_qualifier,                                                                  
        type_size_1: clt$type_specification_size,                                                             
        element_type_spec_1: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$keyword_type_qualifier,                                                              
          keyword_specs: array [1 .. 2] of clt$keyword_specification,                                         
        recend,                                                                                               
        type_size_2: clt$type_specification_size,                                                             
        element_type_spec_2: record                                                                           
          header: clt$type_specification_header,                                                              
          qualifier: clt$integer_type_qualifier,                                                              
        recend,                                                                                               
        default_value: string (1),                                                                            
      recend,                                                                                                 
      type7: record                                                                                           
        header: clt$type_specification_header,                                                                
      recend,                                                                                                 
    recend := [                                                                                               
    [1,                                                                                                       
    [89, 6, 12, 10, 1, 32, 651],                                                                              
    clc$command, 13, 7, 0, 0, 0, 0, 7, ''], [                                                                 
    ['JOB_PROCESS_STATE              ',clc$nominal_entry, 1],                                                 
    ['JPS                            ',clc$abbreviation_entry, 1],                                            
    ['MONITOR_PROCESS_STATE          ',clc$nominal_entry, 2],                                                 
    ['MPS                            ',clc$abbreviation_entry, 2],                                            
    ['P                              ',clc$abbreviation_entry, 6],                                            
    ['PAGE_SIZE_MASK                 ',clc$nominal_entry, 3],                                                 
    ['PAGE_TABLE_ADDRESS             ',clc$nominal_entry, 4],                                                 
    ['PAGE_TABLE_LENGTH              ',clc$nominal_entry, 5],                                                 
    ['PROCESSOR                      ',clc$nominal_entry, 6],                                                 
    ['PSM                            ',clc$abbreviation_entry, 3],                                            
    ['PTA                            ',clc$abbreviation_entry, 4],                                            
    ['PTL                            ',clc$abbreviation_entry, 5],                                            
    ['STATUS                         ',clc$nominal_entry, 7]],                                                
    [                                                                                                         
{ PARAMETER 1                                                                                                 
    [1, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],                               
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter, 
  0, 0],                                                                                                      
{ PARAMETER 2                                                                                                 
    [3, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],                               
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter, 
  0, 0],                                                                                                      
{ PARAMETER 3                                                                                                 
    [6, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],                               
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter, 
  0, 0],                                                                                                      
{ PARAMETER 4                                                                                                 
    [7, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],                               
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter, 
  0, 0],                                                                                                      
{ PARAMETER 5                                                                                                 
    [8, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],                               
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20, clc$optional_parameter, 
  0, 0],                                                                                                      
{ PARAMETER 6                                                                                                 
    [9, clc$normal_usage_entry, clc$non_secure_parameter,                                                     
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],                               
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 121,                        
  clc$optional_default_parameter, 0, 1],                                                                      
{ PARAMETER 7                                                                                                 
    [13, clc$normal_usage_entry, clc$non_secure_parameter,                                                    
    $clt$parameter_spec_methods[clc$specify_by_name],                                                         
    clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,                      
  clc$optional_parameter, 0, 0]],                                                                             
{ PARAMETER 1                                                                                                 
    [[1, 0, clc$integer_type], [0, 0ffffffff(16), 10]],                                                       
{ PARAMETER 2                                                                                                 
    [[1, 0, clc$integer_type], [0, 0ffffffff(16), 10]],                                                       
{ PARAMETER 3                                                                                                 
    [[1, 0, clc$integer_type], [0, 7f(16), 10]],                                                              
{ PARAMETER 4                                                                                                 
    [[1, 0, clc$integer_type], [0, 0ffffffff(16), 10]],                                                       
{ PARAMETER 5                                                                                                 
    [[1, 0, clc$integer_type], [0, 03fff(16), 10]],                                                           
{ PARAMETER 6                                                                                                 
    [[1, 0, clc$union_type], [[clc$integer_type, clc$keyword_type],                                           
    FALSE, 2],                                                                                                
    81, [[1, 0, clc$keyword_type], [2], [                                                                     
      ['A                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],                 
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1]]                      
      ],                                                                                                      
    20, [[1, 0, clc$integer_type], [0, 3, 10]]                                                                
    ,                                                                                                         
    '0'],                                                                                                     
{ PARAMETER 7                                                                                                 
    [[1, 0, clc$status_type]]];                                                                               
?? FMT (FORMAT := ON) ??                                                                                      
?? POP ??                                                                                                     
                                                                                                              
    CONST                                                                                                     
      p$job_process_state = 1,                                                                                
      p$monitor_process_state = 2,                                                                            
      p$page_size_mask = 3,                                                                                   
      p$page_table_address = 4,                                                                               
      p$page_table_length = 5,                                                                                
      p$processor = 6,                                                                                        
      p$status = 7;                                                                                           
                                                                                                              
    VAR                                                                                                       
      pvt: array [1 .. 7] of clt$parameter_value;                                                             
                                                                                                              
    VAR                                                                                                       
      default_list: ARRAY [1 .. 1] OF dut$default_change_list_entry,                                          
      ending_processor_index: 0 .. duc$de_maximum_processors,                                                 
      mask_index_1: 0 .. 14,                                                                                  
      mask_index_2: 0 .. 14,                                                                                  
      processor_index: 0 .. duc$de_maximum_processors,                                                        
      psm: dut$ee_psm_value,                                                                                  
      pta: dut$ee_pta_value,                                                                                  
      ptl: dut$ee_ptl_value,                                                                                  
      starting_processor_index: 0 .. duc$de_maximum_processors;                                               
                                                                                                              
    status.normal := TRUE;                                                                                    
                                                                                                              
    { Change the default value for the PROCESSOR parameter.                                                   
                                                                                                              
    default_list [1].default_name := duc$dp_processor;                                                        
    default_list [1].number := p$processor;                                                                   
    dup$evaluate_parameters (parameter_list, default_list, #SEQ (pdt), ^pvt, status);                         
    IF NOT status.normal THEN                                                                                 
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
                                                                                                              
    IF duv$dump_environment_p = NIL THEN                                                                      
      osp$set_status_abnormal (duc$dump_analyzer_id, due$no_restart_file, '', status);                        
      RETURN;  {---->                                                                                         
    IFEND;                                                                                                    
                                                                                                              
    { Determine the starting and ending processor indexes.                                                    
                                                                                                              
    IF pvt [p$processor].value^.kind = clc$keyword THEN                                                       
      starting_processor_index := 0;                                                                          
      ending_processor_index := duc$de_maximum_processors;                                                    
    ELSE                                                                                                      
      starting_processor_index := pvt [p$processor].value^.integer_value.value;                               
      ending_processor_index := starting_processor_index;                                                     
    IFEND;                                                                                                    
                                                                                                              
    { Change the job_process_state value.                                                                     
                                                                                                              
    IF pvt [p$job_process_state].specified THEN                                                               
      FOR processor_index := starting_processor_index TO ending_processor_index DO                            
        duv$execution_environment.processor_registers [processor_index].available := TRUE;                    
        duv$execution_environment.processor_registers [processor_index].job_process_state :=                  
              pvt [p$job_process_state].value^.integer_value.value;                                           
      FOREND;                                                                                                 
    IFEND;                                                                                                    
                                                                                                              
    { Change the monitor_process_state value.                                                                 
                                                                                                              
    IF pvt [p$monitor_process_state].specified THEN                                                           
      FOR processor_index := starting_processor_index TO ending_processor_index DO                            
        duv$execution_environment.processor_registers [processor_index].available := TRUE;                    
        duv$execution_environment.processor_registers [processor_index].monitor_process_state :=              
              pvt [p$monitor_process_state].value^.integer_value.value;                                       
      FOREND;                                                                                                 
    IFEND;                                                                                                    
                                                                                                              
    { Change the page_size_mask value.                                                                        
                                                                                                              
    IF pvt [p$page_size_mask].specified THEN                                                                  
      psm.value := pvt [p$page_size_mask].value^.integer_value.value;                                         
      FOR mask_index_1 := 0 TO 6 DO                                                                           
        IF NOT (mask_index_1 IN psm.psm) THEN                                                                 
          FOR mask_index_2 := (mask_index_1 + 1) TO 6 DO                                                      
            IF mask_index_2 IN psm.psm THEN                                                                   
              osp$set_status_abnormal (duc$dump_analyzer_id, due$invalid_mask, 'page_size_mask', status);     
              osp$append_status_integer (osc$status_parameter_delimiter, psm.value, 16, TRUE, status);        
              RETURN;  {---->                                                                                 
            IFEND;                                                                                            
          FOREND;                                                                                             
        IFEND;                                                                                                
      FOREND;                                                                                                 
      FOR processor_index := starting_processor_index TO ending_processor_index DO                            
        duv$execution_environment.processor_registers [processor_index].available := TRUE;                    
        duv$execution_environment.processor_registers [processor_index].page_size_mask := psm.psm;            
      FOREND;                                                                                                 
    IFEND;                                                                                                    
                                                                                                              
    { Change the page_table_address value.                                                                    
                                                                                                              
    IF pvt [p$page_table_address].specified THEN                                                              
      pta.value := pvt [p$page_table_address].value^.integer_value.value;                                     
      FOR processor_index := starting_processor_index TO ending_processor_index DO                            
        duv$execution_environment.processor_registers [processor_index].available := TRUE;                    
        duv$execution_environment.processor_registers [processor_index].page_table_address := pta.pta;        
      FOREND;                                                                                                 
    IFEND;                                                                                                    
                                                                                                              
    { Change the page_table_length value.                                                                     
                                                                                                              
    IF pvt [p$page_table_length].specified THEN                                                               
      ptl.value := pvt [p$page_table_length].value^.integer_value.value;                                      
      FOR mask_index_1 := 0 TO 13 DO                                                                          
        IF mask_index_1 IN ptl.ptl THEN                                                                       
          FOR mask_index_2 := (mask_index_1 + 1) TO 13 DO                                                     
            IF NOT (mask_index_2 IN ptl.ptl) THEN                                                             
              osp$set_status_abnormal (duc$dump_analyzer_id, due$invalid_mask, 'page_table_length', status);  
              osp$append_status_integer (osc$status_parameter_delimiter, ptl.value, 16, TRUE, status);        
              RETURN;  {---->                                                                                 
            IFEND;                                                                                            
          FOREND;                                                                                             
        IFEND;                                                                                                
      FOREND;                                                                                                 
      FOR processor_index := starting_processor_index TO ending_processor_index DO                            
        duv$execution_environment.processor_registers [processor_index].available := TRUE;                    
        duv$execution_environment.processor_registers [processor_index].page_table_length := ptl.ptl;         
      FOREND;                                                                                                 
    IFEND;                                                                                                    
                                                                                                              
  PROCEND dup$change_pr_command;                                                                              
MODEND dum$change_pr_command;                                                                                 
