void GameOverState::draw(CL_GraphicContext& gc)
{
MenuState::draw(gc);
if(_is_highscore)
{
std::string new_score = format_number(to_string(_p_common_resources -> highscore));
std::string old_score = format_number(to_string(_p_common_resources -> old_highscore));
int new_score_real_x = _score1_x -
_p_common_resources -> main_font.get_text_size(gc, new_score).width / 2;
int old_score_real_x = _score2_x -
_p_common_resources -> main_font.get_text_size(gc, old_score).width / 2;
_p_common_resources -> main_font.draw_text(gc, new_score_real_x, _score1_y, new_score);
_p_common_resources -> main_font.draw_text(gc, old_score_real_x, _score2_y, old_score);
}
else
{
std::string current_score = format_number(to_string(_p_common_resources -> player1.get_score()));
std::string highscore = format_number(to_string(_p_common_resources -> highscore));
int score1_real_x = _score1_x -
_p_common_resources -> main_font.get_text_size(gc, current_score).width / 2;
int score2_real_x = _score2_x -
_p_common_resources -> main_font.get_text_size(gc, highscore).width / 2;
_p_common_resources -> main_font.draw_text(gc, score1_real_x, _score1_y, current_score);
_p_common_resources -> main_font.draw_text(gc, score2_real_x, _score2_y, highscore);
}
}
void format_number(string s, u64 x, int base, int pad)
{
if ((x > 0) || (pad > 0)) {
format_number(s, x/base, base, pad - 1);
string_insert(s, hex_digits[x%base]);
}
}
/* Write an hexadecimal into a buffer, isCap is true for capital alphas.
* Assumes bufsize > 2 */
static void
format_hex(char *buffer, size_t buffsize, uint64_t value, int isCap)
{
const char *digits = isCap ? "0123456789ABCDEF" : "0123456789abcdef";
format_number(buffer, buffsize, value, 16, digits);
}
static void PrintSummary(stat_record_t *stat_record, int plain_numbers, int csv_output) {
static double duration;
uint64_t bps, pps, bpp;
char byte_str[NUMBER_STRING_SIZE], packet_str[NUMBER_STRING_SIZE];
char bps_str[NUMBER_STRING_SIZE], pps_str[NUMBER_STRING_SIZE], bpp_str[NUMBER_STRING_SIZE];
bps = pps = bpp = 0;
if ( stat_record->last_seen ) {
duration = stat_record->last_seen - stat_record->first_seen;
duration += ((double)stat_record->msec_last - (double)stat_record->msec_first) / 1000.0;
} else {
// no flows to report
duration = 0;
}
if ( duration > 0 && stat_record->last_seen > 0 ) {
bps = ( stat_record->numbytes << 3 ) / duration; // bits per second. ( >> 3 ) -> * 8 to convert octets into bits
pps = stat_record->numpackets / duration; // packets per second
bpp = stat_record->numpackets ? stat_record->numbytes / stat_record->numpackets : 0; // Bytes per Packet
}
if ( csv_output ) {
printf("Summary\n");
printf("flows,bytes,packets,avg_bps,avg_pps,avg_bpp\n");
printf("%llu,%llu,%llu,%llu,%llu,%llu\n",
(long long unsigned)stat_record->numflows, (long long unsigned)stat_record->numbytes,
(long long unsigned)stat_record->numpackets, (long long unsigned)bps,
(long long unsigned)pps, (long long unsigned)bpp );
} else if ( plain_numbers ) {
printf("Summary: total flows: %llu, total bytes: %llu, total packets: %llu, avg bps: %llu, avg pps: %llu, avg bpp: %llu\n",
(long long unsigned)stat_record->numflows, (long long unsigned)stat_record->numbytes,
(long long unsigned)stat_record->numpackets, (long long unsigned)bps,
(long long unsigned)pps, (long long unsigned)bpp );
} else {
format_number(stat_record->numbytes, byte_str, DONT_SCALE_NUMBER, VAR_LENGTH);
format_number(stat_record->numpackets, packet_str, DONT_SCALE_NUMBER, VAR_LENGTH);
format_number(bps, bps_str, DONT_SCALE_NUMBER, VAR_LENGTH);
format_number(pps, pps_str, DONT_SCALE_NUMBER, VAR_LENGTH);
format_number(bpp, bpp_str, DONT_SCALE_NUMBER, VAR_LENGTH);
printf("Summary: total flows: %llu, total bytes: %s, total packets: %s, avg bps: %s, avg pps: %s, avg bpp: %s\n",
(unsigned long long)stat_record->numflows, byte_str, packet_str, bps_str, pps_str, bpp_str );
}
} // End of PrintSummary
static void
append_number_to_gstring(GwyValueFormat *format,
GString *str,
gdouble value)
{
format_number(format, str, value);
ValueFormat *priv = format->priv;
if (priv->style == GWY_VALUE_FORMAT_PANGO)
fix_utf8_minus(str);
}
/* Write an integer (octal or decimal) into a buffer, assumes buffsize > 2 */
static void
format_integer(char *buffer, size_t buffsize, uint64_t value, int base, int isSigned)
{
if (isSigned && (int64_t)value < 0) {
buffer[0] = '-';
buffer += 1;
buffsize -= 1;
value = (uint64_t)(-(int64_t)value);
}
format_number(buffer, buffsize, value, base, "0123456789");
}
void format_number( output_func_t output, void* ptr, unsigned int number )
{
static char digit_chars[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
int digit = number % 10;
int remainder = number / 10;
if( remainder > 0 )
{
format_number( output, ptr, remainder );
}
output( digit_chars[digit], ptr );
}
/*
* Format a basic 512-byte "v7tar" header.
*
* Returns -1 if format failed (due to field overflow).
* Note that this always formats as much of the header as possible.
* If "strict" is set to zero, it will extend numeric fields as
* necessary (overwriting terminators or using base-256 extensions).
*
*/
static int
format_header_v7tar(struct archive_write *a, char h[512],
struct archive_entry *entry, int strict,
struct archive_string_conv *sconv)
{
unsigned int checksum;
int i, r, ret;
size_t copy_length;
const char *p, *pp;
int mytartype;
ret = 0;
mytartype = -1;
/*
* The "template header" already includes the "v7tar"
* signature, various end-of-field markers and other required
* elements.
*/
memcpy(h, &template_header, 512);
/*
* Because the block is already null-filled, and strings
* are allowed to exactly fill their destination (without null),
* I use memcpy(dest, src, strlen()) here a lot to copy strings.
*/
r = archive_entry_pathname_l(entry, &pp, ©_length, sconv);
if (r != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Pathname");
return (ARCHIVE_FATAL);
}
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Can't translate pathname '%s' to %s",
pp, archive_string_conversion_charset_name(sconv));
ret = ARCHIVE_WARN;
}
if (strict && copy_length < V7TAR_name_size)
memcpy(h + V7TAR_name_offset, pp, copy_length);
else if (!strict && copy_length <= V7TAR_name_size)
memcpy(h + V7TAR_name_offset, pp, copy_length);
else {
/* Prefix is too long. */
archive_set_error(&a->archive, ENAMETOOLONG,
"Pathname too long");
ret = ARCHIVE_FAILED;
}
r = archive_entry_hardlink_l(entry, &p, ©_length, sconv);
if (r != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Linkname");
return (ARCHIVE_FATAL);
}
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Can't translate linkname '%s' to %s",
p, archive_string_conversion_charset_name(sconv));
ret = ARCHIVE_WARN;
}
if (copy_length > 0)
mytartype = '1';
else {
r = archive_entry_symlink_l(entry, &p, ©_length, sconv);
if (r != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Linkname");
return (ARCHIVE_FATAL);
}
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Can't translate linkname '%s' to %s",
p, archive_string_conversion_charset_name(sconv));
ret = ARCHIVE_WARN;
}
}
if (copy_length > 0) {
if (copy_length >= V7TAR_linkname_size) {
archive_set_error(&a->archive, ENAMETOOLONG,
"Link contents too long");
ret = ARCHIVE_FAILED;
copy_length = V7TAR_linkname_size;
}
memcpy(h + V7TAR_linkname_offset, p, copy_length);
}
if (format_number(archive_entry_mode(entry) & 07777,
h + V7TAR_mode_offset, V7TAR_mode_size,
V7TAR_mode_max_size, strict)) {
archive_set_error(&a->archive, ERANGE,
"Numeric mode too large");
ret = ARCHIVE_FAILED;
}
if (format_number(archive_entry_uid(entry),
h + V7TAR_uid_offset, V7TAR_uid_size, V7TAR_uid_max_size, strict)) {
archive_set_error(&a->archive, ERANGE,
"Numeric user ID too large");
ret = ARCHIVE_FAILED;
}
if (format_number(archive_entry_gid(entry),
h + V7TAR_gid_offset, V7TAR_gid_size, V7TAR_gid_max_size, strict)) {
archive_set_error(&a->archive, ERANGE,
"Numeric group ID too large");
ret = ARCHIVE_FAILED;
}
if (format_number(archive_entry_size(entry),
h + V7TAR_size_offset, V7TAR_size_size,
V7TAR_size_max_size, strict)) {
archive_set_error(&a->archive, ERANGE,
"File size out of range");
ret = ARCHIVE_FAILED;
}
if (format_number(archive_entry_mtime(entry),
h + V7TAR_mtime_offset, V7TAR_mtime_size,
V7TAR_mtime_max_size, strict)) {
archive_set_error(&a->archive, ERANGE,
"File modification time too large");
ret = ARCHIVE_FAILED;
}
if (mytartype >= 0) {
h[V7TAR_typeflag_offset] = mytartype;
} else {
switch (archive_entry_filetype(entry)) {
case AE_IFREG: case AE_IFDIR:
break;
case AE_IFLNK:
h[V7TAR_typeflag_offset] = '2';
break;
case AE_IFCHR:
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"tar format cannot archive character device");
return (ARCHIVE_FAILED);
case AE_IFBLK:
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"tar format cannot archive block device");
return (ARCHIVE_FAILED);
case AE_IFIFO:
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"tar format cannot archive fifo");
return (ARCHIVE_FAILED);
case AE_IFSOCK:
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"tar format cannot archive socket");
return (ARCHIVE_FAILED);
default:
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"tar format cannot archive this (mode=0%lo)",
(unsigned long)archive_entry_mode(entry));
ret = ARCHIVE_FAILED;
}
}
checksum = 0;
for (i = 0; i < 512; i++)
checksum += 255 & (unsigned int)h[i];
format_octal(checksum, h + V7TAR_checksum_offset, 6);
/* Can't be pre-set in the template. */
h[V7TAR_checksum_offset + 6] = '\0';
return (ret);
}
wxInt32 CViewProjects::FormatResourceShare(double share, double share_pct, wxString& strBuffer) const {
strBuffer.Printf(wxT("%s (%s%%)"), format_number(share, 0), format_number(share_pct, 2));
return 0;
}
void vbprintf(string s, string fmt, va_list ap)
{
character i;
int state = 0;
int base = 0;
int pad;
int count = 0;
string_foreach(fmt, i) {
switch (state){
case 2:
for (int j = 0; j < count; j++)
string_insert(s, i);
state = 0;
break;
case 0:
base = 10;
pad = 0;
if (i == '%') state = 3;
else string_insert(s, i);
break;
case 1:
if ((i >= '0') && (i <= '9')) {
pad = pad * 10 + digit_of(i);
break;
} else {
state = 3;
}
case 3:
switch (i) {
case '0':
state = 1;
break;
case '%':
string_insert(s, '\%');
break;
case 't':
print_time(s, va_arg(ap, ticks));
break;
case 'b':
string_concat(s, (va_arg(ap, string)));
break;
case 'n':
count = va_arg(ap, unsigned int);
state = 2;
break;
case 'c':
string_insert(s, va_arg(ap, int));
break;
case 's':
{
char *c = va_arg(ap, char *);
if (!c) c = (char *)"(null)";
int len = cstring_length(c);
for (int i =0 ; i < pad; i++)
string_insert(s, ' ');
pad = 0;
for (; *c; c++)
string_insert(s, *c);
}
break;
case 'S':
{
unsigned int x = va_arg(ap, unsigned int);
for (int i =0 ; i < x; i++) string_insert(s, ' ');
break;
}
case 'p':
pad = 16;
unsigned long x = va_arg(ap, unsigned long);
format_number(s, x, 16, pad?pad:1);
break;
case 'l':
pad = 0;
unsigned long z = va_arg(ap, unsigned long);
format_number(s, z, 10, pad?pad:1);
break;
case 'x':
base=16;
case 'o':
if (base == 10) base=8;
case 'u':
{
unsigned int x = va_arg(ap, unsigned int);
format_number(s, x, base, pad?pad:1);
break;
}
// xxx - layer violation..meh
// also generalize string pad support
case 'v':
if (pad) {
// xxx transient or resizable stack head
buffer b = allocate_string(s->h);
print_value(b, va_arg(ap, void *));
// xxx utf token length
for (int i =0 ; i < (pad-buffer_length(b)); i++) string_insert(s, ' ');
buffer_append(s, bref(b, 0), buffer_length(b));
pad = 0;
state = 0;
} else print_value(s, va_arg(ap, void *));
break;
case 'r':
if (pad) {
// xxx transient or resizable stack head
buffer b = allocate_string(s->h);
print_value_raw(b, va_arg(ap, void *));
// xxx utf token length
for (int i =0 ; i < (pad-buffer_length(b)); i++) string_insert(s, ' ');
buffer_append(s, bref(b, 0), buffer_length(b));
pad = 0;
state = 0;
} else print_value_raw(s, va_arg(ap, void *));
break;
case 'V':
print_value_vector(s, va_arg(ap, void *));
break;
case 'X':
// xxx - utf8 will break this
{
buffer xx = va_arg(ap, buffer);
string_foreach(xx, i){
print_byte(s, i);
}
}
break;
case 'd': case 'i':
{
int x = va_arg(ap, int);
if (x <0){
string_insert(s, '-');
x = -x;
}
format_number(s, (unsigned int)x, base, pad?pad:1);
break;
}
default:
break;
}
// badness
if (state == 3)
state = 0;
break;
}
}
void CSimpleProjectPanel::UpdateInterface() {
int n, count = -1;
bool b_needMenuRebuild = false;
wxString str = wxEmptyString;
wxString projName = wxEmptyString;
CMainDocument* pDoc = wxGetApp().GetDocument();
wxASSERT(pDoc);
// Should we display the synchronize button instead of the
// attach to project button?
if ( pDoc->IsConnected() ) {
CC_STATUS status;
int is_acct_mgr_detected = 0;
pDoc->GetCoreClientStatus(status);
if (pDoc->m_iAcct_mgr_info_rpc_result == 0) {
// We use an integer rather than a bool to force action the first time
is_acct_mgr_detected = pDoc->ami.acct_mgr_url.size() ? 1 : 0;
if ((m_UsingAccountManager != is_acct_mgr_detected) || (!m_TaskAddProjectButton->IsEnabled())) {
m_UsingAccountManager = is_acct_mgr_detected;
if (is_acct_mgr_detected) {
m_TaskAddProjectButton->SetLabel(m_sSynchronizeString);
m_TaskAddProjectButton->Enable();
m_TaskAddProjectButton->SetToolTip(m_sSynchronizeToolTip);
} else {
m_TaskAddProjectButton->SetLabel(m_sAddProjectString);
if (!status.disallow_attach) {
m_TaskAddProjectButton->Enable();
m_TaskAddProjectButton->SetToolTip(m_sAddProjectToolTip);
}
}
this->Layout();
}
} else {
m_TaskAddProjectButton->Disable();
}
UpdateProjectList();
count = m_ProjectSelectionCtrl->GetCount();
}
if (count > 0) {
n = m_ProjectSelectionCtrl->GetSelection();
if ((n < 0) || (n > count -1)) {
m_ProjectSelectionCtrl->SetSelection(0);
n = 0;
}
// Check to see if we need to rebuild the menu
char* ctrl_url = ((ProjectSelectionData*)m_ProjectSelectionCtrl->GetClientData(n))->project_url;
if (strcmp(m_CurrentSelectedProjectURL, ctrl_url)) {
b_needMenuRebuild = true;
strncpy(m_CurrentSelectedProjectURL, ctrl_url, sizeof(m_CurrentSelectedProjectURL));
}
PROJECT* project = pDoc->state.lookup_project(ctrl_url);
if ( project != NULL && project->last_rpc_time > m_Project_last_rpc_time ) {
b_needMenuRebuild = true;
m_Project_last_rpc_time = project->last_rpc_time;
}
if (b_needMenuRebuild) {
m_ProjectWebSitesButton->RebuildMenu();
}
m_ProjectWebSitesButton->Enable();
m_ProjectCommandsButton->Enable();
if (m_fDisplayedCredit != project->user_total_credit) {
str.Printf(wxT("%s: %s"),
m_sTotalWorkDoneString.c_str(),
format_number(project->user_total_credit, 0)
);
UpdateStaticText(&m_TotalCreditValue, str);
m_TotalCreditValue->SetName(str); // For accessibility on Windows
}
projName = m_ProjectSelectionCtrl->GetStringSelection();
str.Printf(_("Pop up a menu of web sites for project %s"), projName.c_str());
m_ProjectWebSitesButton->SetToolTip(str);
str.Printf(_("Pop up a menu of commands to apply to project %s"), projName.c_str());
m_ProjectCommandsButton->SetToolTip(str);
} else {
m_ProjectWebSitesButton->Disable();
m_ProjectCommandsButton->Disable();
m_CurrentSelectedProjectURL[0] = '\0';
m_fDisplayedCredit = -1.0;
UpdateStaticText(&m_TotalCreditValue, wxEmptyString);
m_TotalCreditValue->SetName(wxEmptyString); // For accessibility on Windows
m_ProjectWebSitesButton->SetToolTip(wxEmptyString);
m_ProjectCommandsButton->SetToolTip(wxEmptyString);
}
}
/*
* Format a basic 512-byte "ustar" header.
*
* Returns -1 if format failed (due to field overflow).
* Note that this always formats as much of the header as possible.
* If "strict" is set to zero, it will extend numeric fields as
* necessary (overwriting terminators or using base-256 extensions).
*
* This is exported so that other 'tar' formats can use it.
*/
int
__archive_write_format_header_ustar(struct archive_write *a, char h[512],
struct archive_entry *entry, int tartype, int strict)
{
unsigned int checksum;
int i, ret;
size_t copy_length;
const char *p, *pp;
int mytartype;
ret = 0;
mytartype = -1;
/*
* The "template header" already includes the "ustar"
* signature, various end-of-field markers and other required
* elements.
*/
memcpy(h, &template_header, 512);
/*
* Because the block is already null-filled, and strings
* are allowed to exactly fill their destination (without null),
* I use memcpy(dest, src, strlen()) here a lot to copy strings.
*/
pp = tk_archive_entry_pathname(entry);
if (strlen(pp) <= USTAR_name_size)
memcpy(h + USTAR_name_offset, pp, strlen(pp));
else {
/* Store in two pieces, splitting at a '/'. */
p = strchr(pp + strlen(pp) - USTAR_name_size - 1, '/');
/*
* Look for the next '/' if we chose the first character
* as the separator. (ustar format doesn't permit
* an empty prefix.)
*/
if (p == pp)
p = strchr(p + 1, '/');
/* Fail if the name won't fit. */
if (!p) {
/* No separator. */
tk_archive_set_error(&a->archive, ENAMETOOLONG,
"Pathname too long");
ret = ARCHIVE_FAILED;
} else if (p[1] == '\0') {
/*
* The only feasible separator is a final '/';
* this would result in a non-empty prefix and
* an empty name, which POSIX doesn't
* explicity forbid, but it just feels wrong.
*/
tk_archive_set_error(&a->archive, ENAMETOOLONG,
"Pathname too long");
ret = ARCHIVE_FAILED;
} else if (p > pp + USTAR_prefix_size) {
/* Prefix is too long. */
tk_archive_set_error(&a->archive, ENAMETOOLONG,
"Pathname too long");
ret = ARCHIVE_FAILED;
} else {
/* Copy prefix and remainder to appropriate places */
memcpy(h + USTAR_prefix_offset, pp, p - pp);
memcpy(h + USTAR_name_offset, p + 1, pp + strlen(pp) - p - 1);
}
}
p = tk_archive_entry_hardlink(entry);
if (p != NULL)
mytartype = '1';
else
p = tk_archive_entry_symlink(entry);
if (p != NULL && p[0] != '\0') {
copy_length = strlen(p);
if (copy_length > USTAR_linkname_size) {
tk_archive_set_error(&a->archive, ENAMETOOLONG,
"Link contents too long");
ret = ARCHIVE_FAILED;
copy_length = USTAR_linkname_size;
}
memcpy(h + USTAR_linkname_offset, p, copy_length);
}
p = tk_archive_entry_uname(entry);
if (p != NULL && p[0] != '\0') {
copy_length = strlen(p);
if (copy_length > USTAR_uname_size) {
tk_archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Username too long");
ret = ARCHIVE_FAILED;
copy_length = USTAR_uname_size;
}
memcpy(h + USTAR_uname_offset, p, copy_length);
}
p = tk_archive_entry_gname(entry);
if (p != NULL && p[0] != '\0') {
copy_length = strlen(p);
if (strlen(p) > USTAR_gname_size) {
tk_archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Group name too long");
ret = ARCHIVE_FAILED;
copy_length = USTAR_gname_size;
}
memcpy(h + USTAR_gname_offset, p, copy_length);
}
if (format_number(tk_archive_entry_mode(entry) & 07777, h + USTAR_mode_offset, USTAR_mode_size, USTAR_mode_max_size, strict)) {
tk_archive_set_error(&a->archive, ERANGE, "Numeric mode too large");
ret = ARCHIVE_FAILED;
}
if (format_number(tk_archive_entry_uid(entry), h + USTAR_uid_offset, USTAR_uid_size, USTAR_uid_max_size, strict)) {
tk_archive_set_error(&a->archive, ERANGE, "Numeric user ID too large");
ret = ARCHIVE_FAILED;
}
if (format_number(tk_archive_entry_gid(entry), h + USTAR_gid_offset, USTAR_gid_size, USTAR_gid_max_size, strict)) {
tk_archive_set_error(&a->archive, ERANGE, "Numeric group ID too large");
ret = ARCHIVE_FAILED;
}
if (format_number(tk_archive_entry_size(entry), h + USTAR_size_offset, USTAR_size_size, USTAR_size_max_size, strict)) {
tk_archive_set_error(&a->archive, ERANGE, "File size out of range");
ret = ARCHIVE_FAILED;
}
if (format_number(tk_archive_entry_mtime(entry), h + USTAR_mtime_offset, USTAR_mtime_size, USTAR_mtime_max_size, strict)) {
tk_archive_set_error(&a->archive, ERANGE,
"File modification time too large");
ret = ARCHIVE_FAILED;
}
if (tk_archive_entry_filetype(entry) == AE_IFBLK
|| tk_archive_entry_filetype(entry) == AE_IFCHR) {
if (format_number(tk_archive_entry_rdevmajor(entry), h + USTAR_rdevmajor_offset,
USTAR_rdevmajor_size, USTAR_rdevmajor_max_size, strict)) {
tk_archive_set_error(&a->archive, ERANGE,
"Major device number too large");
ret = ARCHIVE_FAILED;
}
if (format_number(tk_archive_entry_rdevminor(entry), h + USTAR_rdevminor_offset,
USTAR_rdevminor_size, USTAR_rdevminor_max_size, strict)) {
tk_archive_set_error(&a->archive, ERANGE,
"Minor device number too large");
ret = ARCHIVE_FAILED;
}
}
if (tartype >= 0) {
h[USTAR_typeflag_offset] = tartype;
} else if (mytartype >= 0) {
h[USTAR_typeflag_offset] = mytartype;
} else {
switch (tk_archive_entry_filetype(entry)) {
case AE_IFREG: h[USTAR_typeflag_offset] = '0' ; break;
case AE_IFLNK: h[USTAR_typeflag_offset] = '2' ; break;
case AE_IFCHR: h[USTAR_typeflag_offset] = '3' ; break;
case AE_IFBLK: h[USTAR_typeflag_offset] = '4' ; break;
case AE_IFDIR: h[USTAR_typeflag_offset] = '5' ; break;
case AE_IFIFO: h[USTAR_typeflag_offset] = '6' ; break;
case AE_IFSOCK:
tk_archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"tar format cannot archive socket");
return (ARCHIVE_FAILED);
default:
tk_archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"tar format cannot archive this (mode=0%lo)",
(unsigned long)tk_archive_entry_mode(entry));
ret = ARCHIVE_FAILED;
}
}
checksum = 0;
for (i = 0; i < 512; i++)
checksum += 255 & (unsigned int)h[i];
h[USTAR_checksum_offset + 6] = '\0'; /* Can't be pre-set in the template. */
/* h[USTAR_checksum_offset + 7] = ' '; */ /* This is pre-set in the template. */
format_octal(checksum, h + USTAR_checksum_offset, 6);
return (ret);
}
static int
archive_format_gnutar_header(struct archive_write *a, char h[512],
struct archive_entry *entry, int tartype)
{
unsigned int checksum;
int i, ret;
size_t copy_length;
const char *p;
struct gnutar *gnutar;
gnutar = (struct gnutar *)a->format_data;
ret = 0;
/*
* The "template header" already includes the signature,
* various end-of-field markers, and other required elements.
*/
memcpy(h, &template_header, 512);
/*
* Because the block is already null-filled, and strings
* are allowed to exactly fill their destination (without null),
* I use memcpy(dest, src, strlen()) here a lot to copy strings.
*/
if (tartype == 'K' || tartype == 'L') {
p = archive_entry_pathname(entry);
copy_length = strlen(p);
} else {
p = gnutar->pathname;
copy_length = gnutar->pathname_length;
}
if (copy_length > GNUTAR_name_size)
copy_length = GNUTAR_name_size;
memcpy(h + GNUTAR_name_offset, p, copy_length);
if ((copy_length = gnutar->linkname_length) > 0) {
if (copy_length > GNUTAR_linkname_size)
copy_length = GNUTAR_linkname_size;
memcpy(h + GNUTAR_linkname_offset, gnutar->linkname,
copy_length);
}
/* TODO: How does GNU tar handle unames longer than GNUTAR_uname_size? */
if (tartype == 'K' || tartype == 'L') {
p = archive_entry_uname(entry);
copy_length = strlen(p);
} else {
p = gnutar->uname;
copy_length = gnutar->uname_length;
}
if (copy_length > 0) {
if (copy_length > GNUTAR_uname_size)
copy_length = GNUTAR_uname_size;
memcpy(h + GNUTAR_uname_offset, p, copy_length);
}
/* TODO: How does GNU tar handle gnames longer than GNUTAR_gname_size? */
if (tartype == 'K' || tartype == 'L') {
p = archive_entry_gname(entry);
copy_length = strlen(p);
} else {
p = gnutar->gname;
copy_length = gnutar->gname_length;
}
if (copy_length > 0) {
if (strlen(p) > GNUTAR_gname_size)
copy_length = GNUTAR_gname_size;
memcpy(h + GNUTAR_gname_offset, p, copy_length);
}
/* By truncating the mode here, we ensure it always fits. */
format_octal(archive_entry_mode(entry) & 07777,
h + GNUTAR_mode_offset, GNUTAR_mode_size);
/* GNU tar supports base-256 here, so should never overflow. */
if (format_number(archive_entry_uid(entry), h + GNUTAR_uid_offset,
GNUTAR_uid_size, GNUTAR_uid_max_size)) {
archive_set_error(&a->archive, ERANGE,
"Numeric user ID %jd too large",
(intmax_t)archive_entry_uid(entry));
ret = ARCHIVE_FAILED;
}
/* GNU tar supports base-256 here, so should never overflow. */
if (format_number(archive_entry_gid(entry), h + GNUTAR_gid_offset,
GNUTAR_gid_size, GNUTAR_gid_max_size)) {
archive_set_error(&a->archive, ERANGE,
"Numeric group ID %jd too large",
(intmax_t)archive_entry_gid(entry));
ret = ARCHIVE_FAILED;
}
/* GNU tar supports base-256 here, so should never overflow. */
if (format_number(archive_entry_size(entry), h + GNUTAR_size_offset,
GNUTAR_size_size, GNUTAR_size_max_size)) {
archive_set_error(&a->archive, ERANGE,
"File size out of range");
ret = ARCHIVE_FAILED;
}
/* Shouldn't overflow before 2106, since mtime field is 33 bits. */
format_octal(archive_entry_mtime(entry),
h + GNUTAR_mtime_offset, GNUTAR_mtime_size);
if (archive_entry_filetype(entry) == AE_IFBLK
|| archive_entry_filetype(entry) == AE_IFCHR) {
if (format_octal(archive_entry_rdevmajor(entry),
h + GNUTAR_rdevmajor_offset,
GNUTAR_rdevmajor_size)) {
archive_set_error(&a->archive, ERANGE,
"Major device number too large");
ret = ARCHIVE_FAILED;
}
if (format_octal(archive_entry_rdevminor(entry),
h + GNUTAR_rdevminor_offset,
GNUTAR_rdevminor_size)) {
archive_set_error(&a->archive, ERANGE,
"Minor device number too large");
ret = ARCHIVE_FAILED;
}
}
h[GNUTAR_typeflag_offset] = tartype;
checksum = 0;
for (i = 0; i < 512; i++)
checksum += 255 & (unsigned int)h[i];
h[GNUTAR_checksum_offset + 6] = '\0'; /* Can't be pre-set in the template. */
/* h[GNUTAR_checksum_offset + 7] = ' '; */ /* This is pre-set in the template. */
format_octal(checksum, h + GNUTAR_checksum_offset, 6);
return (ret);
}
static void format_total_credit(double credit, wxString& strBuffer) {
strBuffer = format_number(credit, 0);
}
void
print_number (unsigned long num)
{
format_number (num);
printf ("%lu\t%s\n", num, buffer + bufoff);
}
int main()
{
struct viv_conn *conn = 0;
int rv;
rv = viv_open(VIV_HW_3D, &conn);
if(rv!=0)
{
fprintf(stderr, "Error opening device\n");
exit(1);
}
uint32_t num_profile_counters = viv_get_num_profile_counters();
/* XXX parameter parsing */
int samples_per_second = 100;
bool interactive = true;
int mode = MODE_ALL;
//int mode = MODE_SORTED;
bool color = true;
uint32_t *counter_data = calloc(num_profile_counters, 4);
uint32_t *counter_data_last = calloc(num_profile_counters, 4);
uint64_t *events_per_s = calloc(num_profile_counters, 8);
struct counter_rec *sorted = calloc(num_profile_counters, sizeof(struct counter_rec));
/* reset counters and initial values */
if(viv_read_profile_counters_3d(conn, counter_data_last) != 0)
{
fprintf(stderr, "Error querying counters (probably unsupported with this kernel, or not built into libetnaviv)\n");
exit(1);
}
uint32_t begin_time = gettime();
useconds_t interval = 1000000 / samples_per_second;
while(true)
{
/* Scale counters by real elapsed time */
for(int c=0; c<num_profile_counters; ++c)
{
events_per_s[c] = 0;
}
for(int sample=0; sample<samples_per_second; ++sample)
{
if(viv_read_profile_counters_3d(conn, counter_data) != 0)
{
fprintf(stderr, "Error querying counters (probably unsupported with this kernel, or not built into libetnaviv)\n");
exit(1);
}
for(int c=0; c<num_profile_counters; ++c)
{
/* some counters don't reset when read */
if(c == VIV_PROF_PS_INST_COUNTER ||
c == VIV_PROF_VS_INST_COUNTER ||
c == VIV_PROF_RENDERED_PIXEL_COUNTER ||
c == VIV_PROF_RENDERED_VERTICE_COUNTER ||
c == VIV_PROF_PXL_TEXLD_INST_COUNTER ||
c == VIV_PROF_PXL_BRANCH_INST_COUNTER ||
c == VIV_PROF_VTX_TEXLD_INST_COUNTER ||
c == VIV_PROF_VTX_BRANCH_INST_COUNTER ||
c == VIV_PROF_SE_CULLED_TRIANGLE_COUNT ||
c == VIV_PROF_SE_CULLED_LINES_COUNT)
events_per_s[c] += counter_data[c] - counter_data_last[c];
else
events_per_s[c] += counter_data[c];
}
for(int c=0; c<num_profile_counters; ++c)
counter_data_last[c] = counter_data[c];
usleep(interval);
}
uint32_t end_time = gettime();
uint32_t diff_time = end_time - begin_time;
/* Scale counters by real elapsed time */
for(int c=0; c<num_profile_counters; ++c)
{
events_per_s[c] = events_per_s[c] * 1000000LL / (uint64_t)diff_time;
}
/* Sort counters descending */
for(int c=0; c<num_profile_counters; ++c)
{
sorted[c].id = c;
sorted[c].events_per_s = events_per_s[c];
}
qsort(sorted, num_profile_counters, sizeof(struct counter_rec), &counter_rec_compar);
if(interactive)
{
int line = 0; /* current screen line */
printf("%s", clear_screen);
int max_lines = get_screen_lines() - line - 1;
if(mode == MODE_SORTED)
{
int count = (num_profile_counters > max_lines) ? max_lines : num_profile_counters;
for(int c=0; c<count; ++c)
{
char num[100];
struct viv_profile_counter_info *info = viv_get_profile_counter_info(sorted[c].id);
format_number(num, sizeof(num), sorted[c].events_per_s);
if(color)
printf("%s", sorted[c].events_per_s == 0 ? color_num_zero : color_num);
printf("%15.15s", num);
if(color)
printf("%s", color_reset);
printf(" ");
printf("%-30.30s", info->name);
printf("\n");
}
} else if(mode == MODE_ALL)
{
/* XXX check that width doesn't exceed screen width */
for(int l=0; l<max_lines; ++l)
{
int c = VIV_PROF_GPU_CYCLES_COUNTER + l;
while(c < num_profile_counters)
{
char num[100];
struct viv_profile_counter_info *info = viv_get_profile_counter_info(c);
format_number(num, sizeof(num), events_per_s[c]);
if(color)
printf("%s", events_per_s[c] == 0 ? color_num_zero : color_num);
printf("%15.15s", num);
if(color)
printf("%s", color_reset);
printf(" ");
printf("%-30.30s", info->name);
printf(" ");
c += max_lines;
}
printf("\n");
}
}
}
begin_time = end_time;
}
/*
* XXX define new mode MODE_OCCUPANCY and some derived percentage bars:
* - [PA] Number of primitives per vertex (max 1)
* - [PA] % of primitives culled
* - VS -> PA -> SE -> RA primitives/vertices in each stage
* - RA -> PS -> PE pixels/quads in each stage
* - Pixels per PS inst
* - Vertices per VS inst
* - % of texture requests trilinear/bilinear
* - overdraw (killed by depth)
*/
return 0;
}
int get_residue_range(char line[LINE_LEN +1],int *ipos,
char start_residue[6],char end_residue[6],char *chain,
int *end)
{
char residue_number[6], token[TOKEN_LEN + 1];
int ipstn;
int done, have_range, have_token;
/* Initialise chain-id */
*chain = ' ';
*end = FALSE;
start_residue[0] = '\0';
end_residue[0] = '\0';
done = FALSE;
have_range = FALSE;
ipstn = *ipos;
/* Loop until domain number found */
while (have_range == FALSE && done == FALSE && *ipos < LINE_LEN)
{
/* Get the next token from the line */
have_token = get_token(line,&ipstn,token,&done);
/* If have a valid token, then extract appropriate part of range */
if (have_token == TRUE)
{
/* Check that haven't found a range separator */
if (!strncmp(token,"&",1))
have_range = TRUE;
/* Otherwise, store appropriate part of range */
else if (strncmp(token,"-",1))
{
/* If don't have a start of range, then take this to be it */
if (start_residue[0] == '\0')
{
/* Format the residue number and store */
format_number(residue_number,token);
strcpy(start_residue,residue_number);
}
/* If don't have an end of range, then take this to be it */
else if (end_residue[0] == '\0')
{
/* Format the residue number and store */
format_number(residue_number,token);
strcpy(end_residue,residue_number);
}
/* Otherwise, take this to be the chain-id */
else
*chain = token[0];
}
}
}
/* Check whether have a range */
if (start_residue[0] != '\0' && end_residue[0] != '\0')
have_range = TRUE;
/* Return current position in the line */
*ipos = ipstn;
*end = done;
/* Return the done flag */
return(have_range);
}
static void format_avg_credit(double credit, wxString& strBuffer) {
strBuffer = format_number(credit, 2);
}
