static void statsPrint( // PRINT STATISTICS
INITFINI* defn ) // - definition
{
defn = defn;
if( CompFlags.stats_printed ) {
return;
}
if( CompFlags.quiet_mode ) {
return;
}
if( ! CompFlags.srcfile_compiled ) {
return;
}
if( WholeFName != NULL ) {
VBUF buffer;
VbufInit( &buffer );
VbufConcStr( &buffer, WholeFName );
VbufConcStr( &buffer, ": " );
intPrint( &buffer, "line", ", ", SrcLineCount );
if( IncLineCount != 0 ) {
VbufConcStr( &buffer, "included " );
VbufConcDecimal( &buffer, IncLineCount );
VbufConcStr( &buffer, ", " );
}
intPrint( &buffer, "warning", ", ", WngCount );
intPrint( &buffer, "error", "", ErrCount );
MsgDisplayLine( VbufString( &buffer ) );
CompFlags.stats_printed = 1;
VbufFree( &buffer );
}
}
void FormatTemplateParmScope( VBUF *parms, SCOPE parm_scope )
/***********************************************************/
{
SYMBOL stop;
SYMBOL curr;
SYMBOL sym;
const char *delim;
TYPE type;
auto VBUF sym_parm;
auto VBUF type_parm_prefix;
auto VBUF type_parm_suffix;
VbufInit( parms );
if( parm_scope == NULL ) {
makeUnknownTemplate( parms );
return;
}
delim = templateParmStart;
curr = NULL;
stop = ScopeOrderedStart( parm_scope );
for(;;) {
curr = ScopeOrderedNext( stop, curr );
if( curr == NULL ) break;
VbufConcStr( parms, delim );
type = curr->sym_type;
if( SymIsConstantInt( curr ) ) {
if( UnsignedIntType( type ) ) {
VbufConcDecimal( parms, curr->u.uval );
} else {
VbufConcInteger( parms, curr->u.sval );
}
} else if( SymIsTypedef( curr ) ) {
FormatType( type, &type_parm_prefix, &type_parm_suffix );
VbufTruncWhite( &type_parm_prefix );
VbufTruncWhite( &type_parm_suffix );
VbufConcVbuf( parms, &type_parm_prefix );
VbufConcVbuf( parms, &type_parm_suffix );
VbufFree( &type_parm_prefix );
VbufFree( &type_parm_suffix );
} else {
sym = SymAddressOf( curr );
if( sym != NULL ) {
FormatSym( sym, &sym_parm );
VbufConcVbuf( parms, &sym_parm );
VbufFree( &sym_parm );
}
}
delim = templateParmNext;
}
if( delim == templateParmStart ) {
VbufConcStr( parms, templateParmStart );
}
VbufConcStr( parms, templateParmStop );
}
static DUMP_INFO* bufferNmb( // CONCATENATE NUMBER TO BUFFER
DUMP_INFO* di, // - dump information
unsigned numb ) // - to be concatenated
{
char buf[16]; // - buffer
sprintf( buf, "%d", numb );
VbufConcStr( &di->buffer, buf );
if( numb >= 10 ) {
sprintf( buf, "0x%X", numb );
VbufConcStr( &di->buffer, buf );
}
return di;
}
static DUMP_INFO* bufferStr( // CONCATENATE STRING TO BUFFER
DUMP_INFO* di, // - dump information
const char *str ) // - to be concatenated
{
VbufConcStr( &di->buffer, str );
return di;
}
static PC_SEGMENT *addDefSeg( // ADD A DEFAULT PC SEGMENT
DEF_SEG *def_seg, // - default segment info.
unsigned ads_control ) // - control mask
{
unsigned attrs; // - attributes for segment
PC_SEGMENT *curr; // - segment pointer
VBUF seg_name; // - virtual buffer for name
unsigned sa_control; // - segmentAlloc control mask
VbufInit( &seg_name );
++def_seg->ctr;
sa_control = SA_NULL;
if( ads_control & ADS_MODULE_PREFIX ) {
if(( ads_control & ADS_CODE_SEGMENT ) == 0 && DataSegName[0] != '\0' ) {
VbufConcStr( &seg_name, DataSegName );
} else {
VbufConcStr( &seg_name, ModuleName );
}
sa_control |= SA_MODULE_PREFIX;
}
if( ads_control & ADS_STRING_SEGMENT ) {
sa_control |= SA_DEFINE_ANYTIME;
}
VbufConcStr( &seg_name, def_seg->pcseg->name );
if( ads_control & ADS_ZM_SEGMENT ) {
VbufConcDecimal( &seg_name, def_seg->ctr );
}
if( def_seg == &code_def_seg ) {
attrs = SGAT_CODE_GEN;
} else {
if( ads_control & ADS_CONST_SEGMENT ) {
attrs = SGAT_DATA_PRIVATE_RO;
} else {
attrs = SGAT_DATA_PRIVATE_RW;
}
VbufConcDecimal( &seg_name, def_seg->ctr );
}
curr = segmentAlloc( VbufString( &seg_name ), NULL, SEG_NULL, attrs, sa_control );
if( 0 == ( attrs & EXEC ) ) {
_markUsed( curr, TRUE );
}
if( ads_control & ADS_STRING_SEGMENT ) {
curr->only_strings = TRUE;
}
VbufFree( &seg_name );
return( curr );
}
static void collectStrings( VBUF *vinfo )
{
VbufInit( vinfo );
while( CurToken == T_STRING ) {
VbufConcStr( vinfo, Buffer );
NextToken();
}
}
void CmdLnCtxInfo( // PRINT CONTEXT INFO
void )
{
CTX_CL* entry; // - current entry
VBUF buf; // - buffer
VbufInit( &buf );
for( entry = VstkTop( &cmdLnContexts )
; entry != NULL
; entry = VstkNext( &cmdLnContexts, entry ) ) {
VbufRewind( &buf );
switch( entry->base.ctx_type ) {
case CTX_CLTYPE_ENV :
VbufConcChr( &buf, '@' );
VbufConcStr( &buf, entry->env.var );
break;
case CTX_CLTYPE_FC :
VbufConcStr( &buf, "batch file of commands, line " );
VbufConcDecimal( &buf, CompInfo.fc_file_line );
break;
case CTX_CLTYPE_PGM :
VbufConcStr( &buf, "command line" );
break;
case CTX_CLTYPE_FILE :
VbufConcStr( &buf, SrcFileFullName( entry->file.source ) );
break;
DbgDefault( "bad command-line context" );
}
if( entry->base.sw_ptr != NULL ) {
size_t size;
char const * not_used;
char const* old = CmdScanAddr();
CmdScanInit( entry->base.sw_ptr );
CmdScanChar();
size = CmdScanOption( ¬_used ) + 1;
CmdScanInit( old );
VbufConcStr( &buf, ", switch: " );
for( old = entry->base.sw_ptr; size > 0; ++old, --size ) {
VbufConcChr( &buf, *old );
}
}
InfMsgPtr( INF_SWITCH, VbufString( &buf ) );
}
VbufFree( &buf );
}
void VbufConcInteger( // CONCATENATE INTEGER # TO vbuf->buf
VBUF *vbuf, // - VBUF structure
int value ) // - value to be concatenated
{
char buffer[16]; // - temp buffer
stxicpy( buffer, value );
VbufConcStr( vbuf, buffer );
}
void VbufConcDecimal( // CONCATENATE DECIMAL # TO vbuf->buf
VBUF *vbuf, // - VBUF structure
unsigned value ) // - value to be concatenated
{
char buffer[16]; // - temp buffer
stxdcpy( buffer, value );
VbufConcStr( vbuf, buffer );
}
void VbufConcI64( // CONCATENATE I64 # TO vbuf->buf
VBUF *vbuf, // - VBUF structure
signed_64 value ) // - value to be concatenated
{
char buffer[25]; // - temp buffer
stxi64cpy( buffer, value );
VbufConcStr( vbuf, buffer );
}
// this prints grammatically correct messages.
// i.e. no errors, or 1 error, or 5 errors
static void intPrint // PRINT INT LINE SEGMENT
( VBUF *buf
, char *thing
, char *end
, unsigned int count )
{
if( count == 0 ) {
VbufConcStr( buf, "no " );
} else {
VbufConcDecimal( buf, count );
VbufConcChr( buf, ' ' );
}
VbufConcStr( buf, thing );
if( count != 1 ) {
VbufConcChr( buf, 's' );
}
VbufConcStr( buf, end );
}
static char *doFormatSym( SYMBOL sym, VBUF *pvbuf, FMT_CONTROL control )
{
VbufInit( pvbuf );
if( sym == NULL ) {
VbufConcStr( pvbuf, nullSymbol );
return( VbufString( pvbuf ) );
} else {
return( strrev( formatScopedSym( sym, pvbuf, control ) ) );
}
}
static void doFormatSym( SYMBOL sym, VBUF *pvbuf, FMT_CONTROL control )
{
VbufInit( pvbuf );
if( sym == NULL ) {
VbufConcStr( pvbuf, nullSymbol );
} else {
formatScopedSym( sym, pvbuf, control );
strrev( VbufString( pvbuf ) );
}
}
char *DbgSymNameFull( // GET FULL SYMBOL NAME
SYMBOL sym, // - symbol
VBUF *vbuf ) // - variable-sized buffer
{
if( sym != NULL ) {
return( FormatSym( sym, vbuf ) );
}
VbufInit( vbuf );
VbufConcStr( vbuf, "**NULL**" );
return( VbufString( vbuf ) );
}
static bool formatClassForSym( SYMBOL sym, VBUF *buf )
/****************************************************/
{
CLASSINFO *info; // - class information for symbol
bool retn = FALSE; // - return: TRUE ==> is class member
NAME name; // - class name
info = SymClassInfo( sym );
if( info != NULL ) {
name = info->name;
if( name != NULL ) {
VbufConcStr( buf, NameStr( name ) );
retn = TRUE;
}
}
return retn;
}
void MsgDisplayLineArgs // DISPLAY A BARE LINE, FROM ARGUMENTS
( char* seg // - the line segments
, ... )
{
va_list args; // - arg list
char* str; // - current segment
VBUF buffer; // - buffer
VbufInit( &buffer );
va_start( args, seg );
for( str = seg; str != NULL; str = va_arg( args, char* ) ) {
VbufConcStr( &buffer, str );
}
ideDisplay( IDEMSGSEV_NOTE_MSG, 0, VbufString( &buffer ), NULL );
va_end( args );
VbufFree( &buffer );
}
static void makeUnknownTemplate( VBUF *parms )
{
VbufConcStr( parms, templateParmStart );
VbufConcStr( parms, templateParmUnknown );
VbufConcStr( parms, templateParmStop );
}
SYMBOL FormatMsg( VBUF *pbuf, char *fmt, va_list arg )
/****************************************************/
// this function assumes that pbuf is initialized
// all information is concatenated to the end of pbuf
{
VBUF prefix, suffix;
char cfmt;
char local_buf[ 1 + sizeof( int ) * 2 + 1 ];
unsigned len;
SYMBOL retn_symbol;
retn_symbol = NULL;
cfmt = *fmt;
while( cfmt ) {
if( cfmt == '%' ) {
fmt++;
cfmt = *fmt;
switch( cfmt ) {
case '1': /* %01d */
case '2': /* %02d */
case '3': /* %03d */
case '4': /* %04d */
case '5': /* %05d */
case '6': /* %06d */
case '7': /* %07d */
case '8': /* %08d */
case '9': /* %09d */
len = sticpy( local_buf, va_arg( arg, int ) ) - local_buf;
leading( pbuf, '0', ( cfmt - '0' ) - len );
VbufConcStr( pbuf, local_buf );
break;
case 'c': /* %c */
VbufConcChr( pbuf, va_arg( arg, int ) );
break;
case 's': /* %s */
VbufConcStr( pbuf, va_arg( arg, char * ) );
break;
case 'u': /* %u */
VbufConcDecimal( pbuf, va_arg( arg, unsigned int ) );
break;
case 'd': /* %d */
VbufConcInteger( pbuf, va_arg( arg, int ) );
break;
case 'L': /* token location */
{ TOKEN_LOCN *locn;
locn = va_arg( arg, TOKEN_LOCN * );
if( locn == NULL ) {
VbufConcStr( pbuf, "by compiler" );
} else {
char *src_file = SrcFileName( locn->src_file );
if( src_file == NULL ) {
VbufConcStr( pbuf, "on the command line" );
} else {
if( ( CompFlags.ew_switch_used )
&&( locn->src_file == SrcFileTraceBackFile() ) ) {
VbufConcStr( pbuf, "at: " );
} else {
VbufConcStr( pbuf, "in: " );
VbufConcStr( pbuf, SrcFileName( locn->src_file ) );
}
VbufConcChr( pbuf, '(' );
VbufConcInteger( pbuf, locn->line );
if( locn->column ) {
if( CompFlags.ew_switch_used ) {
VbufConcChr( pbuf, ',' );
VbufConcInteger( pbuf, locn->column );
} else {
VbufConcStr( pbuf, ") (col " );
VbufConcInteger( pbuf, locn->column );
}
}
VbufConcChr( pbuf, ')' );
}
}
} break;
case 'N': /* name */
FormatName( va_arg( arg, NAME ), &prefix );
VbufConcVbuf( pbuf, &prefix );
VbufFree( &prefix );
break;
case 'F': /* symbol name (decorated) */
{ SYMBOL sym;
sym = va_arg( arg, SYMBOL );
FormatSym( sym, &prefix );
VbufConcVbuf( pbuf, &prefix );
VbufFree( &prefix );
} break;
case 'S': /* symbol name (abbreviated) */
{ SYMBOL sym;
SYMBOL_NAME sn;
NAME name;
sym = va_arg( arg, SYMBOL );
if( sym == NULL ) {
VbufConcStr( pbuf, "module data" );
} else {
if( formatClassForSym( sym, pbuf ) ) {
VbufConcStr( pbuf, "::" );
}
if( SymIsCtor( sym ) ) {
formatClassForSym( sym, pbuf );
} else if( SymIsDtor( sym ) ) {
VbufConcChr( pbuf, '~' );
formatClassForSym( sym, pbuf );
} else {
sn = sym->name;
#ifndef NDEBUG
if( sn == NULL ) {
CFatal( "FormatMsg -- %S symbol has NULL SYMBOL_NAME" );
}
#endif
name = sn->name;
#ifndef NDEBUG
if( name == NULL ) {
CFatal( "FormatMsg -- %S SYMBOL_NAME has NULL name" );
}
#endif
if( name == CppConversionName() ) {
VbufConcStr( pbuf, "operator " );
FormatType( SymFuncReturnType( sym )
, &prefix
, &suffix );
VbufFree( &suffix );
} else {
FormatName( name, &prefix );
}
VbufConcVbuf( pbuf, &prefix );
VbufFree( &prefix );
}
if( sym->flag2 & SF2_TOKEN_LOCN ) {
DbgVerify( retn_symbol == NULL, "too many symbols" );
retn_symbol = sym;
}
}
} break;
case 'T': /* type name */
{ TYPE type = va_arg( arg, TYPE );
TYPE refed = TypeReference( type );
if( NULL != refed ) {
type = refed;
}
FormatType( type, &prefix, &suffix );
VbufConcVbuf( pbuf, &prefix );
VbufConcVbuf( pbuf, &suffix );
VbufFree( &prefix );
VbufFree( &suffix );
VbufTruncWhite( pbuf );
if( NULL != refed ) {
VbufConcStr( pbuf, " (lvalue)" );
}
} break;
case 'P': /* PTREE list */
{ const PTREE p = va_arg( arg, PTREE );
FormatPTreeList( p, &prefix );
VbufConcVbuf( pbuf, &prefix );
VbufFree( &prefix );
} break;
case 'I': /* PTREE id */
{ const PTREE p = va_arg( arg, PTREE );
FormatPTreeId( p, &prefix );
VbufConcVbuf( pbuf, &prefix );
VbufFree( &prefix );
} break;
case 'M': /* template info */
{ TEMPLATE_INFO * const tinfo = va_arg( arg, TEMPLATE_INFO * );
const SYMBOL sym = tinfo->sym;
FormatTemplateInfo( tinfo, &prefix );
VbufConcVbuf( pbuf, &prefix );
VbufFree( &prefix );
if( sym->flag2 & SF2_TOKEN_LOCN ) {
DbgVerify( retn_symbol == NULL, "too many symbols" );
retn_symbol = sym;
}
} break;
case 'C': /* template specialisation */
{ TEMPLATE_SPECIALIZATION * const tspec =
va_arg( arg, TEMPLATE_SPECIALIZATION * );
FormatTemplateSpecialization( tspec, &prefix );
VbufConcVbuf( pbuf, &prefix );
VbufFree( &prefix );
} break;
default:
VbufConcChr( pbuf, cfmt );
}
} else {
void DumpObjectModelEnum( // DUMP OBJECT MODEL: ENUM
TYPE type ) // - enum type
{
SYMBOL sym; // - current symbol
TYPE base; // - base type
VBUF buffer; // - printing buffer
char buf[16]; // - buffer
int numb; // - a numeric value
const char *name; // - name to be printed
bool sign; // - TRUE ==> signed enum
unsigned mask; // - used to mask to true size
unsigned val; // - value as unsigned
CompFlags.log_note_msgs = TRUE;
base = TypedefModifierRemoveOnly( type );
sym = base->u.t.sym;
VbufInit( &buffer );
VbufConcStr( &buffer, "Object Model for: " );
if( NULL == sym->name->name || NameStr( sym->name->name )[0] == '.' ) {
VbufConcStr( &buffer, "anonymous enum type" );
} else {
VbufConcStr( &buffer, NameStr( sym->name->name ) );
}
switch( TypedefModifierRemove( base->of ) -> id ) {
case TYP_CHAR :
case TYP_UCHAR :
name = "unsigned char";
sign = FALSE;
break;
case TYP_SCHAR :
name = "signed char";
sign = TRUE;
break;
case TYP_SSHORT :
name = "signed short";
sign = TRUE;
break;
case TYP_USHORT :
name = "unsigned short";
sign = FALSE;
break;
case TYP_SINT :
name = "signed int";
sign = TRUE;
break;
case TYP_UINT :
name = "unsigned int";
sign = FALSE;
break;
case TYP_SLONG :
name = "signed long";
sign = TRUE;
break;
case TYP_ULONG :
name = "unsigned long";
sign = FALSE;
break;
case TYP_SLONG64 :
name = "__int64";
sign = TRUE;
break;
case TYP_ULONG64 :
name = "unsigned __int64";
sign = FALSE;
break;
DbgDefault( "DumpObjectModelEnum -- bad underlying type" );
}
VbufConcStr( &buffer, ", base type is " );
VbufConcStr( &buffer, name );
vbufWrite( &buffer );
mask = CgMemorySize( base );
if( mask == sizeof( unsigned ) ) {
mask = -1;
} else {
mask = ( 1 << ( mask * 8 ) ) - 1;
}
for( ; ; ) {
sym = sym->thread;
if( ! SymIsEnumeration( sym ) ) break;
VbufRewind( &buffer );
VbufConcStr( &buffer, " " );
VbufConcStr( &buffer, NameStr( sym->name->name ) );
VbufConcStr( &buffer, " = " );
numb = sym->u.sval;
if( sign && numb < 0 ) {
VbufConcChr( &buffer, '-' );
VbufConcDecimal( &buffer, -numb );
} else {
VbufConcDecimal( &buffer, numb );
}
val = mask & numb;
if( val > 10 ) {
itoa( val, buf, 16 );
VbufConcStr( &buffer, " /0x" );
VbufConcStr( &buffer, buf );
}
vbufWrite( &buffer );
}
VbufFree( &buffer );
CompFlags.log_note_msgs = FALSE;
}
