/* fopen.macro 11/02/03  Stan Sieler (sieler@gmail.com)                                                                             
/* Copyright (c) 2008 Allegro Consultants, Inc.                                                                                     
/* 2008-11-20 added CM fopen                                                                                                        
                                                                                                                                    
macro get_db_32bits:int (dboff:int) {                                                                                               
   loc half1 [db dboff];                                                                                                            
   loc half2 [db dboff + 1];                                                                                                        
   return s32 ((u32(half1) << #16) bor u32 (half2));                                                                                
   }                                                                                                                                
                                                                                                                                    
macro get_db_filename:str (dboff:int, halfs:int) {                                                                                  
   loc rslt "";                                                                                                                     
   loc highchar str (ascc (#126), 2, 1);                                                                                            
                                                                                                                                    
   while halfs > 0 do                                                                                                               
      {                                                                                                                             
      loc chars ascc ([db dboff]);                                                                                                  
      loc lchar str (chars + " ", 1, 1);                                                                                            
      loc rchar str (chars + "  ", 2, 1);                                                                                           
                                                                                                                                    
      if (lchar <= " ") or (lchar > highchar) then                                                                                  
         return rslt;                                                                                                               
                                                                                                                                    
      if (rchar <= " ") or (rchar > highchar) then                                                                                  
         {                                                                                                                          
         loc rslt rslt + lchar;                                                                                                     
         return rslt;                                                                                                               
         };                                                                                                                         
                                                                                                                                    
      loc rslt rslt + chars;                                                                                                        
                                                                                                                                    
      loc halfs halfs - 1;                                                                                                          
      loc dboff dboff + 1;                                                                                                          
      };                                                                                                                            
                                                                                                                                    
   return rslt;                                                                                                                     
   }                                                                                                                                
                                                                                                                                    
macro get_db_string:str (dboff:int, halfs:int) {                                                                                    
   loc rslt "";                                                                                                                     
   while halfs > 0 do                                                                                                               
      {                                                                                                                             
      loc rslt rslt + ascc ([db dboff]);                                                                                            
      loc halfs halfs - 1;                                                                                                          
      loc dboff dboff + 1;                                                                                                          
      };                                                                                                                            
                                                                                                                                    
   return rslt;                                                                                                                     
   }                                                                                                                                
                                                                                                                                    
macro show_if_mask_bit (mask, bitnum, labl, val) {                                                                                  
   if bitx (mask, bitnum, 1) = 1 then                                                                                               
      wl "   ", labl, ": ", val:"#W6", " (", val:"%", ")";                                                                          
   }                                                                                                                                
                                                                                                                                    
macro show_if_non_0 (xstr, val) {                                                                                                   
   if val <> 0 then wl "   ", xstr, ": ", val:"#";                                                                                  
   }                                                                                                                                
                                                                                                                                    
macro show_if_non_nil (xstr, paddr) {                                                                                               
   if lptr (paddr) <> 0.0 then                                                                                                      
      wl "   ", xstr, ": ",                                                                                                         
           ascc ([paddr])+ascc([paddr+4])+ascc([paddr+$8])+                                                                         
           ascc ([paddr+#12]); }                                                                                                    
                                                                                                                                    
macro show_cm_fopen {                                                                                                               
   loc faddr u16([q-%22])/2;                                                                                                        
   loc mask [q-4];                                                                                                                  
   if bitx (mask, 3, 1) = 1 then                                                                                                    
      wl "   filename: ", get_db_filename (faddr, #14);                                                                             
                                                                                                                                    
   show_if_mask_bit (mask,  4, "fops        ", [q-%21]);                                                                            
   show_if_mask_bit (mask,  5, "aops        ", [q-%20]);                                                                            
   show_if_mask_bit (mask,  6, "recsize     ", [q-%17]);                                                                            
   show_if_mask_bit (mask,  7, "device @    ", [q-%16]);                                                                            
   show_if_mask_bit (mask, #8, "formmsg @   ", [q-%15]);                                                                            
   show_if_mask_bit (mask, #9, "userlabels  ", [q-%14]);                                                                            
   show_if_mask_bit (mask,#10, "blockfactor ", [q-%13]);                                                                            
   show_if_mask_bit (mask,#11, "# buffers   ", [q-%12]);                                                                            
   show_if_mask_bit (mask,#12, "filesize    ", get_db_32bits (q-%12));                                                              
   show_if_mask_bit (mask,#13, "# extents   ", [q-%7]);                                                                             
   show_if_mask_bit (mask,#14, "init #exts  ", [q-%6]);                                                                             
   show_if_mask_bit (mask,#15, "filecode    ", [q-%5]);                                                                             
   }                                                                                                                                
                                                                                                                                    
macro is_valid_mpe_filename_char (nc) {      /* does not include lockword '/'                                                       
   if (nc >= u16 ('A')) and (nc <= u16 ('Z')) then return true;                                                                     
   if (nc >= u16 ('a')) and (nc <= u16 ('z')) then return true;                                                                     
   if (nc >= u16 ('0')) and (nc <= u16 ('9')) then return true;                                                                     
   if nc = u16 ('.') then return true;                                                                                              
   return false;                                                                                                                    
   }                                                                                                                                
                                                                                                                                    
macro find_mpe_filename_len (naddr) {                                                                                               
   loc nlen = 0;                                                                                                                    
   loc nc [byte naddr];                                                                                                             
   while is_valid_mpe_filename_char (nc) and (nlen < #37) do {                                                                      
      loc nlen nlen + 1;                                                                                                            
      loc naddr naddr + 1;                                                                                                          
      loc nc [byte naddr];                                                                                                          
      };                                                                                                                            
   return nlen;                                                                                                                     
   }                                                                                                                                
                                                                                                                                    
macro show_nm_fopen {                                                                                                               
   loc nlen find_mpe_filename_len (r26);                                                                                            
   if (nlen <= 0) then loc nlen = #16;                                                                                              
   loc lfilename strextract (r26, nlen);                                                                                            
   wl "   filename: ", lfilename;                                                                                                   
   wl "   fops: ", r25:"%", "; aops: ", r24:"%";                                                                                    
   wl "   recsize: ", r23:"#";                                                                                                      
   show_if_non_nil ("device     ", [sp-$34]);                                                                                       
   show_if_non_nil ("formmsg    ", [sp-$38]);                                                                                       
   show_if_non_0 ("userlabels ", [s16 sp-$3a]);                                                                                     
   show_if_non_0 ("blockfactor", [s16 sp-$3e]);                                                                                     
   show_if_non_0 ("numbuffers ", [s16 sp-$42]);                                                                                     
   show_if_non_0 ("filesize   ", [    sp-$48]);                                                                                     
   show_if_non_0 ("numextents ", [s16 sp-$4a]);                                                                                     
   show_if_non_0 ("initextents", [s16 sp-$4e]);                                                                                     
   show_if_non_0 ("filecode   ", [s16 sp-$52]);                                                                                     
   }                                                                                                                                
                                                                                                                                    
macro b_cm_fopen {                                                                                                                  
   loc my__old_mode mode;                                                                                                           
   cm;                                                                                                                              
   ignore quiet; b ?FOPEN,,,show_cm_fopen;                                                                                          
   if my__old_mode = 'nm' then nm;                                                                                                  
   }                                                                                                                                
                                                                                                                                    
macro b_nm_fopen {                                                                                                                  
   loc my__old_mode mode;                                                                                                           
   nm;                                                                                                                              
   ignore quiet; b FOPEN,,,show_nm_fopen;                                                                                           
   if my__old_mode = 'cm' then cm;                                                                                                  
   }                                                                                                                                
                                                                                                                                    
wl;                                                                                                                                 
wl "To arm the NM FOPEN breakpoint, enter: b_nm_fopen";                                                                             
wl "To arm the CM FOPEN breakpoint, enter: b_cm_fopen";