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 ); } }
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 ); }
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 VbufConcDecimal( &di->buffer, numb ); if( numb >= 10 ) { itoa( numb, buf, 16 ); di = bufferStr( di, "/0x" ); di = bufferStr( di, buf ); } return di; }
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 ); }
// 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 ); }
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; }