void main(void)
{
unsigned int eax, ebx, ecx, edx, a;
char id[17];
clear_screen();
print_color("cpuid example\n", 0x09);
cpuid(0, 0, &eax, &ebx, &ecx, &edx);
print_num(eax);
memcpy(id, &ebx, 4);
memcpy(id + 4, &edx, 4);
memcpy(id + 8, &ecx, 4);
id[12] = 0;
print(id);
print("\n");
cpuid(1, 0, &eax, &ebx, &ecx, &edx);
print("version: ");
print_num(eax);
for (a = 0x80000002; a <= 0x80000004; a++) {
cpuid(a, 0, &eax, &ebx, &ecx, &edx);
memcpy(id, &eax, 4);
memcpy(id + 4, &ebx, 4);
memcpy(id + 8, &ecx, 4);
memcpy(id + 12, &edx, 4);
id[16] = 0;
print(id);
print("\n");
}
halt();
}
int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
int i;
bd_t *bd = gd->bd;
printf("U-Boot = %s\n", bd->bi_r_version);
printf("CPU = %s\n", bd->bi_cpu);
printf("Board = %s\n", bd->bi_board_name);
printf("VCO = %lu MHz\n", bd->bi_vco / 1000000);
printf("CCLK = %lu MHz\n", bd->bi_cclk / 1000000);
printf("SCLK = %lu MHz\n", bd->bi_sclk / 1000000);
print_num("boot_params", (ulong)bd->bi_boot_params);
print_num("memstart", (ulong)bd->bi_memstart);
print_lnum("memsize", (u64)bd->bi_memsize);
print_num("flashstart", (ulong)bd->bi_flashstart);
print_num("flashsize", (ulong)bd->bi_flashsize);
print_num("flashoffset", (ulong)bd->bi_flashoffset);
puts("ethaddr =");
for (i = 0; i < 6; ++i)
printf("%c%02X", i ? ':' : ' ', bd->bi_enetaddr[i]);
puts("\nip_addr = ");
print_IPaddr(bd->bi_ip_addr);
printf("\nbaudrate = %d bps\n", bd->bi_baudrate);
return 0;
}
int main()
{
ulong i, tens;
int cnt = 0;
int base = 10;
printf("base 10:\n");
for (i = 1; i < 1000000; i++)
if (kaprekar(i, base))
printf("%3d: %llu\n", ++cnt, i);
base = 17;
printf("\nbase %d:\n 1: 1\n", base);
for (i = 2, cnt = 1; i < 1000000; i++)
if ((tens = kaprekar(i, base))) {
printf("%3d: %llu", ++cnt, i);
printf(" \t"); print_num(i, base);
printf("\t"); print_num(i * i, base);
printf("\t"); print_num(i * i / tens, base);
printf(" + "); print_num(i * i % tens, base);
printf("\n");
}
return 0;
}
/*
* Boot support
*/
#include <common.h>
#include <command.h>
DECLARE_GLOBAL_DATA_PTR;
static void print_num(const char *, ulong);
#if !defined(CONFIG_ARM) || defined(CONFIG_CMD_NET)
static void print_eth(int idx);
#endif
#ifndef CONFIG_ARM /* PowerPC and other */
static void print_lnum(const char *, u64);
#ifdef CONFIG_PPC
static void print_str(const char *, const char *);
int do_bdinfo ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
bd_t *bd = gd->bd;
char buf[32];
#ifdef DEBUG
print_num ("bd address", (ulong)bd );
#endif
print_num ("memstart", bd->bi_memstart );
print_lnum ("memsize", bd->bi_memsize );
print_num ("flashstart", bd->bi_flashstart );
print_num ("flashsize", bd->bi_flashsize );
print_num ("flashoffset", bd->bi_flashoffset );
print_num ("sramstart", bd->bi_sramstart );
print_num ("sramsize", bd->bi_sramsize );
#if defined(CONFIG_5xx) || defined(CONFIG_8xx) || \
defined(CONFIG_8260) || defined(CONFIG_E500)
print_num ("immr_base", bd->bi_immr_base );
#endif
print_num ("bootflags", bd->bi_bootflags );
#if defined(CONFIG_405GP) || defined(CONFIG_405CR) || \
defined(CONFIG_405EP) || defined(CONFIG_XILINX_405) || \
defined(CONFIG_440EP) || defined(CONFIG_440GR) || \
defined(CONFIG_440EPX) || defined(CONFIG_440GRX) || \
defined(CONFIG_440SP) || defined(CONFIG_440SPE)
print_str ("procfreq", strmhz(buf, bd->bi_procfreq));
print_str ("plb_busfreq", strmhz(buf, bd->bi_plb_busfreq));
#if defined(CONFIG_405GP) || defined(CONFIG_405EP) || defined(CONFIG_XILINX_405) || \
defined(CONFIG_440EP) || defined(CONFIG_440GR) || defined(CONFIG_440SPE) || \
defined(CONFIG_440EPX) || defined(CONFIG_440GRX)
print_str ("pci_busfreq", strmhz(buf, bd->bi_pci_busfreq));
#endif
#else /* ! CONFIG_405GP, CONFIG_405CR, CONFIG_405EP, CONFIG_XILINX_405, CONFIG_440EP CONFIG_440GR */
#if defined(CONFIG_CPM2)
print_str ("vco", strmhz(buf, bd->bi_vco));
print_str ("sccfreq", strmhz(buf, bd->bi_sccfreq));
print_str ("brgfreq", strmhz(buf, bd->bi_brgfreq));
#endif
print_str ("intfreq", strmhz(buf, bd->bi_intfreq));
#if defined(CONFIG_CPM2)
print_str ("cpmfreq", strmhz(buf, bd->bi_cpmfreq));
#endif
print_str ("busfreq", strmhz(buf, bd->bi_busfreq));
#endif /* CONFIG_405GP, CONFIG_405CR, CONFIG_405EP, CONFIG_XILINX_405, CONFIG_440EP CONFIG_440GR */
#if defined(CONFIG_MPC8220)
print_str ("inpfreq", strmhz(buf, bd->bi_inpfreq));
print_str ("flbfreq", strmhz(buf, bd->bi_flbfreq));
print_str ("pcifreq", strmhz(buf, bd->bi_pcifreq));
print_str ("vcofreq", strmhz(buf, bd->bi_vcofreq));
print_str ("pevfreq", strmhz(buf, bd->bi_pevfreq));
#endif
print_eth(0);
#if defined(CONFIG_HAS_ETH1)
print_eth(1);
#endif
#if defined(CONFIG_HAS_ETH2)
print_eth(2);
#endif
#if defined(CONFIG_HAS_ETH3)
print_eth(3);
#endif
#if defined(CONFIG_HAS_ETH4)
print_eth(4);
#endif
#if defined(CONFIG_HAS_ETH5)
print_eth(5);
#endif
#ifdef CONFIG_HERMES
print_str ("ethspeed", strmhz(buf, bd->bi_ethspeed));
#endif
printf ("IP addr = %pI4\n", &bd->bi_ip_addr);
printf ("baudrate = %6ld bps\n", bd->bi_baudrate );
print_num ("relocaddr", gd->relocaddr);
return 0;
}
#elif defined(CONFIG_NIOS) /* NIOS*/
int do_bdinfo ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
bd_t *bd = gd->bd;
print_num ("memstart", (ulong)bd->bi_memstart);
print_lnum ("memsize", (u64)bd->bi_memsize);
print_num ("flashstart", (ulong)bd->bi_flashstart);
print_num ("flashsize", (ulong)bd->bi_flashsize);
print_num ("flashoffset", (ulong)bd->bi_flashoffset);
print_eth(0);
printf ("ip_addr = %pI4\n", &bd->bi_ip_addr);
printf ("baudrate = %ld bps\n", bd->bi_baudrate);
return 0;
}
#elif defined(CONFIG_NIOS2) /* Nios-II */
int do_bdinfo ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
bd_t *bd = gd->bd;
print_num ("mem start", (ulong)bd->bi_memstart);
print_lnum ("mem size", (u64)bd->bi_memsize);
print_num ("flash start", (ulong)bd->bi_flashstart);
print_num ("flash size", (ulong)bd->bi_flashsize);
print_num ("flash offset", (ulong)bd->bi_flashoffset);
#if defined(CONFIG_SYS_SRAM_BASE)
print_num ("sram start", (ulong)bd->bi_sramstart);
print_num ("sram size", (ulong)bd->bi_sramsize);
#endif
#if defined(CONFIG_CMD_NET)
print_eth(0);
printf ("ip_addr = %pI4\n", &bd->bi_ip_addr);
#endif
printf ("baudrate = %ld bps\n", bd->bi_baudrate);
return 0;
}
#elif defined(CONFIG_MICROBLAZE) /* ! PPC, which leaves Microblaze */
int do_bdinfo ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
bd_t *bd = gd->bd;
print_num ("mem start ", (ulong)bd->bi_memstart);
print_lnum ("mem size ", (u64)bd->bi_memsize);
print_num ("flash start ", (ulong)bd->bi_flashstart);
print_num ("flash size ", (ulong)bd->bi_flashsize);
print_num ("flash offset ", (ulong)bd->bi_flashoffset);
#if defined(CONFIG_SYS_SRAM_BASE)
print_num ("sram start ", (ulong)bd->bi_sramstart);
print_num ("sram size ", (ulong)bd->bi_sramsize);
#endif
#if defined(CONFIG_CMD_NET)
print_eth(0);
printf ("ip_addr = %pI4\n", &bd->bi_ip_addr);
#endif
printf ("baudrate = %ld bps\n", (ulong)bd->bi_baudrate);
return 0;
}
#elif defined(CONFIG_SPARC) /* SPARC */
int do_bdinfo(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
{
bd_t *bd = gd->bd;
#ifdef DEBUG
print_num("bd address ", (ulong) bd);
#endif
print_num("memstart ", bd->bi_memstart);
print_lnum("memsize ", bd->bi_memsize);
print_num("flashstart ", bd->bi_flashstart);
print_num("CONFIG_SYS_MONITOR_BASE ", CONFIG_SYS_MONITOR_BASE);
print_num("CONFIG_ENV_ADDR ", CONFIG_ENV_ADDR);
printf("CONFIG_SYS_RELOC_MONITOR_BASE = 0x%lx (%d)\n", CONFIG_SYS_RELOC_MONITOR_BASE,
CONFIG_SYS_MONITOR_LEN);
printf("CONFIG_SYS_MALLOC_BASE = 0x%lx (%d)\n", CONFIG_SYS_MALLOC_BASE,
CONFIG_SYS_MALLOC_LEN);
printf("CONFIG_SYS_INIT_SP_OFFSET = 0x%lx (%d)\n", CONFIG_SYS_INIT_SP_OFFSET,
CONFIG_SYS_STACK_SIZE);
printf("CONFIG_SYS_PROM_OFFSET = 0x%lx (%d)\n", CONFIG_SYS_PROM_OFFSET,
CONFIG_SYS_PROM_SIZE);
printf("CONFIG_SYS_GBL_DATA_OFFSET = 0x%lx (%d)\n", CONFIG_SYS_GBL_DATA_OFFSET,
CONFIG_SYS_GBL_DATA_SIZE);
#if defined(CONFIG_CMD_NET)
print_eth(0);
printf("ip_addr = %pI4\n", &bd->bi_ip_addr);
#endif
printf("baudrate = %6ld bps\n", bd->bi_baudrate);
return 0;
}
int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
bd_t *bd = gd->bd;
print_bi_mem(bd);
print_bi_flash(bd);
#if defined(CONFIG_SYS_INIT_RAM_ADDR)
print_num("sramstart", (ulong)bd->bi_sramstart);
print_num("sramsize", (ulong)bd->bi_sramsize);
#endif
#if defined(CONFIG_SYS_MBAR)
print_num("mbar", bd->bi_mbar_base);
#endif
print_mhz("cpufreq", bd->bi_intfreq);
print_mhz("busfreq", bd->bi_busfreq);
#ifdef CONFIG_PCI
print_mhz("pcifreq", bd->bi_pcifreq);
#endif
#ifdef CONFIG_EXTRA_CLOCK
print_mhz("flbfreq", bd->bi_flbfreq);
print_mhz("inpfreq", bd->bi_inpfreq);
print_mhz("vcofreq", bd->bi_vcofreq);
#endif
print_eth_ip_addr();
print_baudrate();
return 0;
}
void handle_display()
{
const uint32_t pad_header = TMAP_HEADER(2,2,TSET_16,TMAP_U8);
tmap_blit(sampler.bg,0,0,dessin_header, dessin_tmap);
// display line headers with instruments IDs.
// display blocks according to the current pattern samples (dont care about notes or samples)
for (int chn=0;chn<CHANNELS;chn++)
for (int step=0;step<16;step++)
{
uint8_t s = Player.currentPattern.sampleNumber[step*4][chn];
// 0 or 1 ! inverse channel mapping (if possible, else just use 0).
if (s) {
tmap_blit(sampler.bg,step2x(step), chan2y(chn), pad_header, pad_tmap[s==chn+1 ? 0 : 1]);
}
}
print_num(drumkit_pos,sampler.drumkit,2);
print_num(pattern_pos,Player.orderIndex,2);
int bpm = 5* SAMPLERATE / Player.samplesPerTick /2;
print_num(tempo_pos,bpm,3);
// display player beat position
vram[cursor_line*64 + step2x(Player.row/4)] = cursor_tile[0]+1;
vram[cursor_line*64 + step2x(Player.row/4) + 1 ] = cursor_tile[1]+1;
// position & display blinking cursor
sampler.cursor->x= step2x(sampler.cursor_x)*16;
sampler.cursor->y=(vga_frame & 32) ? chan2y(sampler.cursor_y)*16: 500;
}
int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
bd_t *bd = gd->bd;
char buf[32];
printf("U-Boot = %s\n", bd->bi_r_version);
printf("CPU = %s\n", bd->bi_cpu);
printf("Board = %s\n", bd->bi_board_name);
print_str("VCO", strmhz(buf, bd->bi_vco));
print_str("CCLK", strmhz(buf, bd->bi_cclk));
print_str("SCLK", strmhz(buf, bd->bi_sclk));
print_num("boot_params", (ulong)bd->bi_boot_params);
print_num("memstart", (ulong)bd->bi_memstart);
print_lnum("memsize", (u64)bd->bi_memsize);
print_num("flashstart", (ulong)bd->bi_flashstart);
print_num("flashsize", (ulong)bd->bi_flashsize);
print_num("flashoffset", (ulong)bd->bi_flashoffset);
print_eth(0);
printf("ip_addr = %pI4\n", &bd->bi_ip_addr);
printf("baudrate = %d bps\n", bd->bi_baudrate);
return 0;
}
int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
print_std_bdinfo(gd->bd);
print_num("relocaddr", gd->relocaddr);
print_num("reloc off", gd->reloc_off);
return 0;
}
void print_num(unsigned int n)
{
if (n > 9)
{
print_num(n / 10);
print_num(n % 10);
}
else
ft_putchar(n + '0');
}
static int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[])
{
bd_t *bd = gd->bd;
print_num("arch_number", bd->bi_arch_number);
print_bi_boot_params(bd);
print_bi_dram(bd);
#ifdef CONFIG_SYS_MEM_RESERVE_SECURE
if (gd->arch.secure_ram & MEM_RESERVE_SECURE_SECURED) {
print_num("Secure ram",
gd->arch.secure_ram & MEM_RESERVE_SECURE_ADDR_MASK);
}
#endif
#ifdef CONFIG_RESV_RAM
if (gd->arch.resv_ram)
print_num("Reserved ram", gd->arch.resv_ram);
#endif
#if defined(CONFIG_CMD_NET) && !defined(CONFIG_DM_ETH)
print_eths();
#endif
print_baudrate();
#if !(defined(CONFIG_SYS_ICACHE_OFF) && defined(CONFIG_SYS_DCACHE_OFF))
print_num("TLB addr", gd->arch.tlb_addr);
#endif
print_num("relocaddr", gd->relocaddr);
print_num("reloc off", gd->reloc_off);
print_num("irq_sp", gd->irq_sp); /* irq stack pointer */
print_num("sp start ", gd->start_addr_sp);
#if defined(CONFIG_LCD) || defined(CONFIG_VIDEO)
print_num("FB base ", gd->fb_base);
#endif
/*
* TODO: Currently only support for davinci SOC's is added.
* Remove this check once all the board implement this.
*/
#ifdef CONFIG_CLOCKS
printf("ARM frequency = %ld MHz\n", gd->bd->bi_arm_freq);
printf("DSP frequency = %ld MHz\n", gd->bd->bi_dsp_freq);
printf("DDR frequency = %ld MHz\n", gd->bd->bi_ddr_freq);
#endif
#ifdef CONFIG_BOARD_TYPES
printf("Board Type = %ld\n", gd->board_type);
#endif
#if CONFIG_VAL(SYS_MALLOC_F_LEN)
printf("Early malloc usage: %lx / %x\n", gd->malloc_ptr,
CONFIG_VAL(SYS_MALLOC_F_LEN));
#endif
if (gd->fdt_blob)
print_num("fdt_blob", (ulong)gd->fdt_blob);
return 0;
}
void print_line(int n)
{
int *p;
for(p = buffer+row;p<buffer+BUFF_SIZE;p += ROWS/*not COLS for the buffer stores by COLS,so the buffer has ROWS-size columns*/) {
//printf("inloop: row=%d p = %ld\n",row,p-buffer);
print_num(*p);
}
print_num(n);
print_linefeed();
row++;
}
static inline void print_bi_mem(const bd_t *bd)
{
#if defined(CONFIG_SH)
print_num("mem start ", (ulong)bd->bi_memstart);
print_lnum("mem size ", (u64)bd->bi_memsize);
#elif defined(CONFIG_ARC)
print_num("mem start", (ulong)bd->bi_memstart);
print_lnum("mem size", (u64)bd->bi_memsize);
#else
print_num("memstart", (ulong)bd->bi_memstart);
print_lnum("memsize", (u64)bd->bi_memsize);
#endif
}
int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
bd_t *bd = gd->bd;
print_bi_boot_params(bd);
print_bi_dram(bd);
print_num("relocaddr", gd->relocaddr);
print_num("reloc off", gd->reloc_off);
print_eth_ip_addr();
print_baudrate();
return 0;
}
static inline void print_bi_dram(const bd_t *bd)
{
#ifdef CONFIG_NR_DRAM_BANKS
int i;
for (i = 0; i < CONFIG_NR_DRAM_BANKS; ++i) {
if (bd->bi_dram[i].size) {
print_num("DRAM bank", i);
print_num("-> start", bd->bi_dram[i].start);
print_num("-> size", bd->bi_dram[i].size);
}
}
#endif
}
int main()
{
my_rand(num);
print_num(num);
printf(".......maopao\n");
maopao_num(num);
print_num(num);
printf(".......select\n");
my_rand(num);
print_num(num);
select_num(num);
print_num(num);
return 0;
}
int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
int i;
bd_t *bd = gd->bd;
for (i = 0; i < CONFIG_NR_DRAM_BANKS; ++i) {
print_num("DRAM bank", i);
print_num("-> start", bd->bi_dram[i].start);
print_num("-> size", bd->bi_dram[i].size);
}
print_num("flash start", (ulong)bd->bi_flashstart);
print_num("flash size", (ulong)bd->bi_flashsize);
print_num("flash offset", (ulong)bd->bi_flashoffset);
#if defined(CONFIG_SYS_SRAM_BASE)
print_num ("sram start", (ulong)bd->bi_sramstart);
print_num ("sram size", (ulong)bd->bi_sramsize);
#endif
#if defined(CONFIG_CMD_NET)
print_eth(0);
printf("ip_addr = %s\n", getenv("ipaddr"));
#endif
printf("baudrate = %u bps\n", gd->baudrate);
return 0;
}
int main(int argc, char **argv)
{
t_list pw;
int *tab;
ft_sys("Verification 1 --argc", 1, -10, argc);
ft_sys("Verification 2 --number check", 1, 1, verif_argv(argv + 1));
ft_sys("Starting program --Push Swap", 0, 0, 0);
pw = get_list(argc - 1, argv + 1);
print_num(pw.pile1, pw.p1_len);
print_num(pw.pile2, pw.p2_len);
tab = get_sort_tab(pw);
num_select(&pw, tab);
return (0);
}
int printf(const char *format, ...) {
va_list ap;
char *fmt = (char *)format;
int d;
char c;
char *s;
va_start(ap, format);
while(*fmt) {
c = *fmt++;
if(c != '%') {
put_char(c);
continue;
}
switch(*fmt++) {
case 'd':
d = va_arg(ap, int);
print_num(d, 10);
break;
case 'x':
d = va_arg(ap, int);
print_num(d, 16);
break;
case 'c':
d = va_arg(ap, int);
put_char(d);
break;
case 's':
s = va_arg(ap, char *);
while(*s != '\0') {
put_char(*s++);
}
break;
case 'b':
d = va_arg(ap, int);
print_num(d, 2);
break;
case 'o':
d = va_arg(ap, int);
print_num(d, 8);
break;
}
}
va_end(ap);
return 0;
}
void process_digits(int arr[], size_t n) {
int idx = 0, val;
int backFlg = 0;
while(1) {
if(idx == n) { /* A new n-digits number found */
print_num(arr, n); /* print the number */
idx--; /* move back */
backFlg = 1; /* set the "moving back" flag */
}
if(idx == 0 || backFlg == 1) /* If it's the top digit, */
val = arr[idx] + 1; /* or backflg was set */
else
val = arr[idx-1] + 1; /* When moving forward, the digit at pos- */
/* ition idx should be larger by one than */
/* the digit at position idx-1 */
if(val < 10) { /* If val for postion idx is valid, we should */
arr[idx] = val; /* set the value, and then move forward. */
idx++;
backFlg = 0;
} else { /* Or else, moving back */
idx--;
backFlg = 1;
if(idx < 0) /* the only exit, when all numbers have been found */
break;
}
}
}
int do_bdinfo ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
bd_t *bd = gd->bd;
print_num ("memstart", (ulong)bd->bi_memstart);
print_lnum ("memsize", (u64)bd->bi_memsize);
print_num ("flashstart", (ulong)bd->bi_flashstart);
print_num ("flashsize", (ulong)bd->bi_flashsize);
print_num ("flashoffset", (ulong)bd->bi_flashoffset);
print_eth(0);
printf ("ip_addr = %pI4\n", &bd->bi_ip_addr);
printf ("baudrate = %ld bps\n", bd->bi_baudrate);
return 0;
}
/** print %llp */
static void
print_num_llp(char **at, size_t * left, int *ret, void *value,
int minw, int precision, int prgiven, int zeropad, int minus,
int plus, int space)
{
char buf[PRINT_DEC_BUFSZ];
int negative = 0;
int zero = (value == 0);
#if defined(SIZE_MAX) && defined(UINT32_MAX) && (UINT32_MAX == SIZE_MAX || INT32_MAX == SIZE_MAX)
/* avoid warning about upcast on 32bit systems */
unsigned long long llvalue = (unsigned long)value;
#else
unsigned long long llvalue = (unsigned long long)value;
#endif
int len = print_hex_ll(buf, (int)sizeof(buf), llvalue);
if (zero) {
buf[0] = ')';
buf[1] = 'l';
buf[2] = 'i';
buf[3] = 'n';
buf[4] = '(';
len = 5;
} else {
/* put '0x' in front of the (reversed) buffer result */
if (len < PRINT_DEC_BUFSZ)
buf[len++] = 'x';
if (len < PRINT_DEC_BUFSZ)
buf[len++] = '0';
}
print_num(at, left, ret, minw, precision, prgiven, zeropad, minus,
plus, space, zero, negative, buf, len);
}
int main()
{
// store a free function
std::function<void(int)> f_display = print_num;
f_display(-9);
// store a lambda
std::function<void()> f_display_42 = []() { print_num(42); };
f_display_42();
// store the result of a call to std::bind
std::function<void()> f_display_31337 = std::bind(print_num, 31337);
f_display_31337();
// store a call to a member function
//std::function<void(const IFoo&, int)> f_add_display = &Foo::print_add;
Foo foo;
std::function<void(int)> f_add_display = std::bind(&Foo::print_add, &foo, std::placeholders::_1);
f_add_display(1);
f_add_display = nullptr;
if (f_add_display)
{
std::cout << "Should not write thuis." << '\n';
}
// store a call to a function object
std::function<void(int)> f_display_obj = PrintNum();
f_display_obj(18);
}
int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
bd_t *bd = gd->bd;
print_num("mem start ", (ulong)bd->bi_memstart);
print_lnum("mem size ", (u64)bd->bi_memsize);
print_num("flash start ", (ulong)bd->bi_flashstart);
print_num("flash size ", (ulong)bd->bi_flashsize);
print_num("flash offset ", (ulong)bd->bi_flashoffset);
#if defined(CONFIG_CMD_NET)
print_eth(0);
printf("ip_addr = %s\n", getenv("ipaddr"));
#endif
printf("baudrate = %u bps\n", bd->bi_baudrate);
return 0;
}
void find_target() {
clear_screen();
print_string("Targg");
motor_spin_left();
left_count = 0;
while (get_range() > MAX_RANGE && left_count < 5 * NINETY_DEGREES) {
clear_screen();
print_num(get_range());
_delay_ms(20);
}
motor_stop();
if (left_count >= 5 * NINETY_DEGREES) {
motor_forward();
left_count = 0;
while (left_count < 90);
motor_stop();
}
else {
motor_spin_right();
_delay_ms(20);
motor_stop();
state = &attack;
}
}
void __fastcall__ joker_hit(char pl){
char i,j;
stop = 1;
kill_joker();
matrix[joker_y][joker_x] = joker_tmp;
sc = level*10;
for (i=0;i<8;++i){
for(j=0;j<8;++j){
if (matrix[i][j] == joker_tmp){
print3x3(matrix[i][j]+8,j,i);
}
}
}
delay(20);
for (i=0;i<8;++i){
for(j=0;j<8;++j){
if (matrix[i][j] == joker_tmp){
if (hits[joker_tmp]){
--hits[joker_tmp];
print_hits();
}
print3x3(matrix[i][j]=EMPTY_SYMB,j,i);
plot_score(sc,XOFFS+3*j,3*i+1);
print_num(score[pl]+=sc,6,28,22-(players<<1)+(pl<<1));
}
}
}
move_matrix();
check_matrix(1);
stop = 0;
}
/*
* print_num() - Prints a number to stdout.
* @n: The number to print.
*
* Return: Void.
*/
void print_num(int n)
{
if (n >= 10) {
print_num(n / 10);
}
print_char(n % 10 + 48);
}
int main() {
print_num(weakSym);
if (print) {
print("hello, world!\n");
}
return 0;
}
void dumpmodemparms (char *modem)
{
printf ("modem parms for %s\n", modem);
print_str (dial_command);
print_str (hangup_command);
print_str (echo_off_command);
print_str (reset_command);
print_str (init_string);
print_str (escape_sequence);
print_num (lock_baud);
print_num (intercharacter_delay);
print_num (intercommand_delay);
print_num (escape_guard_time);
print_num (reset_delay);
printf ("\n");
}
void printf(char* text,...)
{
int index=-1;
int param_index=0;
int** param_val;
int params[1];
int sys_num=4;
while (text[++index]!='\0')
{
if (text[index]=='%' && text[index+1]=='d')
{
index+=2;
param_index++;
GET_FROM_STACK(param_index,param_val);
print_num(*param_val);
}
else if (text[index]=='%' && text[index+1]=='s')
{
index+=2;
param_index++;
GET_FROM_STACK(param_index,param_val);
print_char(*param_val);
}
params[0]=text[index];
SYSCALL(4,params);
}
}
int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
bd_t *bd = gd->bd;
print_num("boot_params", (ulong)bd->bi_boot_params);
print_num("memstart", (ulong)bd->bi_memstart);
print_lnum("memsize", (u64)bd->bi_memsize);
print_num("flashstart", (ulong)bd->bi_flashstart);
print_num("flashsize", (ulong)bd->bi_flashsize);
print_num("flashoffset", (ulong)bd->bi_flashoffset);
print_eth(0);
printf("ip_addr = %s\n", getenv("ipaddr"));
printf("baudrate = %lu bps\n", bd->bi_baudrate);
return 0;
}
