//add an output port, if we are active then deactivate and reactivate after //maybe we can do this more intelligently in the future? unsigned int JackCpp::AudioIO::addOutPort(std::string name) throw(std::runtime_error) { if (mJackState == active && mOutputPorts.size() == mOutputPorts.capacity()) throw std::runtime_error("trying to add output ports while the client is running and there are not reserved ports"); if(portExists(name)){ std::string ret_string("cannot register new outport: "); ret_string.append(name); ret_string.append(" port already exists with that name"); throw std::runtime_error(ret_string); } //allocate the item in the vector jack_port_t * newPort = jack_port_register (mJackClient, name.c_str(), JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0); if(newPort == NULL){ std::string ret_string("cannot register new outport: "); ret_string.append(name); throw std::runtime_error(ret_string); } mOutputPorts.push_back(newPort); mPortNames.push_back(name); //if we're active then send a command indicating this change if (mJackState == active) { //loop while there isn't space to write while(mCmdBuffer.getWriteSpace() == 0); mCmdBuffer.write(add_out_port); } else mJackOutBuf.push_back(NULL); return mOutputPorts.size() - 1; }
std::string NetworkDevice::getInterfaceList() { std::string ret_string("Usable interface list: \n"); pcap_if_t *alldevsp; /* list of interfaces */ pcap_if_t *alldev; char errbuf[PCAP_ERRBUF_SIZE]={0}; /* pcap error messages buffer */ if (pcap_findalldevs (&alldevsp, errbuf) < 0) { fprintf (stderr, "%s", errbuf); exit (1); } alldev=alldevsp; while (alldevsp != NULL) { ret_string+=alldevsp->name; ret_string+="\n"; alldevsp = alldevsp->next; } pcap_freealldevs(alldev); return ret_string; }
STDMETHODIMP CDisk::get_compdesc(BSTR *pVal) { const char *name = dsk_compdesc(m_driver); if (!name) name = ""; *pVal = ret_string(name); return S_OK; }
static LISP x_get_cell(LISP row, LISP col, LISP bname) { int r, c; char *p; buffer *buf; int s; r = get_c_long(row); c = get_c_long(col); if (r < 1 || r > BUFFER_ROWS || c < 1 || c > BUFFER_COLS) return NIL; if (NULLP(bname)) { buf = siag_buffer; s = siag_sht; } else if (TYPEP(bname, tc_string)) { buf = find_sheet_by_name(bname->storage_as.string.data, siag_buffer, &s); if (buf == NULL) return NIL; } else return NIL; switch (ret_type(buf, s, r, c)) { case STRING: p = ret_string(buf, s, r, c); return strcons(strlen(p), p); case LABEL: p = ret_text(buf, s, r, c); return strcons(strlen(p), p); case EMPTY: case ERROR: return NIL; default: return flocons(ret_val(buf, s, r, c).number); } }
STDMETHODIMP CDisk::get_comment(BSTR *pVal) { char *cmt = NULL; dsk_err_t err = dsk_get_comment(m_driver, &cmt); if (cmt) *pVal = ret_string(cmt); return MapError(err); }
STDMETHODIMP CDisk::option_enum(long idx, BSTR *name, BOOL *valid) { dsk_err_t err; char *opt; err = dsk_option_enum(m_driver, idx, &opt); switch(err) { case DSK_ERR_OK: *valid = true; *name = ret_string(opt); break; case DSK_ERR_BADOPT: *valid = false; break; default: return MapError(err); } return S_OK; }
STDMETHODIMP CLibrary::comp_enum(long idx, BSTR *name, BOOL *valid) { dsk_err_t err; char *opt; err = dsk_comp_enum(idx, &opt); switch(err) { case DSK_ERR_OK: *valid = true; *name = ret_string(opt); break; case DSK_ERR_NODRVR: *valid = false; break; default: return MapError(err); } return S_OK; }
/* the problem here is that we don't know the current buffer and current sheet. That information is static in siodi.c */ static double get_value(buffer *buf, int sheet, int row, int col) { if (row < 1 || row > BUFFER_ROWS || col < 1 || col > BUFFER_COLS) return 0.0; switch (ret_type(buf, sheet, row, col)) { case STRING: case LABEL: return strtod(ret_string(buf, sheet, row, col), NULL); case EMPTY: case ERROR: return 0.0; default: return ret_val(buf, sheet, row, col).number; } }
void JackCpp::AudioIO::connectFrom(unsigned int index, std::string sourcePortName) throw(std::range_error, std::runtime_error) { int connect_ret; if (mJackState != active) throw std::runtime_error("client must be active before connecting ports"); if(index < mInputPorts.size()){ connect_ret = jack_connect(mJackClient, sourcePortName.c_str(), jack_port_name(mInputPorts[index])); if(connect_ret != 0 && connect_ret != EEXIST){ std::string ret_string("cannot connect source: "); ret_string.append(sourcePortName); ret_string.append(" to dest: "); ret_string.append(jack_port_name(mInputPorts[index])); ret_string.append(" does source exist?"); throw std::range_error(ret_string); } } else throw std::range_error("inport index out of range"); }
static int intl_ctl(ErlDrvData drv_data, unsigned int command, char *buf, int len, char **rbuf, int rlen) { void* d = (void*)drv_data; char* aptr = buf; int alen = len; char* str1; char* str2; char* str3; int int1; int int2; unsigned int uint1; switch(command) { case INTL_GETTEXT: /* arguments: string msgid */ if (get_string(&aptr, &alen, &str1) < 0) return ret_code(EINVAL, rbuf, rlen); return ret_string(gettext(str1), rbuf, rlen); case INTL_NGETTEXT: /* arguments: string msgid, string msgid_plural, int n */ if (get_string(&aptr, &alen, &str1) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_string(&aptr, &alen, &str2) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_uinteger(&aptr, &alen, &uint1) < 0) return ret_code(EINVAL, rbuf, rlen); return ret_string(ngettext(str1,str2,uint1), rbuf, rlen); case INTL_DGETTEXT: /* arguments: string domain, string msgid */ if (get_string(&aptr, &alen, &str1) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_string(&aptr, &alen, &str2) < 0) return ret_code(EINVAL, rbuf, rlen); return ret_string(dgettext(str1,str2), rbuf, rlen); case INTL_DNGETTEXT: /* arguments: string domain, string msgid, string msgid_plural, integer n */ if (get_string(&aptr, &alen, &str1) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_string(&aptr, &alen, &str2) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_string(&aptr, &alen, &str3) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_uinteger(&aptr, &alen, &uint1) < 0) return ret_code(EINVAL, rbuf, rlen); return ret_string(dngettext(str1,str2,str3,uint1), rbuf, rlen); case INTL_DCGETTEXT: /* arguments: string domain, string msgid, int category */ if (get_string(&aptr, &alen, &str1) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_string(&aptr, &alen, &str2) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_integer(&aptr,&alen, &int1) < 0) return ret_code(EINVAL, rbuf, rlen); if ((int1 = get_category(int1)) < 0) return ret_code(EINVAL, rbuf, rlen); return ret_string(dcgettext(str1,str2,int1),rbuf,rlen); case INTL_DCNGETTEXT: /* arguments: string domain, string msgid, strinf msgid_plural, unsigned n, int category */ if (get_string(&aptr, &alen, &str1) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_string(&aptr, &alen, &str2) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_string(&aptr, &alen, &str3) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_uinteger(&aptr,&alen, &uint1) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_integer(&aptr,&alen, &int1) < 0) return ret_code(EINVAL, rbuf, rlen); if ((int1 = get_category(int1)) < 0) return ret_code(EINVAL, rbuf, rlen); return ret_string(dcngettext(str1,str2,str3,uint1,int1),rbuf,rlen); case INTL_TEXTDOMAIN: /* arguments: string domainname */ if (len == 0) return ret_string(textdomain(NULL), rbuf, rlen); if (get_string(&aptr, &alen, &str1) < 0) return ret_code(EINVAL, rbuf, rlen); return ret_string(textdomain(str1), rbuf, rlen); case INTL_BINDTEXTDOMAIN: /* arguments: string domainname, string dirname */ if (len == 0) return ret_string(textdomain(NULL), rbuf, rlen); if (get_string(&aptr, &alen, &str1) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_string(&aptr, &alen, &str2) < 0) return ret_code(EINVAL, rbuf, rlen); return ret_string(bindtextdomain(str1,str2), rbuf, rlen); case INTL_BIND_TEXTDOMAIN_CODESET: /* arguments: string domainname, string dirname */ if (len == 0) return ret_string(textdomain(NULL), rbuf, rlen); if (get_string(&aptr, &alen, &str1) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_string(&aptr, &alen, &str2) < 0) return ret_code(EINVAL, rbuf, rlen); return ret_string(bind_textdomain_codeset(str1,str2), rbuf, rlen); case INTL_SETLOCALE: if (get_integer(&aptr,&alen, &int1) < 0) return ret_code(EINVAL, rbuf, rlen); if ((int1 = get_category(int1)) < 0) return ret_code(EINVAL, rbuf, rlen); if (get_string(&aptr, &alen, &str1) < 0) return ret_code(EINVAL, rbuf, rlen); return ret_string(setlocale(int1,str1), rbuf, rlen); } return -1; }
STDMETHODIMP CDisk::get_drvdesc(BSTR *pVal) { const char *name = dsk_drvdesc(m_driver); *pVal = ret_string(name); return S_OK; }
static int sl_output(int port, char *buf, int len) { int x,y,z,v,w; char *str, *t1, *t2, *t3; int ret; char ch; /* check for signals */ if (signal_cought != 0) { /* async out signal */ char xxx[5]; xxx[0] = 0; put_int32(signal_cought, xxx+1); driver_output(port, xxx, 5); signal_cought = 0; } switch (*buf++) { case INIT_TTY: { int abort_char, flow_ctl, opost; abort_char = get_int32(buf); buf+=4; flow_ctl = get_int32(buf); buf+= 4; opost = get_int32(buf); buf+= 4; ret = SLang_init_tty (abort_char,flow_ctl, opost); return ret_int(port, ret); } case SET_ABORT_FUNCTION: { SLang_set_abort_signal (NULL); return ret_int(port, 0); } case GETKEY: { unsigned int key; if (SLang_input_pending (0) == 0) { wait_for = GETKEY; driver_select(port, 0, DO_READ, 1); return 0; } x = SLang_getkey (); return ret_int(port, x); } /* read a symbol */ case KP_GETKEY: { if (SLang_input_pending (0) == 0) { wait_for = KP_GETKEY; driver_select(port, 0, DO_READ, 1); return 0; } x = SLkp_getkey (); return ret_int(port, x); } case UNGETKEY: { unsigned char key = (unsigned char) *buf; SLang_ungetkey (key); return 0; } case RESET_TTY: { SLang_reset_tty(); return 0; } case KP_INIT: { return ret_int(port, SLkp_init ()); } case SETVAR: { x = get_int32(buf);buf+= 4; y = get_int32(buf); switch (x) { case esl_baud_rate: SLang_TT_Baud_Rate = y; return 0; case esl_read_fd: return 0; case esl_abort_char: SLang_Abort_Char = y; return 0; case esl_ignore_user_abort: SLang_Ignore_User_Abort=y; return 0; case esl_input_buffer_len : SLang_Input_Buffer_Len=y; return 0; case esl_keyboard_quit: SLKeyBoard_Quit=y; return 0; case esl_last_key_char: SLang_Last_Key_Char=y; return 0; case esl_rl_eof_char: SLang_RL_EOF_Char=y; return 0; case esl_rline_quit: SLang_Rline_Quit=y; return 0; case esl_screen_rows: case esl_screen_cols : return 0; case esl_tab_width: SLsmg_Tab_Width=y; return 0; case esl_newline_behaviour: SLsmg_Newline_Behavior=y; return 0; case esl_error: SLang_Error=y; return 0; case esl_version: return 0; case esl_backspace_moves : SLsmg_Backspace_Moves=y; return 0; case esl_display_eight_bit: SLsmg_Display_Eight_Bit=y; return 0; default: return 0; } } case GETVAR: { x = get_int32(buf); switch (x) { case esl_baud_rate: return ret_int(port, SLang_TT_Baud_Rate); case esl_read_fd: return ret_int(port, SLang_TT_Read_FD); case esl_abort_char: return (ret_int(port, SLang_Abort_Char)); case esl_ignore_user_abort: return ret_int(port, SLang_Ignore_User_Abort); case esl_input_buffer_len : return ret_int(port, SLang_Input_Buffer_Len); case esl_keyboard_quit: return ret_int(port, SLKeyBoard_Quit); case esl_last_key_char: return ret_int(port, SLang_Last_Key_Char); case esl_rl_eof_char: return ret_int(port, SLang_RL_EOF_Char); case esl_rline_quit: return ret_int(port, SLang_Rline_Quit); case esl_screen_rows: return ret_int(port, SLtt_Screen_Rows); case esl_screen_cols : return ret_int(port, SLtt_Screen_Cols); case esl_tab_width: return ret_int(port, SLsmg_Tab_Width); case esl_newline_behaviour: return ret_int(port, SLsmg_Newline_Behavior); case esl_error: return ret_int(port, SLang_Error); case esl_version: return ret_int(port, SLang_Version); case esl_backspace_moves : return ret_int(port, SLsmg_Backspace_Moves); case esl_display_eight_bit: return ret_int(port, SLsmg_Display_Eight_Bit); default: return ret_int(port, -1); } } /*{{{ SLsmg Screen Management Functions */ case SMG_FILL_REGION: { x = get_int32(buf); buf+= 4; y = get_int32(buf); buf+= 4; z = get_int32(buf); buf+= 4; v = get_int32(buf); buf+= 4; ch = *buf; SLsmg_fill_region(x, y,z,v,ch); return 0; } case SMG_SET_CHAR_SET: { x = get_int32(buf); buf+= 4; SLsmg_set_char_set(x); return 0; } case SMG_SUSPEND_SMG: { return ret_int(port, SLsmg_suspend_smg()); } case SMG_RESUME_SMG: { ret_int(port, SLsmg_resume_smg()); } case SMG_ERASE_EOL: { SLsmg_erase_eol(); return 0; } case SMG_GOTORC: { x = get_int32(buf); buf+= 4; y = get_int32(buf); buf+= 4; SLsmg_gotorc(x, y); return 0; } case SMG_ERASE_EOS: { SLsmg_erase_eos(); return 0; } case SMG_REVERSE_VIDEO: { SLsmg_reverse_video(); return 0; } case SMG_SET_COLOR: { x = get_int32(buf); buf+= 4; SLsmg_set_color(x); return 0; } case SMG_NORMAL_VIDEO: { SLsmg_normal_video(); return 0; } case SMG_WRITE_STRING: { SLsmg_write_string(buf); return 0; } case SMG_WRITE_CHAR: { ch = *buf; SLsmg_write_char(ch); return 0; } case SMG_WRITE_WRAPPED_STRING: { t1 = buf; buf += strlen(t1) + 1; x = get_int32(buf); buf+= 4; y = get_int32(buf); buf+= 4; z = get_int32(buf); buf+= 4; v = get_int32(buf); buf+= 4; w = get_int32(buf); buf+= 4; SLsmg_write_wrapped_string(t1, x,y,z,v,w); return 0; } case SMG_CLS: { SLsmg_cls(); return 0; } case SMG_REFRESH: { SLsmg_refresh(); return 0; } case SMG_TOUCH_LINES: { x = get_int32(buf); buf+= 4; y = get_int32(buf); buf+= 4; SLsmg_touch_lines(x, y); return 0; } case SMG_TOUCH_SCREEN: { #if (SLANG_VERSION < 10400 ) return ret_int(port, -1); #else SLsmg_touch_screen(); #endif return 0; } case SMG_INIT_SMG: { return ret_int(port, SLsmg_init_smg()); } case SMG_REINIT_SMG: { #if (SLANG_VERSION < 10400 ) return ret_int(port, -1); #else return ret_int(port, SLsmg_reinit_smg()); #endif } case SMG_RESET_SMG: { SLsmg_reset_smg(); return 0; } case SMG_CHAR_AT: { return ret_int(port, SLsmg_char_at()); } case SMG_SET_SCREEN_START: { int *ip1, *ip2; *ip1 = get_int32(buf); buf+= 4; *ip2 = get_int32(buf); buf+= 4; SLsmg_set_screen_start(ip1, ip2); return ret_int_int(port, *ip1, *ip2); } case SMG_DRAW_HLINE: { x = get_int32(buf); buf+= 4; SLsmg_draw_hline(x); return 0; } case SMG_DRAW_VLINE: { x = get_int32(buf); buf+= 4; SLsmg_draw_vline(x); return 0; } case SMG_DRAW_OBJECT: { x = get_int32(buf); buf+= 4; y = get_int32(buf); buf+= 4; x = get_int32(buf); buf+= 4; SLsmg_draw_object(x, y,z); return 0; } case SMG_DRAW_BOX: { x = get_int32(buf); buf+= 4; y = get_int32(buf); buf+= 4; z = get_int32(buf); buf+= 4; v = get_int32(buf); buf+= 4; SLsmg_draw_box(x, y,z,v); return 0; } case SMG_GET_COLUMN: { return ret_int(port, SLsmg_get_column()); } case SMG_GET_ROW: { return ret_int(port, SLsmg_get_row()); } case SMG_FORWARD: { x = get_int32(buf); buf+= 4; SLsmg_forward(x); return 0; } case SMG_WRITE_COLOR_CHARS: { SLsmg_Char_Type * sl; sl = decode_smg_char_type(&buf); x = get_int32(buf); buf+= 4; SLsmg_write_color_chars(sl, x); return 0; } case SMG_READ_RAW: { x = get_int32(buf); buf+= 4; t1 = malloc((2*x) + 2 + 1); y = SLsmg_read_raw((unsigned short*)t1 +1, x); t1[1] = 1; driver_output(port, t1, y+1); free(t1); return 0; } case SMG_WRITE_RAW: { SLsmg_Char_Type * sl; sl = decode_smg_char_type(&buf); x = get_int32(buf); y = SLsmg_write_raw(sl, x); return ret_int(port, y); } case SMG_SET_COLOR_IN_REGION: { x = get_int32(buf); buf+= 4; y = get_int32(buf); buf+= 4; z = get_int32(buf); buf+= 4; v = get_int32(buf); buf+= 4; w = get_int32(buf); buf+= 4; SLsmg_set_color_in_region(x, y,z,v,w); return 0; } /* all the tt_functions */ case TT_FLUSH_OUTPUT: { ret = SLtt_flush_output(); return ret_int(port, ret); } case TT_SET_SCROLL_REGION: { x = get_int32(buf); buf+=4; y = get_int32(buf); buf+=4; SLtt_set_scroll_region(x, y); return 0; } case TT_RESET_SCROLL_REGION: { SLtt_reset_scroll_region(); return 0; } case TT_REVERSE_VIDEO: { SLtt_reverse_video (get_int32(buf)); return 0; } case TT_BOLD_VIDEO: { SLtt_begin_insert(); return 0; } case TT_BEGIN_INSERT: { SLtt_begin_insert(); return 0; } case TT_END_INSERT: { SLtt_end_insert(); return 0; } case TT_DEL_EOL: { SLtt_del_eol(); return 0; } case TT_GOTO_RC: { x = get_int32(buf); buf+=4; y = get_int32(buf); buf+=4; SLtt_goto_rc (x, y); return 0; } case TT_DELETE_NLINES: { SLtt_delete_nlines(get_int32(buf)); return 0; } case TT_DELETE_CHAR: { SLtt_delete_char(); return 0; } case TT_ERASE_LINE: { SLtt_erase_line(); return 0; } case TT_NORMAL_VIDEO: { SLtt_normal_video(); return 0; } case TT_CLS: { SLtt_cls(); return 0; } case TT_BEEP: { SLtt_beep(); return 0; } case TT_REVERSE_INDEX: { SLtt_reverse_index(get_int32(buf)); return 0; } case TT_SMART_PUTS: { SLsmg_Char_Type *t1 ; SLsmg_Char_Type *t2; t1 = decode_smg_char_type(&buf); t2 = decode_smg_char_type(&buf); x = get_int32(buf); buf+=4; y = get_int32(buf); buf+=4; SLtt_smart_puts(t1, t2,x,y); return 0; } case TT_WRITE_STRING: { SLtt_write_string (buf); return 0; } case TT_PUTCHAR: { SLtt_putchar((char) get_int32(buf)); return 0; } case TT_INIT_VIDEO: { ret = SLtt_init_video (); return ret_int(port, ret); } case TT_RESET_VIDEO: { SLtt_reset_video (); return 0; } case TT_GET_TERMINFO: { SLtt_get_terminfo(); return 0; } case TT_GET_SCREEN_SIZE: { SLtt_get_screen_size (); return 0; } case TT_SET_CURSOR_VISIBILITY: { ret = SLtt_set_cursor_visibility (get_int32(buf)); return ret_int(port, ret); } case TT_SET_MOUSE_MODE: { x = get_int32(buf); buf+=4; y = get_int32(buf); buf+=4; ret = SLtt_set_mouse_mode (x,y); return ret_int(port, ret); } case TT_INITIALIZE: { ret =SLtt_initialize (buf); return ret_int(port, ret); } case TT_ENABLE_CURSOR_KEYS: { SLtt_enable_cursor_keys(); return 0; } case TT_SET_TERM_VTXXX: { return 0; } case TT_SET_COLOR_ESC: { x = get_int32(buf); buf+=4; SLtt_set_color_esc (x, buf); return 0; } case TT_WIDE_WIDTH: { SLtt_narrow_width(); return 0; } case TT_NARROW_WIDTH: { SLtt_narrow_width(); return 0; } case TT_SET_ALT_CHAR_SET: { SLtt_set_alt_char_set (get_int32(buf)); return 0; } case TT_WRITE_TO_STATUS_LINE: { x = get_int32(buf); buf+=4; SLtt_write_to_status_line (buf, x); return 0; } case TT_DISABLE_STATUS_LINE: { SLtt_disable_status_line (); return 0; } case TT_TGETSTR: { str = SLtt_tgetstr (buf); return ret_string(port, str); } case TT_TGETNUM: { x = SLtt_tgetnum (buf); return ret_int(port, x); } case TT_TGETFLAG: { x = SLtt_tgetflag (buf); return ret_int(port, x); } case TT_TIGETENT: { str = SLtt_tigetent (buf); return ret_string(port, str); } case TT_TIGETSTR: { return 0; } case TT_TIGETNUM: { return 0; } case SLTT_GET_COLOR_OBJECT: { x = get_int32(buf); buf+=4; y = SLtt_get_color_object (x); return ret_int(port, y); return 0; } case TT_SET_COLOR_OBJECT: { x = get_int32(buf); buf+=4; y = get_int32(buf); buf+=4; SLtt_set_color_object (x, y); return 0; } case TT_SET_COLOR: { x = get_int32(buf); buf+=4; t1 = buf; t2 = buf + (strlen(t1) + 1); t3 = buf + (strlen(t1) + strlen(t2) + 2); SLtt_set_color (x, t1, t2, t3); return 0; } case TT_SET_MONO: { x = get_int32(buf); buf+=4; t1 = buf; buf += strlen(t1) + 1; y = get_int32(buf); SLtt_set_mono (x, t1, y); return 0; } case TT_ADD_COLOR_ATTRIBUTE: { x = get_int32(buf); buf+=4; y = get_int32(buf); buf+=4; SLtt_add_color_attribute (x, y); return 0; } case TT_SET_COLOR_FGBG: { x = get_int32(buf); buf+=4; y = get_int32(buf); buf+=4; z = get_int32(buf); buf+=4; SLtt_set_color_fgbg (x, y, z); return 0; } case ISATTY: { x = get_int32(buf); buf+=4; return ret_int(port, isatty(x)); } case EFORMAT: { fprintf(stderr, "%s", buf); fflush(stderr); return 0; } case SIGNAL: { x = get_int32(buf); buf+=4; SLsignal(x_to_sig(x), sig_handler); return 0; } case SIGNAL_CHECK: { /* polled */ if (signal_cought != 0) signal_cought = 0; return ret_int(port, signal_cought); } default: return 0; } }