intprint.c

中断列表(5) : 工具程序 265K

	 summary_line[1] = s[5] ;
	 summary_line[2] = s[6] ;
	 }
      else if (s[0] == 'M' && s[1] == 'E')
	 {
	 memcpy(summary_line+1,s+4,4) ;
	 if (s[8] == 'h' && s[9] == ':')
	    memcpy(summary_line+5,s+10,4) ;
	 else
	    memcpy(summary_line+5,s+8,4) ;
	 }
      else if (s[0] == 'I' && s[1] == '2')
	 {
	 summary_line[1] = s[4] ;	/* output bus address */
	 summary_line[2] = s[5] ;
	 if (s[7] == '/')
	    {
	    summary_line[4] = s[8] ;
	    summary_line[5] = s[9] ;
	    if (s[10] != 'h')
	       {
	       summary_line[7] = s[10] ;
	       summary_line[8] = s[11] ;
	       }
	    else if (s[11] == '/')
	       {
	       summary_line[7] = s[12] ;
	       summary_line[8] = s[13] ;
	       }
	    }
	 }
      len = 10 ;
      if (page_numbers)
	 {
	 itoa(pages_printed,num,10) ;
	 numlen = strlen(num) ;
	 for (i = numlen ; i < 3 ; i++)
	    summary_line[len++] = ' ' ;
	 memcpy(summary_line+len,num,numlen) ;
	 len += numlen ;
	 summary_line[len++] = ' ' ;
	 }
      s = buffer[line] + 7 ;	/* find function description */
      if (!is_INT_entry)
	 {
	 while (*s && !isspace(*s))
	    s++ ;
	 s++ ;
	 }
      if (*s && *s != '-')	/* does the heading contain flags? */
	 {
	 while (*s && !isspace(*s))
	    summary_line[len++] = *s++ ;
	 summary_line[len++] = '>' ;
	 summary_line[len++] = ' ' ;
	 while (*s && *s != '-')
	    s++ ;
	 }
      while (*s && !isspace(*s))
	 s++ ;
      while (*s && isspace(*s))
	 s++ ;
      max_descrip = (page_width > sizeof(summary_line)-1)
		    ? sizeof(summary_line)-1
		    : page_width ;
      while (len < max_descrip && *s)
	 summary_line[len++] = *s++ ;
      summary_line[len] = '\0' ;
      summary_line_len = len ;
      return 1 ;
      }
   else
      return 0 ;
}

/***********************************************/

void start_format(line)
char *line ;
{
   indent_line(formats) ;
   (*printer->put_line)(formats,79) ;
   newline(formats) ;
   indent_line(formats) ;
   ip_puts(summary_line,formats) ;
   newline(formats) ;
   indent_line(formats) ;
   ip_putc('\t',formats) ;
   ip_puts(line+10,formats) ;
   newline(formats) ;
   echo_format = TRUE ;
}

/***********************************************/

void show_offset(line,fp)
int line ;
IP_FILE *fp ;
{
   char offset_string[12] ;
   int len ;
   
   ultoa(line_offsets[line],offset_string,16) ;
   len = strlen(offset_string) ;
   ip_write("00000000",8-len,fp) ;
   ip_write(offset_string,len,fp) ;
}

/***********************************************/

void add_table(i)
int i ;
{
   char firstchar ;
   char num[6] ;
   char *end ;
   int len ;
   int summary_width ;
   int offset = 0 ;
   char found = FALSE ;

   prev_table++ ;
   firstchar = buffer[i][0] ;
   if (firstchar == 'C' || firstchar == 'V')  /* Call.. or Values... ? */
      {
      if (i > 0 && buffer[i-1][0] == '(')
	 {
	 memcpy(num,buffer[i-1]+7,5) ;
	 if (isdigit(num[4]))
	    len = 5 ;
	 else
	    len = 4 ;
	 num[len] = '\0' ;
	 found = TRUE ;
	 if (firstchar == 'V') offset = 11 ;
	 }
      }
   else if (firstchar == 'B' || firstchar == 'F') /* Bitfields.. or Format..? */
      {
      end = strrchr(buffer[i+1]+7,'(') ;   /* rule out Bit(s) as only match */
      if (end)
	 {
	 memcpy(num,end+7,5) ;
	 if (isdigit(num[4]))
	    len = 5 ;
	 else
	    len = 4 ;
	 num[len] = '\0' ;
	 found = TRUE ;
	 if (firstchar == 'B')
	    offset = 14 ;
	 else
	    offset = 10 ;
	 }
      }
   if (!found)
      {
      itoa(prev_table,num,10) ;
      len = strlen(num) ;
      }
   indent_line(tables) ;
   if (show_offsets)
      show_offset(i,tables) ;
   ip_write("  0000",6-len,tables) ;
   ip_write(num,len,tables);
   if (page_numbers)
      {
      summary_width = 13 ;
      while (summary_line[summary_width] != ' ')
	 summary_width++ ;
      summary_width++ ;	/* include the blank we found */
      }
   else
      summary_width = 10 ;
   ip_write(summary_line,summary_width,tables) ;
   len = strlen(buffer[i]+offset)-1 ;
   if (len > page_width - summary_width - 5)
      len = page_width - summary_width - 5 ;
   if (len > 0)
      ip_write(buffer[i]+offset,len,tables) ;
   newline(tables) ;
}

