1033 lines
20 KiB
C
1033 lines
20 KiB
C
/*
|
||
* CDE - Common Desktop Environment
|
||
*
|
||
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
|
||
*
|
||
* These libraries and programs are free software; you can
|
||
* redistribute them and/or modify them under the terms of the GNU
|
||
* Lesser General Public License as published by the Free Software
|
||
* Foundation; either version 2 of the License, or (at your option)
|
||
* any later version.
|
||
*
|
||
* These libraries and programs are distributed in the hope that
|
||
* they will be useful, but WITHOUT ANY WARRANTY; without even the
|
||
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
||
* PURPOSE. See the GNU Lesser General Public License for more
|
||
* details.
|
||
*
|
||
* You should have received a copy of the GNU Lesser General Public
|
||
* License along with these librararies and programs; if not, write
|
||
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
|
||
* Floor, Boston, MA 02110-1301 USA
|
||
*/
|
||
/*
|
||
* @OSF_COPYRIGHT@
|
||
* COPYRIGHT NOTICE
|
||
* Copyright (c) 1990, 1991, 1992, 1993 Open Software Foundation, Inc.
|
||
* ALL RIGHTS RESERVED (MOTIF). See the file named COPYRIGHT.MOTIF for
|
||
* the full copyright text.
|
||
*/
|
||
/*
|
||
* HISTORY
|
||
*/
|
||
#ifdef REV_INFO
|
||
#ifndef lint
|
||
static char rcsid[] = "$TOG: UilLstLst.c /main/20 1999/07/21 09:03:16 vipin $"
|
||
#endif
|
||
#endif
|
||
|
||
/*
|
||
* (c) Copyright 1989, 1990, DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. */
|
||
|
||
/*
|
||
**++
|
||
** FACILITY:
|
||
**
|
||
** User Interface Language Compiler (UIL)
|
||
**
|
||
** ABSTRACT:
|
||
**
|
||
** This module contains the procedures for managing the UIL listing.
|
||
**
|
||
**--
|
||
**/
|
||
|
||
|
||
/*
|
||
**
|
||
** INCLUDE FILES
|
||
**
|
||
**/
|
||
|
||
#include <X11/Intrinsic.h>
|
||
#include <Xm/Xm.h>
|
||
|
||
#include <stdarg.h>
|
||
|
||
#include "UilDefI.h"
|
||
|
||
|
||
/*
|
||
**
|
||
** EXTERNAL storage used by the listing
|
||
**
|
||
*/
|
||
|
||
|
||
/*
|
||
**
|
||
** OWN storage used by the listing
|
||
**
|
||
*/
|
||
|
||
externaldef(uil_comp_glbl) char Uil_lst_c_title2[132];
|
||
|
||
static int lst_l_usable_lines;
|
||
static int lst_l_lines_left;
|
||
static int lst_l_page_no;
|
||
static char lst_c_title1[132];
|
||
static uil_fcb_type *lst_az_fcb;
|
||
static boolean lst_v_listing_open = FALSE;
|
||
|
||
|
||
/*
|
||
**++
|
||
** FUNCTIONAL DESCRIPTION:
|
||
**
|
||
** This function opens the UIL listing file to be written and
|
||
** initializes OWN storage used by the listing package.
|
||
**
|
||
** FORMAL PARAMETERS:
|
||
**
|
||
** none
|
||
**
|
||
** IMPLICIT INPUTS:
|
||
**
|
||
** none
|
||
**
|
||
** IMPLICIT OUTPUTS:
|
||
**
|
||
** lst_l_usable_lines number of usable lines per page
|
||
** lst_l_lines_left number of lines left on page
|
||
** lst_l_page_no current page number
|
||
** lst_c_title1 title line 1
|
||
** Uil_lst_c_title2 title line 2
|
||
** lst_v_listing_open can the listing be written to
|
||
**
|
||
** FUNCTION VALUE:
|
||
**
|
||
** void
|
||
**
|
||
** SIDE EFFECTS:
|
||
**
|
||
** listing file is opened
|
||
**
|
||
**--
|
||
**/
|
||
|
||
void lst_open_listing()
|
||
{
|
||
status open_status;
|
||
_Xctimeparams ctime_buf;
|
||
|
||
/* allocate fcb */
|
||
|
||
lst_az_fcb = (uil_fcb_type *)_get_memory( sizeof( uil_fcb_type ) );
|
||
|
||
/* open the listing file */
|
||
|
||
open_status =
|
||
create_listing_file( lst_az_fcb );
|
||
|
||
if ( open_status == src_k_open_error )
|
||
{
|
||
diag_issue_diagnostic( d_listing_open,
|
||
diag_k_no_source, diag_k_no_column,
|
||
lst_az_fcb->expanded_name );
|
||
/* should never return - error is fatal */
|
||
|
||
return;
|
||
}
|
||
|
||
lst_l_lines_left = 0;
|
||
lst_l_page_no = 0;
|
||
lst_v_listing_open = TRUE;
|
||
|
||
sprintf(lst_c_title1,
|
||
"%s %s \t%s\t\t Page ",
|
||
_host_compiler, _compiler_version,
|
||
current_time(&ctime_buf));
|
||
|
||
/*
|
||
** Haven't parsed the module yet.
|
||
** UilSarMod.c routines will fill it in.
|
||
*/
|
||
|
||
Uil_lst_c_title2[ 0 ] = 0;
|
||
|
||
}
|
||
|
||
/*
|
||
**++
|
||
** FUNCTIONAL DESCRIPTION:
|
||
**
|
||
** This function does the clean up processing for the listing facility.
|
||
**
|
||
** FORMAL PARAMETERS:
|
||
**
|
||
** none
|
||
**
|
||
** IMPLICIT INPUTS:
|
||
**
|
||
** lst_c_title1 title line 1
|
||
** Uil_lst_c_title2 title line 2
|
||
** lst_v_listing_open can the listing be written to
|
||
**
|
||
** IMPLICIT OUTPUTS:
|
||
**
|
||
** none
|
||
**
|
||
** FUNCTION VALUE:
|
||
**
|
||
** void
|
||
**
|
||
** SIDE EFFECTS:
|
||
**
|
||
** dynamic memory is freed
|
||
**
|
||
**--
|
||
**/
|
||
|
||
void Uil_lst_cleanup_listing()
|
||
{
|
||
/*
|
||
** Check that there is a listing file requested and that
|
||
** it is not already in error.
|
||
*/
|
||
|
||
if (!(lst_v_listing_open && Uil_cmd_z_command.v_listing_file))
|
||
return;
|
||
|
||
/*
|
||
** free fcb
|
||
*/
|
||
|
||
_free_memory((char*)lst_az_fcb);
|
||
lst_az_fcb = NULL;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
/*
|
||
**++
|
||
** FUNCTIONAL DESCRIPTION:
|
||
**
|
||
** routine to create the listing file.
|
||
**
|
||
** FORMAL PARAMETERS:
|
||
**
|
||
** az_fcb file control block for the file
|
||
**
|
||
** IMPLICIT INPUTS:
|
||
**
|
||
** none
|
||
**
|
||
** IMPLICIT OUTPUTS:
|
||
**
|
||
** none
|
||
**
|
||
** FUNCTION VALUE:
|
||
**
|
||
** src_k_open_normal
|
||
** src_k_open_error
|
||
**
|
||
** SIDE EFFECTS:
|
||
**
|
||
** file is created
|
||
**
|
||
**--
|
||
**/
|
||
|
||
status create_listing_file( az_fcb )
|
||
|
||
uil_fcb_type *az_fcb;
|
||
|
||
{
|
||
/* place the file name in the expanded_name buffer */
|
||
|
||
strcpy(az_fcb->expanded_name, Uil_cmd_z_command.ac_listing_file);
|
||
|
||
/* open the file */
|
||
|
||
az_fcb->az_file_ptr = fopen(Uil_cmd_z_command.ac_listing_file, "w");
|
||
|
||
if (az_fcb->az_file_ptr == NULL)
|
||
return src_k_open_error;
|
||
|
||
/* assume 66 lines on a page */
|
||
|
||
lst_l_usable_lines = 66 - 9;
|
||
|
||
return src_k_open_normal;
|
||
}
|
||
|
||
|
||
/*
|
||
**++
|
||
** FUNCTIONAL DESCRIPTION:
|
||
**
|
||
** function to write a line to the listing file.
|
||
**
|
||
** FORMAL PARAMETERS:
|
||
**
|
||
** ac_line text of the line to output
|
||
**
|
||
** IMPLICIT INPUTS:
|
||
**
|
||
** lst_l_lines_left
|
||
** lst_l_usable_lines
|
||
** lst_az_fcb
|
||
** lst_c_title1
|
||
** lst_c_title1
|
||
**
|
||
** IMPLICIT OUTPUTS:
|
||
**
|
||
** lst_l_lines_left
|
||
**
|
||
** FUNCTION VALUE:
|
||
**
|
||
** void
|
||
**
|
||
** SIDE EFFECTS:
|
||
**
|
||
** line output to file
|
||
**
|
||
**--
|
||
**/
|
||
|
||
|
||
void lst_output_line( ac_line, v_new_page )
|
||
|
||
char *ac_line;
|
||
boolean v_new_page;
|
||
|
||
{
|
||
status error_status;
|
||
|
||
if (!lst_v_listing_open)
|
||
return;
|
||
|
||
/*
|
||
** Update the current file and call the Status callback routine to report
|
||
** our progress.
|
||
*/
|
||
Uil_current_file = lst_az_fcb->expanded_name;
|
||
if (Uil_cmd_z_command.status_cb != (Uil_continue_type(*)())NULL)
|
||
diag_report_status();
|
||
|
||
|
||
if ((lst_l_lines_left <= 0) || v_new_page)
|
||
{
|
||
lst_l_page_no ++;
|
||
lst_l_lines_left = lst_l_usable_lines;
|
||
|
||
fprintf(lst_az_fcb->az_file_ptr,
|
||
"\f\n%s%d\n%s\n\n",
|
||
lst_c_title1, lst_l_page_no, Uil_lst_c_title2);
|
||
}
|
||
|
||
error_status = fprintf(lst_az_fcb->az_file_ptr, "%s\n", ac_line);
|
||
|
||
if (error_status == EOF)
|
||
{
|
||
lst_v_listing_open = FALSE;
|
||
diag_issue_diagnostic( d_listing_write,
|
||
diag_k_no_source, diag_k_no_column,
|
||
lst_az_fcb->expanded_name );
|
||
}
|
||
|
||
lst_l_lines_left --;
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
/*
|
||
**++
|
||
** FUNCTIONAL DESCRIPTION:
|
||
**
|
||
** function to return ASCII date and time
|
||
**
|
||
** FORMAL PARAMETERS:
|
||
**
|
||
** void
|
||
**
|
||
** IMPLICIT INPUTS:
|
||
**
|
||
** void
|
||
**
|
||
** IMPLICIT OUTPUTS:
|
||
**
|
||
** void
|
||
**
|
||
** FUNCTION VALUE:
|
||
**
|
||
** pointer to a null terminated string
|
||
**
|
||
** SIDE EFFECTS:
|
||
**
|
||
** none
|
||
**
|
||
**--
|
||
**/
|
||
|
||
char *current_time(_Xctimeparams *ctime_buf)
|
||
{
|
||
time_t time_location;
|
||
char *ascii_time;
|
||
|
||
time_location = time( 0 );
|
||
|
||
ascii_time = _XCtime( &time_location, *ctime_buf );
|
||
|
||
ascii_time[24] = 0;
|
||
|
||
return ascii_time;
|
||
}
|
||
|
||
|
||
/*
|
||
**++
|
||
** FUNCTIONAL DESCRIPTION:
|
||
**
|
||
** This function outputs the UIL listing file
|
||
**
|
||
** FORMAL PARAMETERS:
|
||
**
|
||
**
|
||
** IMPLICIT INPUTS:
|
||
**
|
||
**
|
||
** IMPLICIT OUTPUTS:
|
||
**
|
||
**
|
||
** SIDE EFFECTS:
|
||
**
|
||
**
|
||
**--
|
||
**/
|
||
|
||
void lst_output_listing()
|
||
|
||
{
|
||
src_source_record_type *az_src_rec;
|
||
char src_buffer[ src_k_max_source_line_length+12 ];
|
||
char *src_ptr;
|
||
int i;
|
||
|
||
/*
|
||
** Check that there is a listing file requested and that
|
||
** it is not already in error.
|
||
*/
|
||
|
||
if (!(lst_v_listing_open &&
|
||
Uil_cmd_z_command.v_listing_file)
|
||
)
|
||
return;
|
||
|
||
/*
|
||
** Walk the list of source records.
|
||
*/
|
||
|
||
for (az_src_rec = src_az_first_source_record;
|
||
az_src_rec != NULL;
|
||
az_src_rec = az_src_rec->az_next_source_record)
|
||
{
|
||
|
||
/*
|
||
** place the line and file number in the output buffer
|
||
*/
|
||
|
||
sprintf(src_buffer, "%5d (%d)\t",
|
||
az_src_rec->w_line_number,
|
||
az_src_rec->b_file_number);
|
||
|
||
src_ptr = &(src_buffer[ strlen( src_buffer ) ]);
|
||
|
||
src_retrieve_source( az_src_rec, src_ptr );
|
||
|
||
/*
|
||
** filter standard unprintable characters if necessary
|
||
*/
|
||
|
||
if ( az_src_rec->b_flags & src_m_unprintable_chars)
|
||
lex_filter_unprintable_chars( (unsigned char*)src_ptr, strlen( src_ptr ), 0 );
|
||
|
||
/*
|
||
** replace leading formfeed with a blank
|
||
*/
|
||
|
||
if ( az_src_rec->b_flags & src_m_form_feed)
|
||
*src_ptr = ' ';
|
||
|
||
lst_output_line( src_buffer,
|
||
(az_src_rec->b_flags & src_m_form_feed) != 0 );
|
||
|
||
/*
|
||
** if the line has messages, get them displayed
|
||
*/
|
||
|
||
if (az_src_rec->az_message_list != NULL)
|
||
{
|
||
lst_output_message_ptr_line( az_src_rec, src_ptr );
|
||
lst_output_messages( az_src_rec->az_message_list );
|
||
}
|
||
|
||
/*
|
||
** if the line has machine code, get it displayed if requested
|
||
*/
|
||
|
||
if ( (Uil_cmd_z_command.v_show_machine_code) &&
|
||
(az_src_rec->w_machine_code_cnt > 0) )
|
||
{
|
||
lst_output_machine_code( az_src_rec );
|
||
}
|
||
|
||
}
|
||
|
||
/*
|
||
** output the orphan messages
|
||
*/
|
||
|
||
if (src_az_orphan_messages != NULL)
|
||
lst_output_messages( src_az_orphan_messages );
|
||
|
||
/*
|
||
** output the file summary
|
||
*/
|
||
|
||
lst_output_line( " ", FALSE );
|
||
|
||
for (i = 0; i <= src_l_last_source_file_number; i++) {
|
||
|
||
uil_fcb_type *az_fcb; /* file control block ptr */
|
||
char buffer [132];
|
||
|
||
az_fcb = src_az_source_file_table [i];
|
||
sprintf (buffer,
|
||
" File (%d) %s",
|
||
i, az_fcb->expanded_name );
|
||
lst_output_line( buffer, FALSE );
|
||
}
|
||
|
||
lst_output_line( " ", FALSE );
|
||
|
||
return;
|
||
}
|
||
|
||
/*
|
||
**++
|
||
** FUNCTIONAL DESCRIPTION:
|
||
**
|
||
** This function outputs a list of messages to the UIL listing file
|
||
**
|
||
** FORMAL PARAMETERS:
|
||
**
|
||
** az_message_item ptr to start of the message list
|
||
**
|
||
** IMPLICIT INPUTS:
|
||
**
|
||
**
|
||
** IMPLICIT OUTPUTS:
|
||
**
|
||
** none
|
||
**
|
||
** FUNCTION VALUE:
|
||
**
|
||
** void
|
||
**
|
||
** SIDE EFFECTS:
|
||
**
|
||
** messages are written to the listing file
|
||
**
|
||
**--
|
||
**/
|
||
|
||
void lst_output_messages( az_message_item )
|
||
|
||
src_message_item_type *az_message_item;
|
||
|
||
{
|
||
src_message_item_type *az_msg;
|
||
char buffer[132];
|
||
int msg_no;
|
||
int last_pos;
|
||
int current_pos;
|
||
|
||
last_pos = -1;
|
||
msg_no = 9;
|
||
|
||
for (az_msg = az_message_item;
|
||
az_msg != NULL;
|
||
az_msg = az_msg->az_next_message)
|
||
{
|
||
current_pos = az_msg->b_source_pos;
|
||
|
||
if (last_pos < current_pos)
|
||
{
|
||
last_pos = current_pos;
|
||
if (last_pos == diag_k_no_column)
|
||
msg_no = 0;
|
||
else
|
||
msg_no = (msg_no % 9) + 1;
|
||
}
|
||
|
||
|
||
sprintf(buffer, "%s (%d) %s",
|
||
diag_get_message_abbrev( az_msg->l_message_number ),
|
||
msg_no,
|
||
az_msg->c_text);
|
||
|
||
lst_output_line( buffer, FALSE );
|
||
}
|
||
|
||
lst_output_line( " ", FALSE );
|
||
|
||
return;
|
||
}
|
||
|
||
/*
|
||
**++
|
||
** FUNCTIONAL DESCRIPTION:
|
||
**
|
||
** This function outputs a list of machine code items to the
|
||
** UIL listing file
|
||
**
|
||
** FORMAL PARAMETERS:
|
||
**
|
||
** az_src_rec ptr to a source record
|
||
**
|
||
** IMPLICIT INPUTS:
|
||
**
|
||
**
|
||
** IMPLICIT OUTPUTS:
|
||
**
|
||
** none
|
||
**
|
||
** FUNCTION VALUE:
|
||
**
|
||
** void
|
||
**
|
||
** SIDE EFFECTS:
|
||
**
|
||
** machine code is written to the listing file
|
||
**
|
||
**--
|
||
**/
|
||
|
||
void lst_output_machine_code ( az_src_rec )
|
||
|
||
src_source_record_type *az_src_rec;
|
||
|
||
{
|
||
|
||
static src_machine_code_type * * mc_array = NULL;
|
||
static unsigned short mc_cnt = 0;
|
||
|
||
src_machine_code_type *az_code;
|
||
int code_cnt, mc_i;
|
||
|
||
/* Go through the machine code list, and save the entries in
|
||
the array; traverse them in reverse order. Reuse the vector
|
||
if it is large enough. */
|
||
|
||
|
||
|
||
code_cnt = az_src_rec->w_machine_code_cnt;
|
||
|
||
if ((int)mc_cnt < code_cnt) {
|
||
if (mc_array != NULL) {
|
||
_free_memory ((char*)mc_array);
|
||
}
|
||
mc_array =
|
||
(src_machine_code_type * *)_get_memory (sizeof (char *) * code_cnt);
|
||
mc_cnt = code_cnt;
|
||
}
|
||
|
||
for (az_code = az_src_rec->az_machine_code_list, mc_i = 0;
|
||
az_code != NULL;
|
||
az_code = az_code->az_next_machine_code, mc_i++) {
|
||
mc_array [mc_i] = az_code;
|
||
}
|
||
|
||
for (mc_i = code_cnt - 1; mc_i >= 0; mc_i--)
|
||
{
|
||
|
||
#define BIT_64_LONG ((sizeof(long)*8)==64)
|
||
|
||
#define OFFSET_COL (BIT_64_LONG ? 75 : 43) /*should be 75 on 64 bit mach, 43 on 32*/
|
||
#define TEXT_COL (BIT_64_LONG ? 82 : 50) /*82 on 64 bit mach, 50 on 32*/
|
||
#define BUF_LEN (BIT_64_LONG ? 164 : 132) /*164 on 64 bit mach. 132 on 32 bit mach.*/
|
||
#define HEX_PER_WORD 4
|
||
#define HEX_PER_LONG (BIT_64_LONG ? 16 : 8) /*should be 16 on 64 bit mach., 8 on 32 bit mach*/
|
||
|
||
#define LONG_PER_LINE 4
|
||
#define ASCII_PER_LINE (LONG_PER_LINE * sizeof (long))
|
||
|
||
unsigned short long_cnt, extra_byte_cnt, text_len, code_len,
|
||
line_cnt, extra_long_cnt, i, j, code_offset;
|
||
unsigned char buffer[ BUF_LEN + 1 ], * text_ptr,
|
||
hex_longword [HEX_PER_LONG + 1], line_written;
|
||
unsigned long * code_ptr;
|
||
|
||
unsigned long temp_long;
|
||
static unsigned short start_hex_long [4];
|
||
/*if 64-bit environment, it should have vals { 55, 38, 21, 4 };
|
||
if 32 bit environment, { 31, 22, 13, 4 };
|
||
*/
|
||
start_hex_long[0]=(BIT_64_LONG ? 55 : 31);
|
||
start_hex_long[1]=(BIT_64_LONG ? 38 : 22);
|
||
start_hex_long[2]=(BIT_64_LONG ? 21 : 13);
|
||
start_hex_long[3]=4;
|
||
|
||
|
||
az_code = mc_array [mc_i];
|
||
|
||
code_ptr = (unsigned long *)az_code -> data.c_data;
|
||
code_len = az_code -> w_code_len;
|
||
code_offset = az_code -> w_offset;
|
||
text_ptr = (unsigned char *)(& az_code -> data.c_data [code_len]);
|
||
text_len = strlen ((char *)text_ptr);
|
||
if (text_len > (unsigned short) (BUF_LEN - TEXT_COL + 1))
|
||
text_len = BUF_LEN - TEXT_COL + 1;
|
||
|
||
long_cnt = code_len / sizeof (char *);
|
||
line_cnt = long_cnt / LONG_PER_LINE;
|
||
extra_long_cnt = long_cnt % LONG_PER_LINE;
|
||
extra_byte_cnt = code_len % sizeof (char *);
|
||
|
||
_fill (buffer, ' ', sizeof buffer - 1);
|
||
|
||
|
||
sprintf ((char *)hex_longword, "%04X", code_offset);
|
||
_move (& buffer [OFFSET_COL - 1], hex_longword, HEX_PER_WORD);
|
||
|
||
_move (& buffer [TEXT_COL - 1], text_ptr, text_len);
|
||
buffer [TEXT_COL + text_len] = '\0';
|
||
|
||
line_written = FALSE;
|
||
|
||
/*
|
||
** Write out entire lines. Clear the text after the first line.
|
||
** Filter all non-printable characters.
|
||
*/
|
||
|
||
for (i = 0; i < line_cnt; i++) {
|
||
|
||
if (text_len == 0) {
|
||
_move (& buffer [TEXT_COL - 1], code_ptr, ASCII_PER_LINE);
|
||
lex_filter_unprintable_chars ((unsigned char*)
|
||
& buffer [TEXT_COL - 1], ASCII_PER_LINE,
|
||
lex_m_filter_tab );
|
||
buffer [TEXT_COL - 1 + ASCII_PER_LINE] = '\0';
|
||
}
|
||
|
||
for (j = 0; j < LONG_PER_LINE; j++, code_ptr++) {
|
||
|
||
|
||
if (BIT_64_LONG){
|
||
|
||
sprintf ((char *)hex_longword, "%lX", (* code_ptr));
|
||
}
|
||
else{
|
||
sprintf ((char *)hex_longword, "%08X", (* code_ptr));
|
||
}
|
||
|
||
_move (& buffer [start_hex_long [j]],
|
||
hex_longword, HEX_PER_LONG);
|
||
|
||
}
|
||
|
||
|
||
lst_output_line((char*) buffer, FALSE );
|
||
line_written = TRUE;
|
||
|
||
code_offset += LONG_PER_LINE * sizeof (long);
|
||
sprintf ((char *)hex_longword, "%04X", code_offset);
|
||
_move (& buffer [OFFSET_COL - 1], hex_longword, HEX_PER_WORD);
|
||
|
||
if (i == 0 && text_len > 0) {
|
||
_fill (& buffer [TEXT_COL - 1], ' ', text_len);
|
||
}
|
||
}
|
||
|
||
/* Write out a partial line. */
|
||
|
||
if (extra_long_cnt > 0 || extra_byte_cnt > 0) {
|
||
|
||
if (text_len == 0) {
|
||
int ascii_cnt;
|
||
|
||
ascii_cnt = (extra_long_cnt * sizeof (long)) + extra_byte_cnt;
|
||
_move (& buffer [TEXT_COL - 1], code_ptr, ascii_cnt);
|
||
lex_filter_unprintable_chars ((unsigned char*)
|
||
& buffer [TEXT_COL - 1], ascii_cnt,
|
||
lex_m_filter_tab );
|
||
buffer [TEXT_COL - 1 + ascii_cnt] = '\0';
|
||
}
|
||
|
||
/* Clear code from previous lines, keeping the offset and text if
|
||
it is there. */
|
||
|
||
_fill (buffer, ' ', OFFSET_COL - 1);
|
||
|
||
if (extra_long_cnt > 0) {
|
||
|
||
/* Format the code longwords. */
|
||
|
||
for (i = 0; i < extra_long_cnt; i++, code_ptr++) {
|
||
unsigned long temp_long;
|
||
if (BIT_64_LONG){
|
||
/* _move( (char*) &temp_long, (char*) code_ptr, sizeof(temp_long));*/
|
||
sprintf ((char *)hex_longword, "%lX", (* code_ptr));
|
||
}
|
||
else{
|
||
sprintf ((char *)hex_longword, "%08X", (*code_ptr));
|
||
}
|
||
|
||
_move (& buffer [start_hex_long [i]],
|
||
hex_longword, HEX_PER_LONG);
|
||
}
|
||
}
|
||
|
||
/* Format the extra code bytes. */
|
||
|
||
if (extra_byte_cnt > 0) {
|
||
int l;
|
||
unsigned char extra_bytes [sizeof (long)];
|
||
|
||
_move (extra_bytes, code_ptr, extra_byte_cnt);
|
||
_fill (hex_longword, ' ', HEX_PER_LONG);
|
||
for (l = extra_byte_cnt - 1; l >= 0; l--) {
|
||
if (BIT_64_LONG)
|
||
sprintf ((char *)
|
||
& hex_longword [HEX_PER_LONG - (2 * (l + 1))],
|
||
"%02X", extra_bytes [l]);
|
||
else
|
||
sprintf ((char *)
|
||
& hex_longword [HEX_PER_LONG - (2 * (l + 1))],
|
||
"%02X", extra_bytes [extra_byte_cnt-l-1]);
|
||
|
||
}
|
||
_move (& buffer [start_hex_long [extra_long_cnt]],
|
||
hex_longword, HEX_PER_LONG);
|
||
}
|
||
|
||
/* Output the partial line. */
|
||
|
||
lst_output_line( (char*)buffer, FALSE );
|
||
|
||
line_written = TRUE;
|
||
|
||
}
|
||
|
||
if (! line_written) {
|
||
if (text_len > 0) {
|
||
lst_output_line((char*) buffer, FALSE );
|
||
} else {
|
||
lst_output_line( " ", FALSE );
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
return;
|
||
}
|
||
|
||
/*
|
||
**++
|
||
** FUNCTIONAL DESCRIPTION:
|
||
**
|
||
** This function outputs a pointer line showing the position of
|
||
** diagnostics to the UIL listing file.
|
||
**
|
||
** FORMAL PARAMETERS:
|
||
**
|
||
** az_src_rec ptr to a source record
|
||
**
|
||
** IMPLICIT INPUTS:
|
||
**
|
||
** none
|
||
**
|
||
** IMPLICIT OUTPUTS:
|
||
**
|
||
** none
|
||
**
|
||
** FUNCTION VALUE:
|
||
**
|
||
** void
|
||
**
|
||
** SIDE EFFECTS:
|
||
**
|
||
** message ptr line is written to the listing file
|
||
**
|
||
**--
|
||
**/
|
||
|
||
void lst_output_message_ptr_line( az_src_rec, src_buffer )
|
||
|
||
src_source_record_type *az_src_rec;
|
||
char *src_buffer;
|
||
|
||
{
|
||
src_message_item_type *az_msg;
|
||
char buffer[ src_k_max_source_line_length + 3 ];
|
||
char *ptr_buffer;
|
||
int msg_no;
|
||
int pos;
|
||
int msg_pos;
|
||
char c_char;
|
||
boolean v_output_line;
|
||
|
||
if (_src_null_access_key( az_src_rec->z_access_key) )
|
||
return;
|
||
|
||
msg_no = 9;
|
||
|
||
buffer[ 0 ] = '\t';
|
||
buffer[ 1 ] = '\t';
|
||
ptr_buffer = &buffer[ 2 ];
|
||
|
||
az_msg = az_src_rec->az_message_list;
|
||
if (az_msg == NULL)
|
||
return;
|
||
msg_pos = az_msg->b_source_pos;
|
||
if (msg_pos == diag_k_no_column)
|
||
return;
|
||
|
||
v_output_line = FALSE;
|
||
|
||
for (pos = 0; c_char = src_buffer[ pos ], c_char != 0; )
|
||
{
|
||
if (pos < msg_pos)
|
||
{
|
||
if (c_char == '\t')
|
||
ptr_buffer[ pos++ ] = '\t';
|
||
else
|
||
ptr_buffer[ pos++ ] = ' ';
|
||
|
||
continue;
|
||
}
|
||
|
||
msg_no = (msg_no % 9) + 1;
|
||
ptr_buffer[ pos++ ] = msg_no + '0';
|
||
v_output_line = TRUE;
|
||
|
||
next_message:
|
||
az_msg = az_msg->az_next_message;
|
||
if (az_msg == NULL)
|
||
goto finished_scan;
|
||
msg_pos = az_msg->b_source_pos;
|
||
if ((pos-1) == msg_pos) /* pos already advanced */
|
||
goto next_message;
|
||
if (msg_pos == diag_k_no_column)
|
||
goto finished_scan;
|
||
|
||
}
|
||
|
||
finished_scan:
|
||
ptr_buffer[ pos ] = 0;
|
||
|
||
if (v_output_line)
|
||
lst_output_line( buffer, FALSE );
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
/*
|
||
**++
|
||
** FUNCTIONAL DESCRIPTION:
|
||
**
|
||
** lst_debug_output sends debugging info to the listing file if
|
||
** there is one; if not the output goes to standard output.
|
||
**
|
||
** FORMAL PARAMETERS:
|
||
**
|
||
** standard Xprintf argument list
|
||
**
|
||
** IMPLICIT INPUTS:
|
||
**
|
||
** lst_v_listing_open
|
||
**
|
||
** IMPLICIT OUTPUTS:
|
||
**
|
||
** none
|
||
**
|
||
** FUNCTION VALUE:
|
||
**
|
||
** void
|
||
**
|
||
** SIDE EFFECTS:
|
||
**
|
||
** print lines either in the listing file or to standard output
|
||
**
|
||
**--
|
||
**/
|
||
|
||
static int cur_pos=0;
|
||
static char buffer[132];
|
||
|
||
void lst_debug_output
|
||
|
||
(char *format, ...)
|
||
{
|
||
va_list ap; /* ptr to variable length parameter */
|
||
|
||
/*
|
||
** establish the start of the parameter list
|
||
*/
|
||
|
||
va_start(ap,format);
|
||
|
||
/*
|
||
** check if the listing file is open for output
|
||
*/
|
||
|
||
if (lst_v_listing_open)
|
||
{
|
||
int count;
|
||
char *ptr;
|
||
|
||
vsprintf( &(buffer[cur_pos]), format, ap );
|
||
|
||
for ( ptr=buffer; ptr[0] != '\0'; ptr += (count+1) )
|
||
{
|
||
_assert( ptr <= &(buffer[132]), "Overflowed debug listing buffer" );
|
||
count = strcspn( ptr, "\n" );
|
||
if (count == strlen( ptr ))
|
||
{
|
||
cur_pos = ptr - buffer + count;
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
ptr[ count ] = '\0';
|
||
}
|
||
lst_output_line( ptr, FALSE );
|
||
}
|
||
cur_pos = 0;
|
||
|
||
}
|
||
else
|
||
vprintf( format, ap );
|
||
|
||
va_end(ap);
|
||
}
|