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; }