/***********************************************/

int make_description(desc,type,line)
char *desc, *type ;
int line ;
{
   char *start = desc ;
   
   summarize(line,pages_printed) ;
   if (type)
      {
      int len = strlen(type) ;
      char *blank = strchr(type,' ') ;
      if (blank)
	 len = blank - type + 1 ;
      memcpy(desc,type,len) ;
      desc += len ;
      }
   else
      {
      memcpy(desc,"INT ", 4) ;
      desc += 4 ;
      }
   *desc++ = summary_line[1] ;
   *desc++ = summary_line[2] ;
   if (summary_line[4] != '-')
      {
      memcpy(desc,", AH=", 5) ;
      desc += 5 ;
      *desc++ = summary_line[4] ;
      *desc++ = summary_line[5] ;
      }
   if (summary_line[7] != '-')
      {
      memcpy(desc,", AL=", 5) ;
      desc += 5 ;
      *desc++ = summary_line[7] ;
      *desc++ = summary_line[8] ;
      }
   *desc = '\0' ;
   return (desc-start)+1 ;
}

/***********************************************/

char *determine_heading(last)
int last ;
{
   int i ;
   static char heading[MAXLINE] ;
   char save[25] ;
   char num[10] ;

   /* ugly hack to keep the combination of -H and -T from showing wrong page */
   /* numbers for tables--copy last summary line from previous page to safe */
   /* place before processing current page, then restore it */
   memcpy(save,summary_line,sizeof(save)) ;
   if (start_of_entry(buffer[0]))
      {
      header_first.len = make_description(header_first.desc,buffer[0],0) ;
      header_first.part = 1 ;
      header_first.first_on_page = TRUE ;
      }
   else if (header_last.part == 0)  /* very first entry? */
      {
      for (i = 0 ; i < last ; i++)
	 if (start_of_entry(buffer[i]))
	    {
	    header_first.len = make_description(header_first.desc,buffer[i],i);
	    header_first.part = 1 ;
	    header_first.first_on_page = TRUE ;
	    break ;
	    }
      }
   else
      {
      header_first.len = header_last.len ;
      memcpy(header_first.desc,header_last.desc,header_last.len) ;
      header_first.part = header_last.part + 1 ;
      header_first.first_on_page = FALSE ;
      }
   /* assume entry spans entire page */
   header_last.len = header_first.len ;
   memcpy(header_last.desc,header_first.desc,header_first.len) ;
   header_last.part = header_first.part ;
   header_last.first_on_page = header_first.first_on_page ;
   /* find last entry on page */
   if (header_first.part > 0)
      {
      for (i = last-1 ; i > 0 ; i--)
	 if (start_of_entry(buffer[i]))
	    {
	    header_last.len = make_description(header_last.desc,buffer[i],i) ;
	    header_last.part = 1 ;
	    header_last.first_on_page = FALSE ;
	    break ;
	    }
      memcpy(heading,header_first.desc,header_first.len) ;
      if (header_first.part > 1)
	 {
	 strcat(heading," (Part ") ;
	 strcat(heading,itoa(header_first.part,num,10)) ;
	 strcat(heading,")") ;
	 }
      if (memcmp(header_first.desc,header_last.desc,header_last.len) != 0 ||
	  header_first.part != header_last.part)
	 {
	 strcat(heading," to ") ;
	 strcat(heading,header_last.desc) ;
	 if (header_last.part > 1)
	    {
	    strcat(heading," (Part ") ;
	    strcat(heading,itoa(header_last.part,num,10)) ;
	    strcat(heading,")") ;
	    }
	 }
      memcpy(summary_line,save,sizeof(save)) ;
      return heading ; 
      }
   else /* no headings yet */
      {
      memcpy(summary_line,save,sizeof(save)) ;
      return NULL ;
      }
}

/***********************************************/

