int16
command_run (void)
{
int8 *entry_point;
void
(*f) (void);
entry_point = elf_load (xmodem_recv_buffer_start_address);
if (!entry_point)
{
put_string ("run error!\n");
}
else
{
put_string ("starting from entry point:");
put_hex ((uint32) entry_point, 6);
put_string ("\n");
put_string ("\n");
f = (void
(*) (void)) entry_point;
f ();
}
return 0;
}
static void show_utf8(struct membuffer *b, const char *text, const char *pre, const char *post, int is_attribute)
{
int len;
char *cleaned;
if (!text)
return;
/* remove leading and trailing space */
/* We need to combine isascii() with isspace(),
* because we can only trust isspace() with 7-bit ascii,
* on windows for example */
while (isascii(*text) && isspace(*text))
text++;
len = strlen(text);
if (!len)
return;
while (len && isascii(text[len - 1]) && isspace(text[len - 1]))
len--;
cleaned = strndup(text, len);
put_string(b, pre);
quote(b, cleaned, is_attribute);
put_string(b, post);
free(cleaned);
}
// RTC alarm setup time
static void rtc_alarm_time(void) {
char flag;
char buffer[9];
int temp, temp_time;
util_clear_screen();
// setup alarm second
put_string("en alrm sec(y/n): ");
flag = get_char();
if (flag == 'y') {
temp_time |= AT91C_RTC_SECEN;
util_clear_screen();
// update seconds
put_string("set sec: ");
get_string(buffer, 2, 1);
temp = util_hex_to_int(buffer);
if (temp >= 0x00 && temp <= 0x59) {
temp_time |= temp & AT91C_RTC_SEC;
}
util_clear_screen();
}
// setup alarm minute
put_string("en alrm min(y/n): ");
flag = get_char();
if (flag == 'y') {
temp_time |= AT91C_RTC_MINEN;
util_clear_screen();
// update minutes
put_string("set min: ");
get_string(buffer, 2, 1);
temp = util_hex_to_int(buffer);
if (temp >= 0x00 && temp <= 0x59) {
temp_time |= (temp << 8) & AT91C_RTC_MIN;
}
util_clear_screen();
}
// setup alarm minute
put_string("en alrm hour(y/n): ");
flag = get_char();
if (flag == 'y') {
temp_time |= AT91C_RTC_HOUREN;
util_clear_screen();
// update hours
put_string("set hour: ");
get_string(buffer, 2, 1);
temp = util_hex_to_int(buffer);
if (temp >= 0x00 && temp <= 0x23) {
temp_time |= (temp << 16) & AT91C_RTC_HOUR;
}
util_clear_screen();
}
if (temp_time & AT91C_RTC_SECEN) {
AT91C_BASE_RTC->RTC_TIMALR = temp_time;
AT91C_BASE_RTC->RTC_IER |= AT91C_RTC_ALARM;
}
}
init_fat(){
/* enable everdrive card */
clearFATBuffers();
ed_begin();
put_string("Initialise", 0, 1);
everdrive_error = disk_init();
put_number(everdrive_error, 3, 0, 2);
everdrive_error = getMBR(0);
put_number(everdrive_error, 3, 4, 2);
everdrive_error = getFATVol();
put_number(everdrive_error, 3, 8, 2);
everdrive_error = getFATFS();
put_number(everdrive_error, 3, 12, 2);
/* NOTE: You should normally check that each call to the above 4 functions
has returned correctly before proceeding! */
}
static int put_dynimport_decl(asymbol * sym, void *arg)
{
char dynimport_decl[1024];
const char *func_name = sym->name;
int fd = (int)arg;
/* Put the declaration for the dynamic info structure */
if (func_name)
{
sprintf(dynimport_decl, dynimport_decl_format,
MKINFODECLARGS(func_name, counter));
put_string(fd, dynimport_decl);
counter++;
}
return 0;
}
void
RTMPSession::sendCreateStream()
{
RTMPChunk_0 metadata = {{0}};
metadata.msg_stream_id = kControlChannelStreamId;
metadata.msg_type_id = RTMP_PT_INVOKE;
std::vector<uint8_t> buff;
put_string(buff, "createStream");
m_createStreamInvoke = ++m_numberOfInvokes;
m_trackedCommands[m_numberOfInvokes] = "createStream";
put_double(buff, m_createStreamInvoke);
put_byte(buff, kAMFNull);
metadata.msg_length.data = static_cast<int>( buff.size() );
sendPacket(&buff[0], buff.size(), metadata);
}
// system timer handler
extern void st_handler(void) {
int status = AT91C_BASE_ST->ST_SR & AT91C_BASE_ST->ST_IMR;
// handler of pit
if (status & AT91C_ST_PITS) {
AT91C_BASE_PIOB->PIO_ODSR ^= AT91C_PIO_PB0;
}
// handler of rtt - rttinc
if (status & AT91C_ST_RTTINC) {
AT91C_BASE_PIOB->PIO_ODSR ^= AT91C_PIO_PB27;
}
// handler of rtt - alms
if (status & AT91C_ST_ALMS) {
put_string("Simple message\n");
AT91C_BASE_ST->ST_RTAR += 40;
}
}
int
main (int argc, char **argv)
{
char *command_line;
header the_header;
long name_length;
char *mail_program_name;
char buf[BUFLEN + 1];
register int size;
FILE *the_pipe;
extern char *getenv (const char *);
mail_program_name = getenv ("FAKEMAILER");
if (!(mail_program_name && *mail_program_name))
mail_program_name = MAIL_PROGRAM_NAME;
name_length = strlen (mail_program_name);
my_name = MY_NAME;
the_streams = ((stream_list) NULL);
the_date = ((char *) NULL);
the_user = ((char *) NULL);
the_header = read_header ();
command_line = alloc_string (name_length + args_size (the_header));
strcpy (command_line, mail_program_name);
parse_header (the_header, &command_line[name_length]);
the_pipe = popen (command_line, "w");
if (the_pipe == ((FILE *) NULL))
fatal ("cannot open pipe to real mailer");
add_a_stream (the_pipe, pclose);
write_header (the_header);
/* Dump the message itself */
while (!feof (stdin))
{
size = fread (buf, 1, BUFLEN, stdin);
buf[size] = '\0';
put_string (buf);
}
exit (close_the_streams ());
}
int nice_copy(char *title, char *source, char *dest)
{
int x1=0,y1=0,x2=79,y2=25;
bar(x1,y1+1,x2,y2,176,0x01);
put_title(title);
box(x1,(y1+y2)/2-1,x2,(y1+y2)/2+3,0x17);
bar(x1+1,(y1+y2)/2,x2-1,(y1+y2)/2+2,' ',0x17);
char msg[100];
sprintf(msg,"Copying %s -> %s",source,dest);
put_string(x1+1,(y1+y2)/2,msg,0x17);
bar(x1+1,(y1+y2)/2+2,x2-1,(y1+y2)/2+2,176,0x17);
char *buffer=(char *)jmalloc(0xf000,"read buf");
if (!buffer) return 0;
FILE *out=fopen(dest,"wb");
if (!out) { jfree(buffer) ; return 0; }
FILE *in=fopen(source,"rb");
if (!in) { jfree(buffer); fclose(out); unlink(dest); return 0; }
fseek(in,0,SEEK_END);
long size=ftell(in);
fseek(in,0,SEEK_SET);
int osize=size;
while (size)
{
long tr=fread(buffer,1,0xf000,in);
bar(x1+1,(y1+y2)/2+2,x1+1+(x2-x1)*(osize-size-tr)/osize,(y1+y2)/2+2,178,0x17);
if (fwrite(buffer,1,tr,out)!=tr)
{
fclose(out);
fclose(in);
unlink(dest);
jfree(buffer);
return 0;
}
size-=tr;
}
fclose(in);
fclose(out);
jfree(buffer);
cls();
return 1;
}
void syslinux_execute(void)
{
char *device, *diskdevice;
char *bootimages;
int fd;
if (strcmp(hashmapGetPrintf(ictx.opts, "none", BASE_BOOTLOADER),
"syslinux"))
return;
pr_info("Writing MBR");
diskdevice = xasprintf("/dev/block/%s",
hashmapGetPrintf(ictx.opts, NULL, BASE_INSTALL_DISK));
dd(SYSLINUX_MBR, diskdevice);
free(diskdevice);
/* SYSLINUX complains if this isn't done */
chmod("/tmp", 01777);
bootimages = hashmapGetPrintf(ictx.opts, NULL, BASE_BOOT_LIST);
device = hashmapGetPrintf(ictx.opts, NULL, "partition.bootloader:device");
pr_info("Installing ldlinux.sys onto %s", device);
do_install_syslinux(device);
/* In case we die() before we are finished */
signal(SIGABRT, sighandler);
mount_partition_device(device, "vfat", BOOTLOADER_PATH);
pr_info("Copying syslinux support files");
copy_file(IMAGES_PATH "vesamenu.c32", BOOTLOADER_PATH "vesamenu.c32");
copy_file(IMAGES_PATH "android.c32", BOOTLOADER_PATH "android.c32");
pr_info("Constructing syslinux.cfg");
/* Put the initial template stuff in */
copy_file(SYSLINUX_CFG_TEM_FN, SYSLINUX_CFG_FN);
fd = xopen(SYSLINUX_CFG_FN, O_WRONLY | O_APPEND);
put_string(fd, "menu androidcommand %s\n",
hashmapGetPrintf(ictx.opts, NULL, "partition.misc:index"));
string_list_iterate(bootimages, bootimage_cb, &fd);
xclose(fd);
umount(BOOTLOADER_PATH);
rmdir(BOOTLOADER_PATH);
signal(SIGABRT, SIG_DFL);
pr_info("SYSLINUX installation complete");
}
/*! \fn int32 print_can_frame(void)
*
* \brief 打印CAN帧
*
* \param 无
*
* \exception 无
*
* \return EXIT_FAILURE：失败；EXIT_SUCCESS：成功
*/
int32 print_can_frame(void)
{
int32 lRet = EXIT_SUCCESS;
if(s_unCanSegMsgReadIndex != s_unCanSegMsgWriteIndex)
{
put_string(" ");
lRet = print_protocol_frame(&(s_aucCanSegMsgBuf[s_unCanSegMsgReadIndex][0]));
s_unCanSegMsgReadIndex++;
if(CAN_MSG_BUF_SIZE <= s_unCanSegMsgReadIndex)
{
s_unCanSegMsgReadIndex = 0;
}
}
return lRet;
}
static int put_dynimport_array(asymbol * sym, void *arg)
{
char dynimport_array[1024];
const char *func_name = sym->name;
int fd = (int)arg;
/* Create the dynimport_array */
if (func_name)
{
sprintf(dynimport_array, dynimport_array_format,
MKINFOARGS(func_name, counter));
put_string(fd, dynimport_array);
counter++;
}
return 0;
}
static int put_import_name(asymbol * sym, void *arg)
{
char import_name[512];
const char *func_name = sym->name;
int fd = (int)arg;
/* Create the import_name */
if (func_name)
{
sprintf(import_name, import_name_strtab_format,
MKIMPSTRTABARG(func_name, counter));
put_string(fd, import_name);
counter++;
}
return 0;
}
/*
* We're outputting utf8 in xml.
* We need to quote the characters <, >, &.
*
* Technically I don't think we'd necessarily need to quote the control
* characters, but at least libxml2 doesn't like them. It doesn't even
* allow them quoted. So we just skip them and replace them with '?'.
*
* If we do this for attributes, we need to quote the quotes we use too.
*/
static void quote(struct membuffer *b, const char *text, int is_attribute)
{
const char *p = text;
for (;;) {
const char *escape;
switch (*p++) {
default:
continue;
case 0:
escape = NULL;
break;
case 1 ... 8:
case 11:
case 12:
case 14 ... 31:
escape = "?";
break;
case '<':
escape = "<";
break;
case '>':
escape = ">";
break;
case '&':
escape = "&";
break;
case '\'':
if (!is_attribute)
continue;
escape = "'";
break;
case '\"':
if (!is_attribute)
continue;
escape = """;
break;
}
put_bytes(b, text, (p - text - 1));
if (!escape)
break;
put_string(b, escape);
text = p;
}
}
static ipc_msg_hdr *create_hdr(uint32_t op, size_t *len, char **data_start, int reuse_socket)
{
char *msg = NULL;
ipc_msg_hdr *hdr;
int datalen;
#if !defined(USE_TCP_LOOPBACK)
char ctrl_path[256];
#endif
if (!reuse_socket)
{
#if defined(USE_TCP_LOOPBACK)
*len += 2; // Allocate space for two-byte port number
#else
struct timeval time;
if (gettimeofday(&time, NULL) < 0) return NULL;
sprintf(ctrl_path, "%s%d-%.3lx-%.6lu", CTL_PATH_PREFIX, (int)getpid(),
(unsigned long)(time.tv_sec & 0xFFF), (unsigned long)(time.tv_usec));
*len += strlen(ctrl_path) + 1;
#endif
}
datalen = (int) *len;
*len += sizeof(ipc_msg_hdr);
// write message to buffer
msg = malloc(*len);
if (!msg) return NULL;
bzero(msg, *len);
hdr = (void *)msg;
hdr->datalen = datalen;
hdr->version = VERSION;
hdr->op = op;
if (reuse_socket) hdr->flags |= IPC_FLAGS_REUSE_SOCKET;
*data_start = msg + sizeof(ipc_msg_hdr);
#if defined(USE_TCP_LOOPBACK)
// Put dummy data in for the port, since we don't know what
// it is yet. The data will get filled in before we
// send the message. This happens in deliver_request().
if (!reuse_socket) put_short(0, data_start);
#else
if (!reuse_socket) put_string(ctrl_path, data_start);
#endif
return hdr;
}
// run another code
static void run_kernel(void) {
unsigned read_size;
unsigned boot_args[AT45_PAGE_SIZE / 4];
kernel_t kernel = (kernel_t) LINUX_BASE_ADDRESS;
unsigned *tags = (unsigned *) LINUX_TAGS_ADDRESS;
unsigned *sz, len;
const char *cmdline = "mem=128M root=/dev/sda1 rootwait ro";
/*if (!at45_read(BOOT_2_ARGS_OFFSET, boot_args, AT45_PAGE_SIZE)) {
read_size = boot_args[0];
util_printf("Read 0x%x bytes\n", read_size);
if (read_size > 0 && read_size < (AT45DB642D_SIZE - 4)) {
if (!at45_read(LINUX_OFFSET, (unsigned *)LINUX_BASE_ADDRESS, read_size)) {*/
put_string("Read success\nConfiguring\n");
/* atag_core */
*tags++ = 5;
*tags++ = 0x54410001;
*tags++ = 1;
*tags++ = 4096;
*tags++ = 0;
/* atag_mem */
*tags++ = 4;
*tags++ = 0x54410002;
*tags++ = SDRAM_BASE_ADDRESS;
*tags++ = SDRAM_SIZE;
/* atag_cmdline */
sz = tags++;
*tags++ = 0x54410009;
len = cmdcpy(tags, cmdline);
*sz = 2 + len;
tags += len;
/* atag_none */
*tags++ = 0;
*tags++ = 0;
util_printf("Jump to the kernel image\n\n");
kernel(0, MACHINE_ID, (void*) LINUX_TAGS_ADDRESS);
/*}
}
}*/
}
static void
put_stringv (GDataOutputStream *out,
char **strv)
{
int len, i;
len = g_strv_length (strv);
if (len > G_MAXUINT16)
{
g_warning ("GFileInfo stringv to large, (%d elements)\n", (int)len);
len = 0;
}
g_data_output_stream_put_uint16 (out, len,
NULL, NULL);
for (i = 0; i < len; i++)
put_string (out, strv[i]);
}
static ER
vprintf (B *fmt, VP arg0)
{
VP *ap;
for (ap = (VP *)arg0; *fmt != '\0'; fmt++)
{
if ((*fmt) == '%')
{
++fmt;
switch (*fmt)
{
case 's':
put_string (*(B **)ap, log_port);
INC (ap, B *);
break;
case 'd':
if ((W)*ap < 0)
{
((W)*ap) = -((W)*ap);
putc ('-', log_port);
}
print_digit ((W)*ap, 10);
INC (ap, W);
break;
case 'x':
print_digit ((UW)*ap, 16);
INC (ap, W);
break;
default:
putc ('%', log_port);
break;
}
}
else
{
putc (*fmt, log_port);
}
}
}
void RefreshMainAux(int sel, int row)
{
set_font_pal(sel == 7 ? 15 : 14);
put_string("Horizontal Stripes", HPOS, row++);
set_font_pal(sel == 8 ? 15 : 14);
put_string("Checkerboard", HPOS, row++);
set_font_pal(sel == 9 ? 15 : 14);
put_string("Backlit Zone Test", HPOS, row++);
set_font_pal(sel == 10 ? 15 : 14);
put_string("Sound Test", HPOS, row++);
set_font_pal(sel == 11 ? 15 : 14);
put_string("Audio Sync Test", HPOS, row++);
set_font_pal(sel == 12 ? 15 : 14);
put_string("Video Options", HPOS, ++row);
set_font_pal(sel == 13 ? 15 : 14);
put_string("Help", HPOS, ++row);
set_font_pal(sel == 14 ? 15 : 14);
put_string("Credits", HPOS, ++row);
}
void writeMarkers(struct membuffer *b, const bool selected_only)
{
int i, dive_no = 0;
struct dive *dive;
char pre[1000], post[1000];
for_each_dive (i, dive) {
if (selected_only) {
if (!dive->selected)
continue;
}
struct dive_site *ds = get_dive_site_for_dive(dive);
if (!ds || !dive_site_has_gps_location(ds))
continue;
put_degrees(b, ds->latitude, "temp = new google.maps.Marker({position: new google.maps.LatLng(", "");
put_degrees(b, ds->longitude, ",", ")});\n");
put_string(b, "markers.push(temp);\ntempinfowindow = new google.maps.InfoWindow({content: '<div id=\"content\">'+'<div id=\"siteNotice\">'+'</div>'+'<div id=\"bodyContent\">");
snprintf(pre, sizeof(pre), "<p>%s ", translate("gettextFromC", "Date:"));
put_HTML_date(b, dive, pre, "</p>");
snprintf(pre, sizeof(pre), "<p>%s ", translate("gettextFromC", "Time:"));
put_HTML_time(b, dive, pre, "</p>");
snprintf(pre, sizeof(pre), "<p>%s ", translate("gettextFromC", "Duration:"));
snprintf(post, sizeof(post), " %s</p>", translate("gettextFromC", "min"));
put_duration(b, dive->duration, pre, post);
put_string(b, "<p> ");
put_HTML_quoted(b, translate("gettextFromC", "Max. depth:"));
put_HTML_depth(b, dive, " ", "</p>");
put_string(b, "<p> ");
put_HTML_quoted(b, translate("gettextFromC", "Air temp.:"));
put_HTML_airtemp(b, dive, " ", "</p>");
put_string(b, "<p> ");
put_HTML_quoted(b, translate("gettextFromC", "Water temp.:"));
put_HTML_watertemp(b, dive, " ", "</p>");
snprintf(pre, sizeof(pre), "<p>%s <b>", translate("gettextFromC", "Location:"));
put_string(b, pre);
put_HTML_quoted(b, get_dive_location(dive));
put_string(b, "</b></p>");
snprintf(pre, sizeof(pre), "<p> %s ", translate("gettextFromC", "Notes:"));
put_HTML_notes(b, dive, pre, " </p>");
put_string(b, "</p>'+'</div>'+'</div>'});\ninfowindows.push(tempinfowindow);\n");
put_format(b, "google.maps.event.addListener(markers[%d], 'mouseover', function() {\ninfowindows[%d].open(map,markers[%d]);}", dive_no, dive_no, dive_no);
put_format(b, ");google.maps.event.addListener(markers[%d], 'mouseout', function() {\ninfowindows[%d].close();});\n", dive_no, dive_no);
dive_no++;
}
}
static void show_bindings(val env, val stream)
{
val level = zero;
put_string(lit("bindings:\n"), stream);
for (;; level = plus(level, one)) {
if (nilp(env))
break;
else if (consp(env)) {
format(stream, lit("~d: ~s\n"), level, env, nao);
break;
} else if (type(env) == ENV) {
format(stream, lit("~d: ~s\n"), level, env->e.vbindings, nao);
env = env->e.up_env;
} else {
format(stream, lit("invalid environment object: ~s\n"), env, nao);
break;
}
}
}
void input_entry_format::debug_print()
{
int i;
for (i = 0; i < pre_vline; i++)
putc('|', stderr);
entry_format::debug_print();
if (!width.empty()) {
putc('w', stderr);
putc('(', stderr);
put_string(width, stderr);
putc(')', stderr);
}
if (equal)
putc('e', stderr);
if (separation >= 0)
fprintf(stderr, "%d", separation);
for (i = 0; i < vline; i++)
putc('|', stderr);
if (last_column)
putc(',', stderr);
}
void possible_command::print(int is_last, FILE *fp)
{
build_argv();
if (IS_BSHELL(argv[0])
&& argv[1] != 0 && strcmp(argv[1], BSHELL_DASH_C) == 0
&& argv[2] != 0 && argv[3] == 0)
fputs(argv[2], fp);
else {
fputs(argv[0], fp);
string str;
for (int i = 1; argv[i] != 0; i++) {
str.clear();
append_arg_to_string(argv[i], str);
put_string(str, fp);
}
}
if (is_last)
putc('\n', fp);
else
fputs(" | ", fp);
}
DNSServiceErrorType DNSSD_API DNSServiceReconfirmRecord
(
DNSServiceFlags flags,
uint32_t interfaceIndex,
const char *fullname,
uint16_t rrtype,
uint16_t rrclass,
uint16_t rdlen,
const void *rdata
)
{
char *ptr;
size_t len;
ipc_msg_hdr *hdr;
DNSServiceRef tmp;
len = sizeof(DNSServiceFlags);
len += sizeof(uint32_t);
len += strlen(fullname) + 1;
len += 3 * sizeof(uint16_t);
len += rdlen;
tmp = connect_to_server();
if (!tmp) return(kDNSServiceErr_Unknown);
hdr = create_hdr(reconfirm_record_request, &len, &ptr, 1);
if (!hdr) return(kDNSServiceErr_Unknown);
put_flags(flags, &ptr);
put_long(interfaceIndex, &ptr);
put_string(fullname, &ptr);
put_short(rrtype, &ptr);
put_short(rrclass, &ptr);
put_short(rdlen, &ptr);
put_rdata(rdlen, rdata, &ptr);
ConvertHeaderBytes(hdr);
write_all(tmp->sockfd, (char *)hdr, (int) len);
free(hdr);
DNSServiceRefDeallocate(tmp);
return(kDNSServiceErr_NoError);
}
DNSServiceErrorType DNSSD_API DNSServiceSetDefaultDomainForUser
(
DNSServiceFlags flags,
const char *domain
)
{
DNSServiceRef sdr;
DNSServiceErrorType err;
char *ptr = NULL;
size_t len = sizeof(flags) + strlen(domain) + 1;
ipc_msg_hdr *hdr = create_hdr(setdomain_request, &len, &ptr, 1);
if (!hdr) return kDNSServiceErr_Unknown;
put_flags(flags, &ptr);
put_string(domain, &ptr);
sdr = connect_to_server();
if (!sdr) { free(hdr); return kDNSServiceErr_Unknown; }
err = deliver_request((char *)hdr, sdr, 1); // deliver_request frees the message for us
DNSServiceRefDeallocate(sdr);
return err;
}
// ********************************************
void systeminfo_output(void)
{
int y = 30;
int dy = 20;
struct sysinfo si;
char s[40] = "";
sysinfo(&si);
// Uptime
sprintf (s, "system uptime : %ld days, %ld:%02ld:%02ld",
si.uptime / SEC_DAY,
(si.uptime % SEC_DAY) / SEC_HOUR,
(si.uptime % SEC_HOUR) / SEC_MINUTE,
si.uptime % SEC_MINUTE);
put_string(10, y, s, LIGHT_GREY, FONT_8X16);
y+=dy;
// Loads
sprintf (s, "load avg. : %4.2f %4.2f %4.2f",
si.loads[0] / LINUX_SYSINFO_LOADS_SCALE,
si.loads[1] / LINUX_SYSINFO_LOADS_SCALE,
si.loads[2] / LINUX_SYSINFO_LOADS_SCALE);
put_string(10, y, s, LIGHT_GREY, FONT_8X16);
y+=dy;
// RAM
sprintf (s, "ram [MByte] : %5.1f/%5.1f",
(si.totalram - si.freeram) / ONE_MBYTE,
si.totalram / ONE_MBYTE);
put_string(10, y, s, LIGHT_GREY, FONT_8X16);
y+=dy;
// SWAP
sprintf (s, "swap [MByte] : %5.1f/%5.1f",
(si.totalswap - si.freeswap) / ONE_MBYTE,
si.totalswap / ONE_MBYTE);
put_string(10, y, s, LIGHT_GREY, FONT_8X16);
y+=dy;
// Processes/User
sprintf (s, "proc./user : %5i/%i",
si.procs,
get_number_of_users());
put_string(10, y, s, LIGHT_GREY, FONT_8X16);
y+=dy;
// Netzwerk Rx/Tx-Statistik
sprintf (s, "rx/tx [kByte/s]: %5.1f/%5.1f", rx_kbs, tx_kbs);
put_string(10, y, s, LIGHT_GREY, FONT_8X16);
}
int RecievePacket(char* packet){
put_string("BEGIN REC PACKET\r\n");
//strcpy(packet,DummyPacket);
int PacketLength = strlen(DummyPacket);
put_string("Dummy packet length: "); put_number(PacketLength); put_string("\r\n");
//display_string("r packet length: "); display_number(PacketLength); display_string("\n");
for(int i=0;i<(PacketLength);i++){
packet[i] = DummyPacket[i];
}
for(int i=0;i<(MAXPACKETSIZE+1);i++){
DummyPacket[i] = 0;
}
PacketLength = strlen(packet);
put_string("Real packet length: "); put_number(PacketLength); put_string("\r\n");
put_string("END REC PACKET\r\n");
return 0;
}
void RefreshMain(int sel)
{
int row = 8;
set_font_pal(sel == 0 ? 15 : 14);
put_string("Test Patterns", HPOS, row++);
set_font_pal(sel == 1 ? 15 : 14);
put_string("Drop Shadow Test", HPOS, row++);
set_font_pal(sel == 2 ? 15 : 14);
put_string("Striped Sprite Test", HPOS, row++);
set_font_pal(sel == 3 ? 15 : 14);
put_string("Lag Test", HPOS, row++);
set_font_pal(sel == 4 ? 15 : 14);
put_string("Manual Lag Test", HPOS, row++);
set_font_pal(sel == 5 ? 15 : 14);
put_string("Scroll Test", HPOS, row++);
set_font_pal(sel == 6 ? 15 : 14);
put_string("Grid Scroll Test", HPOS, row++);
RefreshMainAux(sel, row);
}
static void quote(struct membuffer *b, const char *text)
{
const char *p = text;
for (;;) {
const char *escape;
switch (*p++) {
default:
continue;
case 0:
escape = NULL;
break;
case 1 ... 8:
case 11:
case 12:
case 14 ... 31:
escape = "?";
break;
case '\\':
escape = "\\\\";
break;
case '"':
escape = "\\\"";
break;
case '\n':
escape = "\n\t";
if (*p == '\n')
escape = "\n";
break;
}
put_bytes(b, text, (p - text - 1));
if (!escape)
break;
put_string(b, escape);
text = p;
}
}
/*! \fn int32 debug_msg(int8 *pString, int8 *pFile, uint16 ulLine)
*
* \brief 输出调试信息
*
* \param pString [in] 输出的字符串
*
* \param *pFile [in] __FILE__/为NULL表示不打印文件名及行号
*
* \param ulLine [in] __LINE__
*
* \exception 注意：在输出行号后会打印”\r\n“
*
* \return EXIT_SUCCESS：成功，EXIT_FAILURE：失败
*/
int32 debug_msg(int8 *pString, int8 *pFile, uint16 ulLine)
{
int32 lRet = EXIT_SUCCESS;
/*! 输出字符串 */
if(NULL != pString)
{
if(EXIT_FAILURE == put_string(pString))
{
lRet = EXIT_FAILURE;
}
}
/*! 输出调用此函数的文件名与行号 */
if(NULL != pFile)
{
if(EXIT_FAILURE == put_file_line(pFile, ulLine))
{
lRet = EXIT_FAILURE;
}
}
return lRet;
}
