void clock(int sec) { while(1) { BEEP(1); Delay(100000); BEEP(0); Delay(100000); if(setTime[5]==sec) break; } }
/* * Check if the value lies outside the low/high range. If so, force it in. */ static void limitCurrentValue (CDKUSCALE *widget) { if (widget->current < widget->low) { widget->current = widget->low; BEEP(); } else if (widget->current > widget->high) { widget->current = widget->high; BEEP(); } }
int mutt_yesorno (const char *msg, int def) { event_t ch; unsigned char *yes = (unsigned char *) _("yes"); unsigned char *no = (unsigned char *) _("no"); CLEARLINE(LINES-1); printw("%s ([%c]/%c): ", msg, def ? *yes : *no, def ? *no : *yes); FOREVER { mutt_refresh (); ch = mutt_getch (); if (ch.ch == -1) return(-1); if (CI_is_return (ch.ch)) break; else if (tolower(ch.ch) == tolower(*yes)) { def = 1; break; } else if (tolower(ch.ch) == tolower(*no)) { def = 0; break; } else { BEEP(); } } addstr ((char *) (def ? yes : no)); mutt_refresh (); return (def); }
void brandt8641_state::brandt8641(machine_config &config) { /* basic machine hardware */ Z80(config, m_maincpu, XTAL(4'000'000)); // U4 ,4MHz crystal on board m_maincpu->set_addrmap(AS_PROGRAM, &brandt8641_state::brandt8641_mem); m_maincpu->set_addrmap(AS_IO, &brandt8641_state::brandt8641_io); m_maincpu->set_daisy_config(daisy_chain_intf); /* sound hardware */ SPEAKER(config, "mono").front_center(); BEEP(config, m_beep, 2000).add_route(ALL_OUTPUTS, "mono", 0.50); // Z80APIO U9 // Z80APIO U14 // Z80PIO U7 - unknown which is which Z80PIO(config, m_pio1, XTAL(4'000'000)); m_pio1->out_int_callback().set_inputline(m_maincpu, INPUT_LINE_IRQ0); Z80PIO(config, m_pio2, XTAL(4'000'000)); m_pio2->out_int_callback().set_inputline(m_maincpu, INPUT_LINE_IRQ0); m_pio2->in_pa_callback().set(FUNC(brandt8641_state::port08_r)); m_pio2->out_pa_callback().set(FUNC(brandt8641_state::port08_w)); m_pio2->out_pb_callback().set(FUNC(brandt8641_state::port09_w)); Z80PIO(config, m_pio3, XTAL(4'000'000)); m_pio3->out_int_callback().set_inputline(m_maincpu, INPUT_LINE_IRQ0); Z80CTC(config, "ctc", XTAL(4'000'000)); // Z80CTC U8 }
GFXDECODE_END void mbc200_state::mbc200(machine_config &config) { /* basic machine hardware */ Z80(config, m_maincpu, 8_MHz_XTAL / 2); // NEC D780C-1 m_maincpu->set_addrmap(AS_PROGRAM, &mbc200_state::mbc200_mem); m_maincpu->set_addrmap(AS_IO, &mbc200_state::mbc200_io); z80_device &subcpu(Z80(config, "subcpu", 8_MHz_XTAL / 2)); // NEC D780C-1 subcpu.set_addrmap(AS_PROGRAM, &mbc200_state::mbc200_sub_mem); subcpu.set_addrmap(AS_IO, &mbc200_state::mbc200_sub_io); /* video hardware */ screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER)); screen.set_refresh_hz(50); screen.set_vblank_time(ATTOSECONDS_IN_USEC(2500)); /* not accurate */ screen.set_size(640, 400); screen.set_visarea(0, 640-1, 0, 400-1); screen.set_screen_update("crtc", FUNC(hd6845s_device::screen_update)); GFXDECODE(config, "gfxdecode", m_palette, gfx_mbc200); PALETTE(config, m_palette, palette_device::MONOCHROME); HD6845S(config, m_crtc, 8_MHz_XTAL / 4); // HD46505SP m_crtc->set_screen("screen"); m_crtc->set_show_border_area(false); m_crtc->set_char_width(8); m_crtc->set_update_row_callback(FUNC(mbc200_state::update_row), this); // sound SPEAKER(config, "mono").front_center(); BEEP(config, m_beep, 1000).add_route(ALL_OUTPUTS, "mono", 0.50); // frequency unknown SPEAKER_SOUND(config, m_speaker).add_route(ALL_OUTPUTS, "mono", 0.50); I8255(config, "ppi_1").out_pc_callback().set(FUNC(mbc200_state::p1_portc_w)); I8255(config, "ppi_2").in_pa_callback().set(FUNC(mbc200_state::p2_porta_r)); I8255(config, m_ppi_m); m_ppi_m->out_pa_callback().set(FUNC(mbc200_state::pm_porta_w)); m_ppi_m->out_pb_callback().set(FUNC(mbc200_state::pm_portb_w)); I8251(config, "uart1", 0); // INS8251N I8251(config, "uart2", 0); // INS8251A MB8876(config, m_fdc, 8_MHz_XTAL / 8); // guess FLOPPY_CONNECTOR(config, "fdc:0", mbc200_floppies, "qd", floppy_image_device::default_floppy_formats).enable_sound(true); FLOPPY_CONNECTOR(config, "fdc:1", mbc200_floppies, "qd", floppy_image_device::default_floppy_formats).enable_sound(true); /* Keyboard */ generic_keyboard_device &keyboard(GENERIC_KEYBOARD(config, "keyboard", 0)); keyboard.set_keyboard_callback(FUNC(mbc200_state::kbd_put)); /* software lists */ SOFTWARE_LIST(config, "flop_list").set_original("mbc200"); }
void Accept_to_complete(uint32_t *hour,uint32_t *min) { uint32_t one=0,two=0,three=0,four=0; switch(receive[1]) { case '1': one = (receive[2]-'0')*10+(receive[3]-'0'); two = (receive[4]-'0')*10+(receive[5]-'0'); three = (receive[7]-'0')*10+(receive[6]-'0'); four = (receive[8]-'0')*10+(receive[9]-'0'); *hour = one; *min = two; setTime[3] = three; setTime[4] = four; USART2_SendStringData("0101"); break; case '2': one = (receive[2]-'0')*10+(receive[3]-'0'); setPwm = one; /*** 设置pwm,改变灯的亮度 ***/ CCR4_Val= one*100; TIM3_Mode_Config(); printf("0101"); break; case '3': one = (receive[2]-'0')*10+(receive[3]-'0'); //一键闹醒 if(one==1) { BEEP(1); Delay(500000); BEEP(0); } printf("0101"); break; case '4': printf("03%03d55aa",vTemp/1000); break; default : printf("0202"); break; } }
/* * This injects a single character into the widget. */ static int _injectCDKButton (CDKOBJS *object, chtype input) { CDKBUTTON *widget = (CDKBUTTON *)object; int ret = unknownInt; bool complete = FALSE; setExitType (widget, 0); /* Check a predefined binding. */ if (checkCDKObjectBind (vBUTTON, widget, input) != 0) { checkEarlyExit (widget); complete = TRUE; } else { switch (input) { case KEY_ESC: setExitType (widget, input); complete = TRUE; break; case KEY_ERROR: setExitType (widget, input); complete = TRUE; break; case KEY_ENTER: case SPACE: if (widget->callback) widget->callback (widget); setExitType (widget, KEY_ENTER); ret = 0; complete = TRUE; break; case CDK_REFRESH: eraseCDKScreen (ScreenOf (widget)); refreshCDKScreen (ScreenOf (widget)); break; default: BEEP (); break; } } if (!complete) { setExitType (widget, 0); } ResultOf (widget).valueInt = ret; return (ret != unknownInt); }
/* * Set the edit position. Normally the cursor is one cell to the right of * the editable field. Moving it left, over the field allows the user to * modify cells by typing in replacement characters for the field's value. */ static void setEditPosition(CDKUSCALE *widget, int newPosition) { if (newPosition < 0) { BEEP(); } else if (newPosition == 0) { widget->fieldEdit = newPosition; } else if (validEditPosition(widget, newPosition)) { widget->fieldEdit = newPosition; } else { BEEP(); } }
/* This displays a message in the host editor's main window. * Used mostly for error messages. */ void HostWinMsg(const char *msg) { int maxy; maxy = getmaxy(gHostWin); DrawStrAt(gHostWin, maxy - 2, 0, msg); wclrtoeol(gHostWin); wmove(gHostWin, maxy - 1, 0); wrefresh(gHostWin); BEEP(1); gNeedToClearMsg = 1; } /* HostWinMsg */
void vt100_keyboard_device::device_add_mconfig(machine_config &config) { SPEAKER(config, "mono").front_center(); BEEP(config, m_speaker, 786); // 7.945us per serial clock = ~125865.324hz, / 160 clocks per char = ~ 786 hz m_speaker->add_route(ALL_OUTPUTS, "mono", 0.50); AY31015(config, m_uart); m_uart->write_so_callback().set(FUNC(vt100_keyboard_device::signal_out_w)); RIPPLE_COUNTER(config, m_scan_counter); // 2x 74LS93 m_scan_counter->set_stages(8); m_scan_counter->count_out_cb().set(FUNC(vt100_keyboard_device::key_scan_w)); }
pgp_key_t pgp_ask_for_key (char *tag, char *whatfor, short abilities, pgp_ring_t keyring) { pgp_key_t key; char resp[SHORT_STRING]; struct pgp_cache *l = NULL; mutt_clear_error (); resp[0] = 0; if (whatfor) { for (l = id_defaults; l; l = l->next) if (!mutt_strcasecmp (whatfor, l->what)) { strfcpy (resp, NONULL (l->dflt), sizeof (resp)); break; } } FOREVER { resp[0] = 0; if (mutt_get_field (tag, resp, sizeof (resp), M_CLEAR) != 0) return NULL; if (whatfor) { if (l) mutt_str_replace (&l->dflt, resp); else { l = safe_malloc (sizeof (struct pgp_cache)); l->next = id_defaults; id_defaults = l; l->what = safe_strdup (whatfor); l->dflt = safe_strdup (resp); } } if ((key = pgp_getkeybystr (resp, abilities, keyring))) return key; BEEP (); } /* not reached */ }
void a5105_state::a5105(machine_config &config) { /* basic machine hardware */ Z80(config, m_maincpu, XTAL(15'000'000) / 4); m_maincpu->set_addrmap(AS_PROGRAM, &a5105_state::a5105_mem); m_maincpu->set_addrmap(AS_IO, &a5105_state::a5105_io); m_maincpu->set_daisy_config(a5105_daisy_chain); /* video hardware */ SCREEN(config, m_screen, SCREEN_TYPE_RASTER); m_screen->set_refresh_hz(50); m_screen->set_vblank_time(ATTOSECONDS_IN_USEC(2500)); /* not accurate */ m_screen->set_screen_update("upd7220", FUNC(upd7220_device::screen_update)); m_screen->set_size(40*8, 32*8); m_screen->set_visarea(0, 40*8-1, 0, 25*8-1); GFXDECODE(config, m_gfxdecode, m_palette, gfx_a5105); PALETTE(config, m_palette, FUNC(a5105_state::a5105_palette), 16); /* sound hardware */ SPEAKER(config, "mono").front_center(); WAVE(config, "wave", "cassette").add_route(ALL_OUTPUTS, "mono", 0.25); BEEP(config, "beeper", 500).add_route(ALL_OUTPUTS, "mono", 0.50); /* Devices */ UPD7220(config, m_hgdc, XTAL(15'000'000) / 16); // unk clock m_hgdc->set_addrmap(0, &a5105_state::upd7220_map); m_hgdc->set_display_pixels(FUNC(a5105_state::hgdc_display_pixels)); m_hgdc->set_draw_text(FUNC(a5105_state::hgdc_draw_text)); z80ctc_device& ctc(Z80CTC(config, "z80ctc", XTAL(15'000'000) / 4)); ctc.intr_callback().set_inputline(m_maincpu, 0); ctc.zc_callback<0>().set("z80ctc", FUNC(z80ctc_device::trg2)); ctc.zc_callback<2>().set("z80ctc", FUNC(z80ctc_device::trg3)); z80pio_device& pio(Z80PIO(config, "z80pio", XTAL(15'000'000) / 4)); pio.in_pb_callback().set(FUNC(a5105_state::pio_pb_r)); pio.out_int_callback().set_inputline(m_maincpu, 0); CASSETTE(config, m_cass); UPD765A(config, m_fdc, 8'000'000, true, true); FLOPPY_CONNECTOR(config, "upd765a:0", a5105_floppies, "525qd", a5105_state::floppy_formats); FLOPPY_CONNECTOR(config, "upd765a:1", a5105_floppies, "525qd", a5105_state::floppy_formats); FLOPPY_CONNECTOR(config, "upd765a:2", a5105_floppies, "525qd", a5105_state::floppy_formats); FLOPPY_CONNECTOR(config, "upd765a:3", a5105_floppies, "525qd", a5105_state::floppy_formats); /* internal ram */ RAM(config, RAM_TAG).set_default_size("64K"); }
void mephisto_modena_state::modena(machine_config &config) { M65C02(config, m_maincpu, XTAL(4'194'304)); // W65C02SP m_maincpu->set_addrmap(AS_PROGRAM, &mephisto_modena_state::modena_mem); timer_device &nmi_on(TIMER(config, "nmi_on")); nmi_on.configure_periodic(FUNC(mephisto_modena_state::nmi_on), attotime::from_hz(XTAL(4'194'304) / (1 << 13))); nmi_on.set_start_delay(attotime::from_hz(XTAL(4'194'304) / (1 << 13)) - attotime::from_usec(975)); // active for 975us TIMER(config, "nmi_off").configure_periodic(FUNC(mephisto_modena_state::nmi_off), attotime::from_hz(XTAL(4'194'304) / (1 << 13))); NVRAM(config, "nvram", nvram_device::DEFAULT_ALL_0); MEPHISTO_BUTTONS_BOARD(config, m_board, 0); m_board->set_disable_leds(true); config.set_default_layout(layout_mephisto_modena); /* sound hardware */ SPEAKER(config, "mono").front_center(); BEEP(config, m_beeper, 3250).add_route(ALL_OUTPUTS, "mono", 1.0); }
void epson_ex800_device::device_add_mconfig(machine_config &config) { /* basic machine hardware */ upd7810_device &upd(UPD7810(config, m_maincpu, 12000000)); // 12 MHz? upd.set_addrmap(AS_PROGRAM, &epson_ex800_device::ex800_mem); upd.pa_in_cb().set(FUNC(epson_ex800_device::porta_r)); upd.pa_out_cb().set(FUNC(epson_ex800_device::porta_w)); upd.pb_in_cb().set(FUNC(epson_ex800_device::portb_r)); upd.pb_out_cb().set(FUNC(epson_ex800_device::portb_w)); upd.pc_in_cb().set(FUNC(epson_ex800_device::portc_r)); upd.pc_out_cb().set(FUNC(epson_ex800_device::portc_w)); config.set_default_layout(layout_ex800); /* audio hardware */ SPEAKER(config, "mono").front_center(); BEEP(config, m_beeper, 4000); // measured at 4000 Hz */ m_beeper->add_route(ALL_OUTPUTS, "mono", 1.0); }
void trs80dt1_state::trs80dt1(machine_config &config) { /* basic machine hardware */ I8051(config, m_maincpu, 7372800); m_maincpu->set_addrmap(AS_PROGRAM, &trs80dt1_state::prg_map); m_maincpu->set_addrmap(AS_IO, &trs80dt1_state::io_map); m_maincpu->port_out_cb<1>().set(FUNC(trs80dt1_state::port1_w)); m_maincpu->port_out_cb<3>().set(FUNC(trs80dt1_state::port3_w)); /* video hardware */ screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER)); screen.set_screen_update("crtc", FUNC(i8276_device::screen_update)); screen.set_refresh_hz(60); screen.set_vblank_time(ATTOSECONDS_IN_USEC(2500)); /* not accurate */ screen.set_size(40*12, 16*16); screen.set_visarea(0, 40*12-1, 0, 16*16-1); GFXDECODE(config, "gfxdecode", m_palette, gfx_trs80dt1); I8276(config, m_crtc, 12480000 / 8); m_crtc->set_character_width(8); m_crtc->set_display_callback(FUNC(trs80dt1_state::crtc_update_row), this); m_crtc->drq_wr_callback().set_inputline(m_maincpu, MCS51_INT0_LINE); // BRDY pin goes through inverter to /INT0, so we don't invert m_crtc->irq_wr_callback().set(m_7474, FUNC(ttl7474_device::clear_w)); // INT pin m_crtc->irq_wr_callback().append(m_7474, FUNC(ttl7474_device::d_w)); m_crtc->vrtc_wr_callback().set(m_7474, FUNC(ttl7474_device::clock_w)); m_crtc->set_screen("screen"); PALETTE(config, "palette").set_entries(3); X2210(config, "nvram"); TTL7474(config, m_7474, 0); m_7474->comp_output_cb().set_inputline(m_maincpu, MCS51_INT1_LINE).invert(); // /Q connects directly to /INT1, so we need to invert? /* sound hardware */ SPEAKER(config, "mono").front_center(); BEEP(config, m_beep, 2000); m_beep->add_route(ALL_OUTPUTS, "mono", 0.50); }
int mutt_multi_choice (char *prompt, char *letters) { event_t ch; int choice; char *p; mvaddstr (LINES - 1, 0, prompt); clrtoeol (); FOREVER { mutt_refresh (); ch = mutt_getch (); if (ch.ch == -1 || CI_is_return (ch.ch)) { choice = -1; break; } else { p = strchr (letters, ch.ch); if (p) { choice = p - letters + 1; break; } else if (ch.ch <= '9' && ch.ch > '0') { choice = ch.ch - '0'; if (choice <= mutt_strlen (letters)) break; } } BEEP (); } CLEARLINE (LINES - 1); mutt_refresh (); return choice; }
/*************************************************************************** Child main program ***************************************************************************/ int child_main(Controller* ctlPtrChild) { struct timespec lastSleep; long PWMcounter; long beepCounter; int PWM; //make sure output is not buffered (this program generally a child to a nodejs program) and set signal handler setbuf(stdout, NULL); setbuf(stderr, NULL); signal(SIGINT, sig_handler_child); signal(SIGTERM, sig_handler_child); PWMcounter = 0; beepCounter = 0; clock_gettime(CLOCK_MONOTONIC, &lastSleep); //capture current time as time of 'last sleep' while (1) { sync_clock_delay(PWMCycle_ns, &lastSleep); PWM = (int)(ctlPtrChild->out + 0.5); PWMcounter++; // PWMcounter %= 100; if (PWMcounter == 100) { // printf("PWM: %d, Out: %f\n",PWM, ctlPtrChild->out); PWMcounter = 0; pidControl(ctlPtrChild); //run PID algorithm printJSON(ctlPtrChild); //send data out formatted as JSON } if (PWMcounter < PWM) { GPIO_SET = 1<<SSR1_GPIO; //turn on SSR pin } else { GPIO_CLR = 1<<SSR1_GPIO; //turn off SSR pin // printf("SSR Off. PWM: %d, PWMcounter: %d, Out: %f\n", PWM, PWMcounter, ctlPtrChild->out); } //Manage beeper ctlPtrChild->beep_mode = BEEP(ctlPtrChild->beep_mode); } }
void mutt_curses_error (const char *fmt, ...) { va_list ap; va_start (ap, fmt); vsnprintf (Errorbuf, sizeof (Errorbuf), fmt, ap); va_end (ap); dprint (1, (debugfile, "%s\n", Errorbuf)); Errorbuf[ (COLS < sizeof (Errorbuf) ? COLS : sizeof (Errorbuf)) - 2 ] = 0; clean_error_buf(); if (!option (OPTKEEPQUIET)) { BEEP (); SETCOLOR (MT_COLOR_ERROR); mvaddstr (LINES-1, 0, Errorbuf); clrtoeol (); SETCOLOR (MT_COLOR_NORMAL); mutt_refresh (); } set_option (OPTMSGERR); }
int main(void) { BEEP(0); sys_Start(); }
void pve500_state::pve500(machine_config &config) { /* Main CPU */ TMPZ84C015(config, m_maincpu, 12_MHz_XTAL / 2); // TMPZ84C015BF-6 m_maincpu->set_addrmap(AS_PROGRAM, &pve500_state::maincpu_prg); m_maincpu->set_addrmap(AS_IO, &pve500_state::maincpu_io); m_maincpu->set_daisy_config(maincpu_daisy_chain); m_maincpu->out_dtra_callback().set(FUNC(pve500_state::GPI_w)); m_maincpu->out_dtrb_callback().set(m_buzzer, FUNC(beep_device::set_state)).invert(); m_maincpu->out_txda_callback().set("recorder", FUNC(rs232_port_device::write_txd)); m_maincpu->out_txdb_callback().set("player1", FUNC(rs232_port_device::write_txd)); z80ctc_device& ctc(Z80CTC(config, "external_ctc", 12_MHz_XTAL / 2)); ctc.intr_callback().set_inputline(m_maincpu, INPUT_LINE_IRQ0); z80sio0_device& sio(Z80SIO0(config, "external_sio", 12_MHz_XTAL / 2)); sio.out_int_callback().set_inputline(m_maincpu, INPUT_LINE_IRQ0); sio.out_txda_callback().set("player2", FUNC(rs232_port_device::write_txd)); sio.out_txdb_callback().set("edl_inout", FUNC(rs232_port_device::write_txd)); /* Secondary CPU */ TMPZ84C015(config, m_subcpu, 12_MHz_XTAL / 2); /* TMPZ84C015BF-6 */ m_subcpu->set_addrmap(AS_PROGRAM, &pve500_state::subcpu_prg); m_subcpu->set_addrmap(AS_IO, &pve500_state::subcpu_io); m_subcpu->out_dtra_callback().set(FUNC(pve500_state::cxdio_reset_w)); m_subcpu->out_dtrb_callback().set(FUNC(pve500_state::external_monitor_w)); m_subcpu->out_txda_callback().set("switcher", FUNC(rs232_port_device::write_txd)); m_subcpu->out_txdb_callback().set("serial_mixer", FUNC(rs232_port_device::write_txd)); // PIO callbacks m_subcpu->in_pa_callback().set(FUNC(pve500_state::eeprom_r)); m_subcpu->out_pa_callback().set(FUNC(pve500_state::eeprom_w)); // ICG3: I/O Expander CXD1095(config, m_cxdio, 0); m_cxdio->out_porta_cb().set(FUNC(pve500_state::io_sc_w)); m_cxdio->out_portb_cb().set(FUNC(pve500_state::io_le_w)); m_cxdio->in_portc_cb().set(FUNC(pve500_state::io_ky_r)); m_cxdio->out_portd_cb().set(FUNC(pve500_state::io_ld_w)); m_cxdio->out_porte_cb().set(FUNC(pve500_state::io_sel_w)); /* Search Dial MCUs */ MB88201(config, "dial_mcu_left", 4_MHz_XTAL).set_disable(); /* PLAYER DIAL MCU */ MB88201(config, "dial_mcu_right", 4_MHz_XTAL).set_disable(); /* RECORDER DIAL MCU */ /* Serial EEPROM (128 bytes, 8-bit data organization) */ /* The EEPROM stores the setup data */ EEPROM_MSM16911_8BIT(config, "eeprom"); /* FIX-ME: These are actually RS422 ports (except EDL IN/OUT which is indeed an RS232 port)*/ rs232_port_device &recorder(RS232_PORT(config, "recorder", default_rs232_devices, nullptr)); recorder.rxd_handler().set(m_maincpu, FUNC(tmpz84c015_device::rxa_w)); rs232_port_device &player1(RS232_PORT(config, "player1", default_rs232_devices, nullptr)); player1.rxd_handler().set(m_maincpu, FUNC(tmpz84c015_device::rxb_w)); rs232_port_device &player2(RS232_PORT(config, "player2", default_rs232_devices, nullptr)); player2.rxd_handler().set("external_sio", FUNC(z80dart_device::rxa_w)); rs232_port_device &edl_inout(RS232_PORT(config, "edl_inout", default_rs232_devices, nullptr)); edl_inout.rxd_handler().set("external_sio", FUNC(z80dart_device::rxb_w)); rs232_port_device &switcher(RS232_PORT(config, "switcher", default_rs232_devices, nullptr)); switcher.rxd_handler().set(m_subcpu, FUNC(tmpz84c015_device::rxa_w)); rs232_port_device &serial_mixer(RS232_PORT(config, "serial_mixer", default_rs232_devices, nullptr)); serial_mixer.rxd_handler().set(m_subcpu, FUNC(tmpz84c015_device::rxb_w)); clock_device &clk1(CLOCK(config, "clk1", 12_MHz_XTAL / 20)); clk1.signal_handler().set(m_maincpu, FUNC(tmpz84c015_device::rxca_w)); clk1.signal_handler().append(m_maincpu, FUNC(tmpz84c015_device::txca_w)); clk1.signal_handler().append(m_maincpu, FUNC(tmpz84c015_device::rxcb_w)); clk1.signal_handler().append(m_maincpu, FUNC(tmpz84c015_device::txcb_w)); clk1.signal_handler().append(m_subcpu, FUNC(tmpz84c015_device::rxca_w)); clk1.signal_handler().append(m_subcpu, FUNC(tmpz84c015_device::txca_w)); clk1.signal_handler().append(m_subcpu, FUNC(tmpz84c015_device::rxcb_w)); clk1.signal_handler().append(m_subcpu, FUNC(tmpz84c015_device::txcb_w)); /* ICF5: 2kbytes of RAM shared between the two CPUs (dual-port RAM)*/ mb8421_device &mb8421(MB8421(config, "mb8421")); mb8421.intl_callback().set(FUNC(pve500_state::mb8421_intl)); mb8421.intr_callback().set(FUNC(pve500_state::mb8421_intr)); /* video hardware */ config.set_default_layout(layout_pve500); /* audio hardware */ SPEAKER(config, "mono").front_center(); BEEP(config, "buzzer", 12_MHz_XTAL / 3200).add_route(ALL_OUTPUTS, "mono", 0.05); // 3.75 kHz CLK2 coming out of IC D4 (frequency divider circuitry) }
/* * This allows the user to use the cursor keys to adjust the * position of the widget. */ void positionCDKButton (CDKBUTTON *button) { /* Declare some variables. */ int origX = getbegx (button->win); int origY = getbegy (button->win); chtype key = (chtype)0; boolean functionKey; /* Let them move the widget around until they hit return. */ while (key != KEY_ENTER) { key = (chtype)getchCDKObject (ObjOf (button), &functionKey); if (key == KEY_UP || key == '8') { if (getbegy (button->win) > 0) { moveCDKButton (button, 0, -1, TRUE, TRUE); } else { BEEP (); } } else if (key == KEY_DOWN || key == '2') { if (getbegy (button->win) + getmaxy (button->win) < getmaxy (WindowOf (button)) - 1) { moveCDKButton (button, 0, 1, TRUE, TRUE); } else { BEEP (); } } else if (key == KEY_LEFT || key == '4') { if (getbegx (button->win) > 0) { moveCDKButton (button, -1, 0, TRUE, TRUE); } else { BEEP (); } } else if (key == KEY_RIGHT || key == '6') { if (getbegx (button->win) + getmaxx (button->win) < getmaxx (WindowOf (button)) - 1) { moveCDKButton (button, 1, 0, TRUE, TRUE); } else { BEEP (); } } else if (key == '7') { if (getbegy (button->win) > 0 && getbegx (button->win) > 0) { moveCDKButton (button, -1, -1, TRUE, TRUE); } else { BEEP (); } } else if (key == '9') { if (getbegx (button->win) + getmaxx (button->win) < getmaxx (WindowOf (button)) - 1 && getbegy (button->win) > 0) { moveCDKButton (button, 1, -1, TRUE, TRUE); } else { BEEP (); } } else if (key == '1') { if (getbegx (button->win) > 0 && getbegx (button->win) + getmaxx (button->win) < getmaxx (WindowOf (button)) - 1) { moveCDKButton (button, -1, 1, TRUE, TRUE); } else { BEEP (); } } else if (key == '3') { if (getbegx (button->win) + getmaxx (button->win) < getmaxx (WindowOf (button)) - 1 && getbegy (button->win) + getmaxy (button->win) < getmaxy (WindowOf (button)) - 1) { moveCDKButton (button, 1, 1, TRUE, TRUE); } else { BEEP (); } } else if (key == '5') { moveCDKButton (button, CENTER, CENTER, FALSE, TRUE); } else if (key == 't') { moveCDKButton (button, getbegx (button->win), TOP, FALSE, TRUE); } else if (key == 'b') { moveCDKButton (button, getbegx (button->win), BOTTOM, FALSE, TRUE); } else if (key == 'l') { moveCDKButton (button, LEFT, getbegy (button->win), FALSE, TRUE); } else if (key == 'r') { moveCDKButton (button, RIGHT, getbegy (button->win), FALSE, TRUE); } else if (key == 'c') { moveCDKButton (button, CENTER, getbegy (button->win), FALSE, TRUE); } else if (key == 'C') { moveCDKButton (button, getbegx (button->win), CENTER, FALSE, TRUE); } else if (key == CDK_REFRESH) { eraseCDKScreen (ScreenOf (button)); refreshCDKScreen (ScreenOf (button)); } else if (key == KEY_ESC) { moveCDKButton (button, origX, origY, FALSE, TRUE); } else if (key != KEY_ENTER) { BEEP (); } } }
/* * This allows the user to use the cursor keys to adjust the * position of the widget. */ void positionCDKObject (CDKOBJS *obj, WINDOW *win) { /* *INDENT-EQLS* */ CDKSCREEN *screen = ScreenOf (obj); WINDOW *parent = screen->window; int origX = getbegx (win); int origY = getbegy (win); int begX = getbegx (parent); int begY = getbegy (parent); int endX = begX + getmaxx (WindowOf (obj)); int endY = begY + getmaxy (WindowOf (obj)); chtype key; boolean functionKey; /* Let them move the widget around until they hit return. */ while ((key = (chtype)getchCDKObject (obj, &functionKey)) != KEY_ENTER) { switch (key) { case KEY_UP: case '8': if (getbegy (win) > begY) { moveCDKObject (obj, 0, -1, TRUE, TRUE); } else { BEEP (); } break; case KEY_DOWN: case '2': if (getendy (win) < endY) { moveCDKObject (obj, 0, 1, TRUE, TRUE); } else { BEEP (); } break; case KEY_LEFT: case '4': if (getbegx (win) > begX) { moveCDKObject (obj, -1, 0, TRUE, TRUE); } else { BEEP (); } break; case KEY_RIGHT: case '6': if (getendx (win) < endX) { moveCDKObject (obj, 1, 0, TRUE, TRUE); } else { BEEP (); } break; case '7': if (getbegy (win) > begY && getbegx (win) > begX) { moveCDKObject (obj, -1, -1, TRUE, TRUE); } else { BEEP (); } break; case '9': if (getendx (win) < endX && getbegy (win) > begY) { moveCDKObject (obj, 1, -1, TRUE, TRUE); } else { BEEP (); } break; case '1': if (getbegx (win) > begX && getendy (win) < endY) { moveCDKObject (obj, -1, 1, TRUE, TRUE); } else { BEEP (); } break; case '3': if (getendx (win) < endX && getendy (win) < endY) { moveCDKObject (obj, 1, 1, TRUE, TRUE); } else { BEEP (); } break; case '5': moveCDKObject (obj, CENTER, CENTER, FALSE, TRUE); break; case 't': moveCDKObject (obj, getbegx (win), TOP, FALSE, TRUE); break; case 'b': moveCDKObject (obj, getbegx (win), BOTTOM, FALSE, TRUE); break; case 'l': moveCDKObject (obj, LEFT, getbegy (win), FALSE, TRUE); break; case 'r': moveCDKObject (obj, RIGHT, getbegy (win), FALSE, TRUE); break; case 'c': moveCDKObject (obj, CENTER, getbegy (win), FALSE, TRUE); break; case 'C': moveCDKObject (obj, getbegx (win), CENTER, FALSE, TRUE); break; case CDK_REFRESH: eraseCDKScreen (ScreenOf (obj)); refreshCDKScreen (ScreenOf (obj)); break; case KEY_ESC: moveCDKObject (obj, origX, origY, FALSE, TRUE); break; default: BEEP (); break; } } }
/** * mutt_multi_choice - Offer the user a multiple choice question * @param prompt Message prompt * @param letters Allowable selection keys * @retval >=0 0-based user selection * @retval -1 Selection aborted */ int mutt_multi_choice(const char *prompt, const char *letters) { struct Event ch; int choice; bool redraw = true; int prompt_lines = 1; char *p = NULL; while (true) { if (redraw || SigWinch) { redraw = false; if (SigWinch) { SigWinch = 0; mutt_resize_screen(); clearok(stdscr, TRUE); mutt_menu_current_redraw(); } if (MuttMessageWindow->cols) { prompt_lines = (mutt_strwidth(prompt) + MuttMessageWindow->cols - 1) / MuttMessageWindow->cols; prompt_lines = MAX(1, MIN(3, prompt_lines)); } if (prompt_lines != MuttMessageWindow->rows) { mutt_window_reflow_message_rows(prompt_lines); mutt_menu_current_redraw(); } SETCOLOR(MT_COLOR_PROMPT); mutt_window_mvaddstr(MuttMessageWindow, 0, 0, prompt); NORMAL_COLOR; mutt_window_clrtoeol(MuttMessageWindow); } mutt_refresh(); /* SigWinch is not processed unless timeout is set */ mutt_getch_timeout(30 * 1000); ch = mutt_getch(); mutt_getch_timeout(-1); if (ch.ch == -2) continue; /* (ch.ch == 0) is technically possible. Treat the same as < 0 (abort) */ if ((ch.ch <= 0) || CI_is_return(ch.ch)) { choice = -1; break; } else { p = strchr(letters, ch.ch); if (p) { choice = p - letters + 1; break; } else if ((ch.ch <= '9') && (ch.ch > '0')) { choice = ch.ch - '0'; if (choice <= mutt_str_strlen(letters)) break; } } BEEP(); } if (MuttMessageWindow->rows != 1) { mutt_window_reflow_message_rows(1); mutt_menu_current_redraw(); } else mutt_window_clearline(MuttMessageWindow, 0); mutt_refresh(); return choice; }
/** * mutt_yesorno - Ask the user a Yes/No question * @param msg Prompt * @param def Default answer, see #QuadOption * @retval num Selection made, see #QuadOption */ enum QuadOption mutt_yesorno(const char *msg, enum QuadOption def) { struct Event ch; char *yes = _("yes"); char *no = _("no"); char *answer_string = NULL; int answer_string_wid, msg_wid; size_t trunc_msg_len; bool redraw = true; int prompt_lines = 1; char *expr = NULL; regex_t reyes; regex_t reno; char answer[2]; answer[1] = '\0'; bool reyes_ok = (expr = nl_langinfo(YESEXPR)) && (expr[0] == '^') && (REGCOMP(&reyes, expr, REG_NOSUB) == 0); bool reno_ok = (expr = nl_langinfo(NOEXPR)) && (expr[0] == '^') && (REGCOMP(&reno, expr, REG_NOSUB) == 0); /* In order to prevent the default answer to the question to wrapped * around the screen in the even the question is wider than the screen, * ensure there is enough room for the answer and truncate the question * to fit. */ safe_asprintf(&answer_string, " ([%s]/%s): ", (def == MUTT_YES) ? yes : no, (def == MUTT_YES) ? no : yes); answer_string_wid = mutt_strwidth(answer_string); msg_wid = mutt_strwidth(msg); while (true) { if (redraw || SigWinch) { redraw = false; if (SigWinch) { SigWinch = 0; mutt_resize_screen(); clearok(stdscr, TRUE); mutt_menu_current_redraw(); } if (MuttMessageWindow->cols) { prompt_lines = (msg_wid + answer_string_wid + MuttMessageWindow->cols - 1) / MuttMessageWindow->cols; prompt_lines = MAX(1, MIN(3, prompt_lines)); } if (prompt_lines != MuttMessageWindow->rows) { mutt_window_reflow_message_rows(prompt_lines); mutt_menu_current_redraw(); } /* maxlen here is sort of arbitrary, so pick a reasonable upper bound */ trunc_msg_len = mutt_wstr_trunc( msg, 4 * prompt_lines * MuttMessageWindow->cols, prompt_lines * MuttMessageWindow->cols - answer_string_wid, NULL); mutt_window_move(MuttMessageWindow, 0, 0); SETCOLOR(MT_COLOR_PROMPT); addnstr(msg, trunc_msg_len); addstr(answer_string); NORMAL_COLOR; mutt_window_clrtoeol(MuttMessageWindow); } mutt_refresh(); /* SigWinch is not processed unless timeout is set */ mutt_getch_timeout(30 * 1000); ch = mutt_getch(); mutt_getch_timeout(-1); if (ch.ch == -2) continue; if (CI_is_return(ch.ch)) break; if (ch.ch < 0) { def = MUTT_ABORT; break; } answer[0] = ch.ch; if (reyes_ok ? (regexec(&reyes, answer, 0, 0, 0) == 0) : (tolower(ch.ch) == 'y')) { def = MUTT_YES; break; } else if (reno_ok ? (regexec(&reno, answer, 0, 0, 0) == 0) : (tolower(ch.ch) == 'n')) { def = MUTT_NO; break; } else { BEEP(); } } FREE(&answer_string); if (reyes_ok) regfree(&reyes); if (reno_ok) regfree(&reno); if (MuttMessageWindow->rows != 1) { mutt_window_reflow_message_rows(1); mutt_menu_current_redraw(); } else mutt_window_clearline(MuttMessageWindow, 0); if (def != MUTT_ABORT) { addstr((char *) ((def == MUTT_YES) ? yes : no)); mutt_refresh(); } else { /* when the users cancels with ^G, clear the message stored with * mutt_message() so it isn't displayed when the screen is refreshed. */ mutt_clear_error(); } return def; }
/* * This function injects a single character into the widget. */ static int _injectCDKUScale (CDKOBJS *object, chtype input) { CDKUSCALE *widget = (CDKUSCALE *)object; int ppReturn = 1; unsigned ret = unknownUnsigned; bool complete = FALSE; /* Set the exit type. */ setExitType(widget, 0); /* Draw the field. */ drawCDKUScaleField (widget); /* Check if there is a pre-process function to be called. */ if (PreProcessFuncOf(widget) != 0) { /* Call the pre-process function. */ ppReturn = PreProcessFuncOf(widget) (vUSCALE, widget, PreProcessDataOf(widget), input); } /* Should we continue? */ if (ppReturn != 0) { /* Check for a key binding. */ if (checkCDKObjectBind(vUSCALE, widget, input) != 0) { checkEarlyExit(widget); complete = TRUE; } else { switch (input) { case KEY_LEFT : setEditPosition(widget, widget->fieldEdit + 1); break; case KEY_RIGHT : setEditPosition(widget, widget->fieldEdit - 1); break; case KEY_DOWN : Decrement(widget->current, widget->inc); break; case KEY_UP : Increment(widget->current, widget->inc); break; case KEY_PPAGE : Increment(widget->current, widget->fastinc); break; case KEY_NPAGE : Decrement(widget->current, widget->fastinc); break; case KEY_HOME : widget->current = widget->low; break; case KEY_END : widget->current = widget->high; break; case KEY_TAB : case KEY_ENTER : setExitType(widget, input); ret = (widget->current); complete = TRUE; break; case KEY_ESC : setExitType(widget, input); complete = TRUE; break; case CDK_REFRESH : eraseCDKScreen (ScreenOf(widget)); refreshCDKScreen (ScreenOf(widget)); break; default : if (widget->fieldEdit) { if (!performEdit(widget, input)) BEEP(); } else { /* * The cursor is not within the editable text. Interpret * input as commands. */ switch (input) { case 'd': case '-': return _injectCDKUScale(object, KEY_DOWN); case '+': return _injectCDKUScale(object, KEY_UP); case 'D': return _injectCDKUScale(object, KEY_NPAGE); case '0': return _injectCDKUScale(object, KEY_HOME); default: BEEP(); break; } } break; } } limitCurrentValue(widget); /* Should we call a post-process? */ if (!complete && (PostProcessFuncOf(widget) != 0)) { PostProcessFuncOf(widget) (vUSCALE, widget, PostProcessDataOf(widget), input); } } if (!complete) { drawCDKUScaleField (widget); setExitType(widget, 0); } ResultOf(widget).valueUnsigned = ret; return (ret != unknownUnsigned); }
int _mutt_enter_string(char *buf, size_t buflen, int y, int x, int flags, int multiple, char ***files, int *numfiles, struct enter_state *state) { int width = COLS - x - 1; int redraw; int pass =(flags & M_PASS); int first = 1; int ch, w, r; size_t i; wchar_t *tempbuf = 0; size_t templen = 0; history_class_t hclass; wchar_t wc; mbstate_t mbstate; int rv = 0; memset(&mbstate, 0, sizeof(mbstate)); if (state->wbuf) { /* Coming back after return 1 */ redraw = M_REDRAW_LINE; first = 0; } else { /* Initialise wbuf from buf */ state->wbuflen = 0; state->lastchar = my_mbstowcs(&state->wbuf, &state->wbuflen, 0, buf); redraw = M_REDRAW_INIT; } if (flags & M_FILE) hclass = HC_FILE; else if (flags & M_EFILE) hclass = HC_MBOX; else if (flags & M_CMD) hclass = HC_CMD; else if (flags & M_ALIAS) hclass = HC_ALIAS; else if (flags & M_COMMAND) hclass = HC_COMMAND; else if (flags & M_PATTERN) hclass = HC_PATTERN; else hclass = HC_OTHER; for(;;) { if (redraw && !pass) { if (redraw == M_REDRAW_INIT) { /* Go to end of line */ state->curpos = state->lastchar; state->begin = width_ceiling(state->wbuf, state->lastchar, my_wcswidth(state->wbuf, state->lastchar) - width + 1); } if (state->curpos < state->begin || my_wcswidth(state->wbuf + state->begin, state->curpos - state->begin) >= width) state->begin = width_ceiling(state->wbuf, state->lastchar, my_wcswidth(state->wbuf, state->curpos) - width / 2); move(y, x); w = 0; for(i = state->begin; i < state->lastchar; i++) { w += my_wcwidth(state->wbuf[i]); if (w > width) break; my_addwch(state->wbuf[i]); } clrtoeol(); move(y, x + my_wcswidth(state->wbuf + state->begin, state->curpos - state->begin)); } mutt_refresh(); if ((ch = km_dokey(MENU_EDITOR)) == -1) { rv = -1; goto bye; } if (ch != OP_NULL) { first = 0; if (ch != OP_EDITOR_COMPLETE && ch != OP_EDITOR_COMPLETE_QUERY) state->tabs = 0; redraw = M_REDRAW_LINE; switch(ch) { case OP_EDITOR_HISTORY_UP: state->curpos = state->lastchar; if (mutt_history_at_scratch(hclass)) { my_wcstombs(buf, buflen, state->wbuf, state->curpos); mutt_history_save_scratch(hclass, buf); } replace_part(state, 0, mutt_history_prev(hclass)); redraw = M_REDRAW_INIT; break; case OP_EDITOR_HISTORY_DOWN: state->curpos = state->lastchar; if (mutt_history_at_scratch(hclass)) { my_wcstombs(buf, buflen, state->wbuf, state->curpos); mutt_history_save_scratch(hclass, buf); } replace_part(state, 0, mutt_history_next(hclass)); redraw = M_REDRAW_INIT; break; case OP_EDITOR_BACKSPACE: if (state->curpos == 0) BEEP(); else { i = state->curpos; while(i && COMB_CHAR(state->wbuf[i - 1])) --i; if (i) --i; memmove(state->wbuf + i, state->wbuf + state->curpos,(state->lastchar - state->curpos) * sizeof(wchar_t)); state->lastchar -= state->curpos - i; state->curpos = i; } break; case OP_EDITOR_BOL: state->curpos = 0; break; case OP_EDITOR_EOL: redraw= M_REDRAW_INIT; break; case OP_EDITOR_KILL_LINE: state->curpos = state->lastchar = 0; break; case OP_EDITOR_KILL_EOL: state->lastchar = state->curpos; break; case OP_EDITOR_BACKWARD_CHAR: if (state->curpos == 0) BEEP(); else { while(state->curpos && COMB_CHAR(state->wbuf[state->curpos - 1])) state->curpos--; if (state->curpos) state->curpos--; } break; case OP_EDITOR_FORWARD_CHAR: if (state->curpos == state->lastchar) BEEP(); else { ++state->curpos; while(state->curpos < state->lastchar && COMB_CHAR(state->wbuf[state->curpos])) ++state->curpos; } break; case OP_EDITOR_BACKWARD_WORD: if (state->curpos == 0) BEEP(); else { while(state->curpos && iswspace(state->wbuf[state->curpos - 1])) --state->curpos; while(state->curpos && !iswspace(state->wbuf[state->curpos - 1])) --state->curpos; } break; case OP_EDITOR_FORWARD_WORD: if (state->curpos == state->lastchar) BEEP(); else { while(state->curpos < state->lastchar && iswspace(state->wbuf[state->curpos])) ++state->curpos; while(state->curpos < state->lastchar && !iswspace(state->wbuf[state->curpos])) ++state->curpos; } break; case OP_EDITOR_CAPITALIZE_WORD: case OP_EDITOR_UPCASE_WORD: case OP_EDITOR_DOWNCASE_WORD: if (state->curpos == state->lastchar) { BEEP(); break; } while(state->curpos && !iswspace(state->wbuf[state->curpos])) --state->curpos; while(state->curpos < state->lastchar && iswspace(state->wbuf[state->curpos])) ++state->curpos; while(state->curpos < state->lastchar && !iswspace(state->wbuf[state->curpos])) { if (ch == OP_EDITOR_DOWNCASE_WORD) state->wbuf[state->curpos] = towlower(state->wbuf[state->curpos]); else { state->wbuf[state->curpos] = towupper(state->wbuf[state->curpos]); if (ch == OP_EDITOR_CAPITALIZE_WORD) ch = OP_EDITOR_DOWNCASE_WORD; } state->curpos++; } break; case OP_EDITOR_DELETE_CHAR: if (state->curpos == state->lastchar) BEEP(); else { i = state->curpos; while(i < state->lastchar && COMB_CHAR(state->wbuf[i])) ++i; if (i < state->lastchar) ++i; while(i < state->lastchar && COMB_CHAR(state->wbuf[i])) ++i; memmove(state->wbuf + state->curpos, state->wbuf + i,(state->lastchar - i) * sizeof(wchar_t)); state->lastchar -= i - state->curpos; } break; case OP_EDITOR_KILL_WORD: /* delete to beginning of word */ if (state->curpos != 0) { i = state->curpos; while(i && iswspace(state->wbuf[i - 1])) --i; if (i) { if (iswalnum(state->wbuf[i - 1])) { for(--i; i && iswalnum(state->wbuf[i - 1]); i--) ; } else --i; } memmove(state->wbuf + i, state->wbuf + state->curpos, (state->lastchar - state->curpos) * sizeof(wchar_t)); state->lastchar += i - state->curpos; state->curpos = i; } break; case OP_EDITOR_KILL_EOW: /* delete to end of word */ /* first skip over whitespace */ for(i = state->curpos; i < state->lastchar && iswspace(state->wbuf[i]); i++) ; /* if there are any characters left.. */ if (i < state->lastchar) { /* if the current character is alphanumeric.. */ if (iswalnum(state->wbuf[i])) { /* skip over the rest of the word consistent of only alphanumerics */ for(; i < state->lastchar && iswalnum(state->wbuf[i]); i++) ; } else { /* skip over one non-alphanumeric character */ ++i; } } memmove(state->wbuf + state->curpos, state->wbuf + i, (state->lastchar - i) * sizeof(wchar_t)); state->lastchar += state->curpos - i; break; case OP_EDITOR_BUFFY_CYCLE: if (flags & M_EFILE) { first = 1; /* clear input if user types a real key later */ my_wcstombs(buf, buflen, state->wbuf, state->curpos); mutt_buffy(buf, buflen); state->curpos = state->lastchar = my_mbstowcs(&state->wbuf, &state->wbuflen, 0, buf); break; } else if (!(flags & M_FILE)) goto self_insert; /* fall through to completion routine(M_FILE) */ case OP_EDITOR_COMPLETE: case OP_EDITOR_COMPLETE_QUERY: state->tabs++; if (flags & M_CMD) { for(i = state->curpos; i && !is_shell_char(state->wbuf[i-1]); i--) ; my_wcstombs(buf, buflen, state->wbuf + i, state->curpos - i); if (tempbuf && templen == state->lastchar - i && !memcmp(tempbuf, state->wbuf + i,(state->lastchar - i) * sizeof(wchar_t))) { mutt_select_file(buf, buflen,(flags & M_EFILE) ? M_SEL_FOLDER : 0); set_bit(options, OPTNEEDREDRAW); if (*buf) replace_part(state, i, buf); rv = 1; goto bye; } if (!mutt_complete(buf, buflen)) { templen = state->lastchar - i; safe_realloc(&tempbuf, templen * sizeof(wchar_t)); } else BEEP(); replace_part(state, i, buf); } else if (flags & M_ALIAS && ch == OP_EDITOR_COMPLETE) { /* invoke the alias-menu to get more addresses */ for(i = state->curpos; i && state->wbuf[i-1] != ',' && state->wbuf[i-1] != ':'; i--) ; for(; i < state->lastchar && state->wbuf[i] == ' '; i++) ; my_wcstombs(buf, buflen, state->wbuf + i, state->curpos - i); r = mutt_alias_complete(buf, buflen); replace_part(state, i, buf); if (!r) { rv = 1; goto bye; } break; } else if (flags & M_ALIAS && ch == OP_EDITOR_COMPLETE_QUERY) { /* invoke the query-menu to get more addresses */ if ((i = state->curpos)) { for(; i && state->wbuf[i - 1] != ','; i--) ; for(; i < state->curpos && state->wbuf[i] == ' '; i++) ; } my_wcstombs(buf, buflen, state->wbuf + i, state->curpos - i); mutt_query_complete(buf, buflen); replace_part(state, i, buf); rv = 1; goto bye; } else if (flags & M_COMMAND) { my_wcstombs(buf, buflen, state->wbuf, state->curpos); i = strlen(buf); if (i && buf[i - 1] == '=' && mutt_var_value_complete(buf, buflen, i)) state->tabs = 0; else if (!mutt_command_complete(buf, buflen, i, state->tabs)) BEEP(); replace_part(state, 0, buf); } else if (flags &(M_FILE | M_EFILE)) { my_wcstombs(buf, buflen, state->wbuf, state->curpos); /* see if the path has changed from the last time */ if ((!tempbuf && !state->lastchar) ||(tempbuf && templen == state->lastchar && !memcmp(tempbuf, state->wbuf, state->lastchar * sizeof(wchar_t)))) { _mutt_select_file(buf, buflen, ((flags & M_EFILE) ? M_SEL_FOLDER : 0) |(multiple ? M_SEL_MULTI : 0), files, numfiles); set_bit(options, OPTNEEDREDRAW); if (*buf) { mutt_pretty_mailbox(buf, buflen); if (!pass) mutt_history_add(hclass, buf, 1); rv = 0; goto bye; } /* file selection cancelled */ rv = 1; goto bye; } if (!mutt_complete(buf, buflen)) { templen = state->lastchar; safe_realloc(&tempbuf, templen * sizeof(wchar_t)); memcpy(tempbuf, state->wbuf, templen * sizeof(wchar_t)); } else BEEP(); /* let the user know that nothing matched */ replace_part(state, 0, buf); } else goto self_insert; break; case OP_EDITOR_QUOTE_CHAR: { struct event event; /*ADDCH(LastKey);*/ event = mutt_getch(); if (event.ch >= 0) { LastKey = event.ch; goto self_insert; } } case OP_EDITOR_TRANSPOSE_CHARS: if (state->lastchar < 2) BEEP(); else { wchar_t t; if (state->curpos == 0) state->curpos = 2; else if (state->curpos < state->lastchar) ++state->curpos; t = state->wbuf[state->curpos - 2]; state->wbuf[state->curpos - 2] = state->wbuf[state->curpos - 1]; state->wbuf[state->curpos - 1] = t; } break; default: BEEP(); } } else { self_insert: state->tabs = 0; /* use the raw keypress */ ch = LastKey; #if KEY_ENTER /* treat ENTER the same as RETURN */ if (ch == KEY_ENTER) ch = '\r'; #endif /* quietly ignore all other function keys */ if (ch & ~0xff) continue; /* gather the octets into a wide character */ { char c; size_t k; c = ch; k = mbrtowc(&wc, &c, 1, &mbstate); if (k ==(size_t)(-2)) continue; else if (k && k != 1) { memset(&mbstate, 0, sizeof(mbstate)); continue; } } if (first &&(flags & M_CLEAR)) { first = 0; if (IsWPrint(wc)) /* why? */ state->curpos = state->lastchar = 0; } if (wc == '\r' || wc == '\n') { /* Convert from wide characters */ my_wcstombs(buf, buflen, state->wbuf, state->lastchar); if (!pass) mutt_history_add(hclass, buf, 1); if (multiple) { char **tfiles; *numfiles = 1; tfiles = safe_calloc(*numfiles, sizeof(char *)); mutt_expand_path(buf, buflen); tfiles[0] = safe_strdup(buf); *files = tfiles; } rv = 0; goto bye; } else if (wc &&(wc < ' ' || IsWPrint(wc))) /* why? */ { if (state->lastchar >= state->wbuflen) { state->wbuflen = state->lastchar + 20; safe_realloc(&state->wbuf, state->wbuflen * sizeof(wchar_t)); } memmove(state->wbuf + state->curpos + 1, state->wbuf + state->curpos,(state->lastchar - state->curpos) * sizeof(wchar_t)); state->wbuf[state->curpos++] = wc; state->lastchar++; } else { mutt_flushinp(); BEEP(); } } } bye: mutt_reset_history_state(hclass); safe_free(&tempbuf); return rv; }
void zorba_state::zorba(machine_config &config) { // basic machine hardware Z80(config, m_maincpu, 24_MHz_XTAL / 6); m_maincpu->set_addrmap(AS_PROGRAM, &zorba_state::zorba_mem); m_maincpu->set_addrmap(AS_IO, &zorba_state::zorba_io); /* video hardware */ screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER)); screen.set_color(rgb_t::green()); screen.set_refresh_hz(50); screen.set_screen_update("crtc", FUNC(i8275_device::screen_update)); GFXDECODE(config, "gfxdecode", m_palette, gfx_zorba); PALETTE(config, m_palette, palette_device::MONOCHROME_HIGHLIGHT); /* sound hardware */ SPEAKER(config, "mono").front_center(); BEEP(config, m_beep, 800).add_route(ALL_OUTPUTS, "mono", 1.00); // should be horizontal frequency / 16, so depends on CRTC parameters INPUT_MERGER_ANY_HIGH(config, "irq0").output_handler().set(FUNC(zorba_state::irq_w<0>)); INPUT_MERGER_ANY_HIGH(config, "irq1").output_handler().set(FUNC(zorba_state::irq_w<1>)); INPUT_MERGER_ANY_HIGH(config, "irq2").output_handler().set(FUNC(zorba_state::irq_w<2>)); /* devices */ Z80DMA(config, m_dma, 24_MHz_XTAL / 6); // busack on cpu connects to bai pin m_dma->out_busreq_callback().set(FUNC(zorba_state::busreq_w)); //connects to busreq on cpu m_dma->out_int_callback().set("irq0", FUNC(input_merger_device::in_w<0>)); //ba0 - not connected m_dma->in_mreq_callback().set(FUNC(zorba_state::memory_read_byte)); m_dma->out_mreq_callback().set(FUNC(zorba_state::memory_write_byte)); m_dma->in_iorq_callback().set(FUNC(zorba_state::io_read_byte)); m_dma->out_iorq_callback().set(FUNC(zorba_state::io_write_byte)); I8251(config, m_uart0, 0); // U32 COM port J2 m_uart0->txd_handler().set("rs232", FUNC(rs232_port_device::write_txd)); // TODO: this line has a LED attached m_uart0->dtr_handler().set("rs232", FUNC(rs232_port_device::write_dtr)); m_uart0->rts_handler().set("rs232", FUNC(rs232_port_device::write_rts)); m_uart0->rxrdy_handler().set(FUNC(zorba_state::tx_rx_rdy_w<1>)); m_uart0->txrdy_handler().set(FUNC(zorba_state::tx_rx_rdy_w<0>)); I8251(config, m_uart1, 0); // U31 printer port J3 m_uart1->txd_handler().set("serprn", FUNC(rs232_port_device::write_txd)); m_uart1->rts_handler().set("serprn", FUNC(rs232_port_device::write_rts)); m_uart1->rxrdy_handler().set(FUNC(zorba_state::tx_rx_rdy_w<3>)); m_uart1->txrdy_handler().set(FUNC(zorba_state::tx_rx_rdy_w<2>)); I8251(config, m_uart2, 0); // U30 serial keyboard J6 m_uart2->txd_handler().set("keyboard", FUNC(zorba_keyboard_device::txd_w)); m_uart2->rxrdy_handler().set(FUNC(zorba_state::tx_rx_rdy_w<5>)); m_uart2->txrdy_handler().set(FUNC(zorba_state::tx_rx_rdy_w<4>)); // port A - disk select etc, beeper // port B - parallel interface PIA6821(config, m_pia0, 0); m_pia0->writepa_handler().set(FUNC(zorba_state::pia0_porta_w)); m_pia0->writepb_handler().set("parprndata", FUNC(output_latch_device::bus_w)); m_pia0->cb2_handler().set("parprn", FUNC(centronics_device::write_strobe)); // IEEE488 interface PIA6821(config, m_pia1, 0); m_pia1->readpa_handler().set(m_ieee, FUNC(ieee488_device::dio_r)); // TODO: gated with PB1 m_pia1->writepa_handler().set(m_ieee, FUNC(ieee488_device::host_dio_w)); // TODO: gated with PB1 m_pia1->readpb_handler().set(FUNC(zorba_state::pia1_portb_r)); m_pia1->writepb_handler().set(FUNC(zorba_state::pia1_portb_w)); m_pia1->ca2_handler().set(m_ieee, FUNC(ieee488_device::host_ifc_w)); m_pia1->cb2_handler().set(m_ieee, FUNC(ieee488_device::host_ren_w)); m_pia1->irqa_handler().set("irq1", FUNC(input_merger_device::in_w<0>)); m_pia1->irqb_handler().set("irq1", FUNC(input_merger_device::in_w<1>)); // PIT pit8254_device &pit(PIT8254(config, "pit", 0)); pit.set_clk<0>(24_MHz_XTAL / 3); pit.set_clk<1>(24_MHz_XTAL / 3); pit.set_clk<2>(24_MHz_XTAL / 3); pit.out_handler<0>().set(FUNC(zorba_state::br1_w)); pit.out_handler<1>().set(m_uart1, FUNC(i8251_device::write_txc)); pit.out_handler<1>().append(m_uart1, FUNC(i8251_device::write_rxc)); pit.out_handler<2>().set(m_uart2, FUNC(i8251_device::write_txc)); pit.out_handler<2>().append(m_uart2, FUNC(i8251_device::write_rxc)); // CRTC I8275(config, m_crtc, 14.318'181_MHz_XTAL / 7); m_crtc->set_character_width(8); m_crtc->set_display_callback(FUNC(zorba_state::zorba_update_chr), this); m_crtc->drq_wr_callback().set(m_dma, FUNC(z80dma_device::rdy_w)); m_crtc->irq_wr_callback().set("irq0", FUNC(input_merger_device::in_w<1>)); m_crtc->set_screen("screen"); // Floppies FD1793(config, m_fdc, 24_MHz_XTAL / 24); m_fdc->intrq_wr_callback().set("irq2", FUNC(input_merger_device::in_w<0>)); m_fdc->drq_wr_callback().set("irq2", FUNC(input_merger_device::in_w<1>)); FLOPPY_CONNECTOR(config, m_floppy0, zorba_floppies, "525dd", floppy_image_device::default_floppy_formats).enable_sound(true); FLOPPY_CONNECTOR(config, m_floppy1, zorba_floppies, "525dd", floppy_image_device::default_floppy_formats).enable_sound(true); // J1 IEEE-488 IEEE488(config, m_ieee); m_ieee->srq_callback().set(m_pia1, FUNC(pia6821_device::ca2_w)); // TODO: gated with PB1 from PIA // J2 EIA RS232/internal modem // TODO: this has additional lines compared to a regular RS232 port (TxC in, RxC in, RxC out, speaker in, power) rs232_port_device &rs232(RS232_PORT(config, "rs232", default_rs232_devices, nullptr)); rs232.rxd_handler().set(m_uart0, FUNC(i8251_device::write_rxd)); // TODO: this line has a LED attached rs232.cts_handler().set(m_uart0, FUNC(i8251_device::write_cts)); // TODO: this line has a LED attached rs232.dsr_handler().set(m_uart0, FUNC(i8251_device::write_dsr)); // J3 Parallel printer centronics_device &parprn(CENTRONICS(config, "parprn", centronics_devices, "printer")); parprn.busy_handler().set(m_uart1, FUNC(i8251_device::write_cts)); parprn.busy_handler().append(m_uart1, FUNC(i8251_device::write_dsr)); // TODO: shared with serial CTS parprn.fault_handler().set(FUNC(zorba_state::printer_fault_w)); parprn.select_handler().set(FUNC(zorba_state::printer_select_w)); output_latch_device &parprndata(OUTPUT_LATCH(config, "parprndata")); parprn.set_output_latch(parprndata); // J3 Serial printer rs232_port_device &serprn(RS232_PORT(config, "serprn", default_rs232_devices, nullptr)); serprn.rxd_handler().set(m_uart1, FUNC(i8251_device::write_rxd)); // TODO: this line has a LED attached // J6 TTL-level serial keyboard ZORBA_KEYBOARD(config, "keyboard").rxd_cb().set(m_uart2, FUNC(i8251_device::write_rxd)); SOFTWARE_LIST(config, "flop_list").set_original("zorba"); }
void by133_state::babypac(machine_config &config) { /* basic machine hardware */ M6800(config, m_maincpu, XTAL(3'579'545)/4); // no xtal, just 2 chips m_maincpu->set_addrmap(AS_PROGRAM, &by133_state::main_map); MC6809(config, m_videocpu, XTAL(3'579'545)); m_videocpu->set_addrmap(AS_PROGRAM, &by133_state::video_map); M6803(config, m_audiocpu, XTAL(3'579'545)); m_audiocpu->set_addrmap(AS_PROGRAM, &by133_state::sound_map); m_audiocpu->out_p1_cb().set("dac", FUNC(dac_byte_interface::data_w)); // P10-P17 m_audiocpu->in_p2_cb().set(FUNC(by133_state::m6803_port2_r)); // P20-P24 sound command in m_audiocpu->out_p2_cb().set(FUNC(by133_state::m6803_port2_w)); NVRAM(config, "nvram", nvram_device::DEFAULT_ALL_0); PIA6821(config, m_pia_u7, 0); m_pia_u7->readpa_handler().set(FUNC(by133_state::u7_a_r)); m_pia_u7->writepa_handler().set(FUNC(by133_state::u7_a_w)); m_pia_u7->readpb_handler().set(FUNC(by133_state::u7_b_r)); m_pia_u7->writepb_handler().set(FUNC(by133_state::u7_b_w)); m_pia_u7->ca2_handler().set(FUNC(by133_state::u7_ca2_w)); m_pia_u7->cb2_handler().set(FUNC(by133_state::u7_cb2_w)); m_pia_u7->irqa_handler().set_inputline("videocpu", M6809_FIRQ_LINE); m_pia_u7->irqa_handler().set_inputline("videocpu", M6809_FIRQ_LINE); PIA6821(config, m_pia_u10, 0); m_pia_u10->readpa_handler().set(FUNC(by133_state::u10_a_r)); m_pia_u10->writepa_handler().set(FUNC(by133_state::u10_a_w)); m_pia_u10->readpb_handler().set(FUNC(by133_state::u10_b_r)); m_pia_u10->writepb_handler().set(FUNC(by133_state::u10_b_w)); m_pia_u10->ca2_handler().set(FUNC(by133_state::u10_ca2_w)); m_pia_u10->cb2_handler().set(FUNC(by133_state::u10_cb2_w)); m_pia_u10->irqa_handler().set_inputline("maincpu", M6800_IRQ_LINE); m_pia_u10->irqb_handler().set_inputline("maincpu", M6800_IRQ_LINE); TIMER(config, "babypac1").configure_periodic(FUNC(by133_state::u10_timer), attotime::from_hz(120)); // mains freq*2 PIA6821(config, m_pia_u11, 0); m_pia_u11->readpa_handler().set(FUNC(by133_state::u11_a_r)); m_pia_u11->writepa_handler().set(FUNC(by133_state::u11_a_w)); m_pia_u11->readpb_handler().set(FUNC(by133_state::u11_b_r)); m_pia_u11->writepb_handler().set(FUNC(by133_state::u11_b_w)); m_pia_u11->ca2_handler().set(FUNC(by133_state::u11_ca2_w)); m_pia_u11->cb2_handler().set(FUNC(by133_state::u11_cb2_w)); m_pia_u11->irqa_handler().set_inputline("maincpu", M6800_IRQ_LINE); m_pia_u11->irqb_handler().set_inputline("maincpu", M6800_IRQ_LINE); TIMER(config, "babypac2").configure_periodic(FUNC(by133_state::u11_timer), attotime::from_hz(634)); // 555 timer*2 /* video hardware */ TMS9928A(config, m_crtc, XTAL(10'738'635)).set_screen("screen"); m_crtc->set_vram_size(0x4000); m_crtc->int_callback().set_inputline(m_videocpu, M6809_IRQ_LINE); SCREEN(config, "screen", SCREEN_TYPE_RASTER); /* sound hardware */ SPEAKER(config, "speaker").front_center(); ZN429E(config, "dac", 0).add_route(ALL_OUTPUTS, "speaker", 0.25); // U32 (Vidiot) or U6 (Cheap Squeak) voltage_regulator_device &vref(VOLTAGE_REGULATOR(config, "vref")); vref.add_route(0, "dac", 1.0, DAC_VREF_POS_INPUT); vref.add_route(0, "dac", -1.0, DAC_VREF_NEG_INPUT); SPEAKER(config, "beee").front_center(); BEEP(config, m_beep, 600).add_route(ALL_OUTPUTS, "beee", 0.10); }
int main() { char str[128]; char compiler[128]; char fpath[MAX_PATH+1]; char* path = "."; char* glob_pattern = "*wrap*"; int i; int ch; uint u; time_t t; glob_t g; DIR* dir; DIRENT* dirent; thread_data_t thread_data; int fd; int fd2; int canrelock=0; clock_t ticks; /* Show platform details */ DESCRIBE_COMPILER(compiler); printf("%-15s: %s\n","Platform",PLATFORM_DESC); printf("%-15s: %s\n","Version",os_version(str)); printf("%-15s: %s\n","Compiler" ,compiler); printf("%-15s: %d\n","Random Number",xp_random(1000)); for(i=0;i<3;i++) { if(_beginthread( sopen_child_thread /* entry point */ ,0 /* stack size (0=auto) */ ,(void*)i /* data */ )==(unsigned long)-1) printf("_beginthread failed\n"); else SLEEP(1); } printf("Waiting for all sopen_child_threads to close...\n"); SLEEP(5000); /* wait for all threads to quit */ /* Exclusive sopen test */ printf("\nsopen() test\n"); if((fd=sopen(LOCK_FNAME,O_RDWR|O_CREAT,SH_DENYRW,S_IREAD|S_IWRITE))==-1) { perror(LOCK_FNAME); return(errno); } printf("%s is opened with an exclusive (read/write) lock\n",LOCK_FNAME); getkey(); if(_beginthread( sopen_test_thread /* entry point */ ,0 /* stack size (0=auto) */ ,NULL /* data */ )==(unsigned long)-1) printf("_beginthread failed\n"); else SLEEP(1000); close(fd); /* sopen()/lock test */ printf("\nlock() test\n"); if((fd=sopen(LOCK_FNAME,O_RDWR|O_CREAT,SH_DENYNO,S_IREAD|S_IWRITE))==-1) { perror(LOCK_FNAME); return(errno); } write(fd,"lock testing\n",LOCK_LEN); if(lock(fd,LOCK_OFFSET,LOCK_LEN)==0) printf("lock() succeeds\n"); else printf("!FAILURE: lock() non-functional (or file already locked)\n"); if(lock(fd,LOCK_OFFSET,LOCK_LEN)==0) { printf("!FAILURE: Subsequent lock of region was allowed (will skip some tests)\n"); canrelock=1; } if(_beginthread( lock_test_thread /* entry point */ ,0 /* stack size (0=auto) */ ,NULL /* data */ )==(unsigned long)-1) printf("_beginthread failed\n"); else SLEEP(1000); if(canrelock) printf("?? Skipping some tests due to inability to detect own locks\n"); else { if(lock(fd,LOCK_OFFSET,LOCK_LEN)) printf("Locks in first thread survive open()/close() in other thread\n"); else printf("!FAILURE: lock() in first thread lost by open()/close() in other thread\n"); if(lock(fd,LOCK_OFFSET+LOCK_LEN+1,LOCK_LEN)) printf("!FAILURE: file locking\n"); else printf("Record locking\n"); } if((fd2=sopen(LOCK_FNAME,O_RDWR,SH_DENYRW))==-1) { printf("Cannot reopen SH_DENYRW while lock is held\n"); close(fd2); } else { printf("!FAILURE: can reopen SH_DENYRW while lock is held\n"); } if(unlock(fd,LOCK_OFFSET,LOCK_LEN)) printf("!FAILURE: unlock() non-functional\n"); if(lock(fd,LOCK_OFFSET+LOCK_LEN+1,LOCK_LEN)) printf("Cannot re-lock after non-overlapping unlock()\n"); else printf("!FAILURE: can re-lock after non-overlappping unlock()\n"); if(lock(fd,LOCK_OFFSET,LOCK_LEN)) printf("!FAILURE: cannot re-lock unlocked area\n"); close(fd); /* getch test */ printf("\ngetch() test (ESC to continue)\n"); do { ch=getch(); printf("getch() returned %d\n",ch); } while(ch!=ESC); /* kbhit test */ printf("\nkbhit() test (any key to continue)\n"); while(!kbhit()) { printf("."); fflush(stdout); SLEEP(500); } getch(); /* remove character from keyboard buffer */ /* BEEP test */ printf("\nBEEP() test\n"); getkey(); for(i=750;i>250;i-=5) BEEP(i,15); for(;i<1000;i+=5) BEEP(i,15); /* SLEEP test */ printf("\nSLEEP(5 second) test\n"); getkey(); t=time(NULL); printf("sleeping... "); fflush(stdout); ticks=msclock(); SLEEP(5000); printf("slept %ld seconds (%ld according to msclock)\n",time(NULL)-t,(msclock()-ticks)/MSCLOCKS_PER_SEC); /* Thread SLEEP test */ printf("\nThread SLEEP(5 second) test\n"); getkey(); i=0; if(_beginthread( sleep_test_thread /* entry point */ ,0 /* stack size (0=auto) */ ,&i /* data */ )==(unsigned long)-1) printf("_beginthread failed\n"); else { SLEEP(1); /* yield to child thread */ while(i==0) { printf("."); fflush(stdout); SLEEP(1000); } } /* glob test */ printf("\nglob(%s) test\n",glob_pattern); getkey(); i=glob(glob_pattern,GLOB_MARK,NULL,&g); if(i==0) { for(u=0;u<g.gl_pathc;u++) printf("%s\n",g.gl_pathv[u]); globfree(&g); } else printf("glob(%s) returned %d\n",glob_pattern,i); /* opendir (and other directory functions) test */ printf("\nopendir(%s) test\n",path); getkey(); printf("\nDirectory of %s\n\n",FULLPATH(fpath,path,sizeof(fpath))); dir=opendir(path); while(dir!=NULL && (dirent=readdir(dir))!=NULL) { t=fdate(dirent->d_name); printf("%.24s %10lu %06o %s%c\n" ,ctime(&t) ,flength(dirent->d_name) ,getfattr(dirent->d_name) ,dirent->d_name ,isdir(dirent->d_name) ? '/':0 ); } if(dir!=NULL) closedir(dir); printf("\nFree disk space: %lu kbytes\n",getfreediskspace(path,1024)); /* Thread (and inter-process communication) test */ printf("\nSemaphore test\n"); getkey(); if(sem_init(&thread_data.parent_sem ,0 /* shared between processes */ ,0 /* initial count */ )) { printf("sem_init failed\n"); } if(sem_init(&thread_data.child_sem ,0 /* shared between processes */ ,0 /* initial count */ )) { printf("sem_init failed\n"); } if(_beginthread( sem_test_thread /* entry point */ ,0 /* stack size (0=auto) */ ,&thread_data /* data */ )==(unsigned long)-1) printf("_beginthread failed\n"); else { sem_wait(&thread_data.child_sem); /* wait for thread to begin */ for(i=0;i<10;i++) { printf("<parent>"); sem_post(&thread_data.parent_sem); sem_wait(&thread_data.child_sem); } sem_wait(&thread_data.child_sem); /* wait for thread to end */ } sem_destroy(&thread_data.parent_sem); sem_destroy(&thread_data.child_sem); printf("\nSemaphore blocking test\n"); getkey(); sem_init(&thread_data.parent_sem ,0 /* shared between processes */ ,0 /* initial count */ ); sem_init(&thread_data.child_sem ,0 /* shared between processes */ ,0 /* initial count */ ); if(_beginthread( sem_test_thread_block /* entry point */ ,0 /* stack size (0=auto) */ ,&thread_data /* data */ )==(unsigned long)-1) printf("_beginthread failed\n"); else { sem_wait(&thread_data.child_sem); /* wait for thread to begin */ for(i=0;i<10;i++) { printf("<parent>"); SLEEP(5000); sem_post(&thread_data.parent_sem); sem_wait(&thread_data.child_sem); } sem_wait(&thread_data.child_sem); /* wait for thread to end */ } printf("\nsem_trywait_block test..."); t=time(NULL); sem_trywait_block(&thread_data.parent_sem,5000); printf("\ntimed-out after %ld seconds (should be 5 seconds)\n",time(NULL)-t); sem_destroy(&thread_data.parent_sem); sem_destroy(&thread_data.child_sem); printf("\nendian check..."); memcpy(&i,"\x01\x02\x03\x04",4); if(LE_LONG(i)==67305985) { printf("OK!\n"); } else { printf("FAILED!\n"); } return 0; }