void print_buffer(last,body_lines,lines_per_page,total_lines,use_FF)
int last, body_lines, lines_per_page, total_lines ;
int use_FF ;
{
   int i, len ;
   int headpos ;
   int print_this_page = (pages_printed>=first_page && pages_printed<=last_page);
   
   pages_printed++ ;
   if (do_headers)
      {
      char *heading ;
      
      if ((heading = determine_heading(last)) != NULL)
	 {
	 if (print_this_page)
	    {
	    len = strlen(heading) ;
	    headpos = 40-len/2 ;
	    indent_to(headpos,outfile) ;
	    if (boldface)
	       {
	       if (printer_bold)
		  {
		  ip_putcstr(&printer->bold_on,outfile) ;
		  ip_write(heading,len,outfile) ;
		  ip_putcstr(&printer->bold_off,outfile) ;
		  }
	       else
		  {
		  ip_write(heading,len,outfile) ;
		  ip_putc('\r',outfile) ;
		  indent_to(headpos,outfile) ;
		  ip_write(heading,len,outfile) ;
		  }
	       }
	    else
	       ip_write(heading,len,outfile) ;
	    }
	 }
      newline(outfile) ;
      newline(outfile) ;
      }
   for (i = 0 ; i < last ; i++)
      {
      if (print_this_page)
	 {
	 char *line = buffer[i] ;
	 if (*line)
	    {
	    if (!keep_divider_lines && divider_line(line))
	       {
	       indent_line(outfile) ;
	       (*printer->put_line)(outfile,79) ;
	       newline(outfile) ;
	       echo_format = FALSE ;
	       }
	    else
	       {
	       output_line(line, outfile) ;
	       if (echo_format)
		  output_line(line,formats) ;
	       }
	    }
	 else
	    {
	    newline(outfile) ;
	    echo_format = FALSE ;
	    }
	 }
      /* need summary lines if doing summary, formats, or table index */
      if (need_summary)
	 {
	 if (summarize(i,pages_printed) && do_summary && summary)
	    {
	    if (show_offsets)
	       show_offset(i,summary) ;
	    ip_write(summary_line,summary_line_len,summary) ;
	    newline(summary) ;
	    }
	 if (do_formats && memcmp(buffer[i],"Format ",7) == 0)
	    start_format(buffer[i]) ;
	 if (do_tables && start_of_table(buffer[i]))
	    add_table(i) ;
	 }
      }
   if (print_this_page)
      {
      if (page_numbers)
	 {
	 for (i = last ; i <= body_lines ; i++)
	    newline(outfile) ;
	 itoa(pages_printed, num, 10) ;
	 i = strlen(num) ;
	 if (!duplex)
	    indent_to(38-i/2,outfile) ;
	 else if (pages_printed & 1)	    /* odd-numbered page? */
	    indent_to(75-i/2,outfile) ;
	 else
	    indent_to(2,outfile) ;
	 ip_putlit("- ", outfile) ;
	 ip_write(num, i, outfile) ;
	 ip_putlit(" -", outfile) ;
	 newline(outfile) ;
	 }
      if (use_FF)
	 ip_putc('\f',outfile) ;
      else
	 for (i = page_numbers?lines_per_page:last ; i<total_lines ; i++)
	    newline(outfile) ;
      if (duplex)
	 {
	 if (pages_printed & 1)	       /* next page even or odd? */
	    ip_putcstr(&printer->marginl, outfile) ;	/* even page */
	 else
	    ip_putcstr(&printer->marginr, outfile) ;	/* odd page */
	 }
      }
}

/***********************************************/

void display_printers()
{
   int i ;
   
   ip_putlit("Valid printer names are:",err) ;
   newline(err) ;
   for (i = 0 ; i < NUM_PRINTERS ; i++)
      {
      ip_putc('\t',err) ;
      ip_puts(printers[i].name,err) ;
      newline(err) ;
      }
   ip_putlit("When entering the printer name, use either a dash or an",err) ;
   newline(err) ;
   ip_putlit("underscore in place of blanks.  Case is ignored, and the",err) ;
   newline(err) ;
   ip_putlit("name may be abbreviated to the shortest unique prefix.",err) ;
   newline(err) ;
   exit(1) ;
}

/***********************************************/

void select_printer(name)
char *name ;
{
   int i, len, prt = -1 ;
   
   len = strlen(name) ;
   for (i = 0 ; i < len ; i++)		/* convert dashes and underscores to blanks */
      if (name[i] == '-' || name[i] == '_')
	 name[i] = ' ' ;
   for (i = 0 ; i < NUM_PRINTERS ; i++)
      if (strnicmp(name,printers[i].name,len) == 0)
	 if (prt == -1)
	    prt = i ;
	 else
	    fatal("Ambiguous printer name!  Use -P? to list printers.") ;
   if (prt == -1)
      fatal("Unknown printer name!  Use -P? to list printers.") ;
   else
      printer = &printers[prt] ;
}