/** regexp_matched_pos : 'regexp -> n:int -> { pos => int, len => int } <doc>Return the [n]th matched block position by the regexp. If [n] is 0 then return the whole matched substring position</doc> **/ static value regexp_matched_pos( value o, value n ) { pcredata *d; int m; val_check_kind(o,k_regexp); d = PCRE(o); val_check(n,int); m = val_int(n); if( m < 0 || m >= d->nmatchs || val_is_null(d->str) ) return alloc_null(); { int start = d->matchs[m*2]; int len = d->matchs[m*2+1] - start; value o = alloc_empty_object(); alloc_field(o,id_pos,alloc_int(start)); alloc_field(o,id_len,alloc_int(len)); return o; } }
/** socket_send_char : 'socket -> int -> void <doc>Send a character over a connected socket. Must be in the range 0..255</doc> **/ static value socket_send_char( value o, value v ) { int c; unsigned char cc; SOCKET sock = val_sock(o); val_check(v,int); c = val_int(v); if( c < 0 || c > 255 ) return alloc_null(); cc = (unsigned char)c; gc_enter_blocking(); POSIX_LABEL(send_char_again); if( send(sock,(const char *)&cc,1,MSG_NOSIGNAL) == SOCKET_ERROR ) { HANDLE_EINTR(send_char_again); return block_error(); } gc_exit_blocking(); return alloc_bool(true); }
value lime_al_gen_buffers (value n) { int count = val_int (n); ALuint* buffers = new ALuint[count]; alGenBuffers (count, buffers); value result = alloc_array (count); for (int i = 0; i < count; ++i) { val_array_set_i (result, i, alloc_int (buffers[i])); } delete [] buffers; return result; }
void lime_al_source_pausev (int n, value sources) { if (val_is_null (sources) == false) { int size = val_array_size (sources); ALuint* data = new ALuint[size]; for (int i = 0; i < size; ++i) { data[i] = (ALuint)val_int( val_array_i (sources, i) ); } alSourcePausev (n, data); delete[] data; } }
value wx_timer_create(value inOwner,value inID) { wxEvtHandler *handler=0; ValueToWX(inOwner,handler); if (handler) { wxClientData *data = handler->GetClientObject(); if (data) { HaxeEventHandler *haxe = (HaxeEventHandler *)data; handler = haxe; } } wxTimer *timer = new wxTimer( handler, val_int(inID) ); return WXToDeletingValue(timer); }
/** $hresize : 'hash -> int -> void <doc>Resize an hashtable</doc> **/ static value builtin_hresize( value vh, value size ) { vhash *h; hcell **cc; int nsize; int i; val_check_kind(vh,k_hash); val_check(size,int); h = val_hdata(vh); nsize = val_int(size); if( nsize <= 0 ) nsize = HASH_DEF_SIZE; cc = (hcell**)alloc(sizeof(hcell*)*nsize); memset(cc,0,sizeof(hcell*)*nsize); for(i=0;i<h->ncells;i++) add_rec(cc,nsize,h->cells[i]); h->cells = cc; h->ncells = nsize; return val_null; }
/** host_reverse : 'int32 -> string <doc>Reverse the DNS of the given IP address.</doc> **/ static value host_reverse( value host ) { struct hostent *h; unsigned int ip; val_check(host,int); ip = val_int(host); gc_enter_blocking(); # if defined(NEKO_WINDOWS) || defined(NEKO_MAC) || defined(ANDROID) || defined(BLACKBERRY) h = gethostbyaddr((char *)&ip,4,AF_INET); # else struct hostent htmp; int errcode; char buf[1024]; gethostbyaddr_r((char *)&ip,4,AF_INET,&htmp,buf,1024,&h,&errcode); # endif gc_exit_blocking(); if( h == NULL ) return alloc_null(); return alloc_string( h->h_name ); }
/** $sfind : src:string -> pos:int -> pat:string -> int? <doc> Return the first position starting at [pos] in [src] where [pat] was found. Return null if not found. Error if [pos] is outside [src] bounds. </doc> **/ static value builtin_sfind( value src, value pos, value pat ) { int p, l, l2; const char *ptr; val_check(src,string); val_check(pos,int); val_check(pat,string); p = val_int(pos); l = val_strlen(src); l2 = val_strlen(pat); if( p < 0 || p >= l ) neko_error(); ptr = val_string(src) + p; while( l - p >= l2 ) { if( memcmp(ptr,val_string(pat),l2) == 0 ) return alloc_int(p); p++; ptr++; } return val_null; }
/** regexp_matched : 'regexp -> n:int -> string? <doc>Return the [n]th matched block by the regexp. If [n] is 0 then return the whole matched substring. If the [n]th matched block was optional and not matched, returns null</doc> **/ static value regexp_matched( value o, value n ) { pcredata *d; int m; val_check_kind(o,k_regexp); d = PCRE(o); val_check(n,int); m = val_int(n); if( m < 0 || m >= d->nmatchs || val_is_null(d->str) ) neko_error(); { int start = d->matchs[m*2]; int len = d->matchs[m*2+1] - start; value str; if( start == -1 ) return val_null; str = alloc_empty_string(len); memcpy((char*)val_string(str),val_string(d->str)+start,len); return str; } }
void lime_al_sourceiv (int source, int param, value values) { if (val_is_null (values) == false) { int size = val_array_size (values); ALint* data = new ALint[size]; for (int i = 0; i < size; ++i) { data[i] = (ALint)val_int( val_array_i (values, i) ); } alSourceiv (source, param, data); delete[] data; } }
void lime_al_source_queue_buffers (int source, int nb, value buffers) { if (val_is_null (buffers) == false) { int size = val_array_size (buffers); ALuint* data = new ALuint[size]; for (int i = 0; i < size; ++i) { data[i] = (ALuint)val_int( val_array_i (buffers, i) ); } alSourceQueueBuffers (source, nb, data); delete[] data; } }
void lime_al_delete_buffers (int n, value buffers) { if (val_is_null (buffers) == false) { int size = val_array_size (buffers); ALuint* data = new ALuint[size]; for (int i = 0; i < size; ++i) { data[i] = (ALuint)val_int( val_array_i (buffers, i) ); } alDeleteBuffers (n, data); delete[] data; } }
/** sys_create_dir : string -> mode:int -> void <doc>Create a directory with the specified rights</doc> **/ static value sys_create_dir( value path, value mode ) { #ifdef EPPC return alloc_bool(true); #else val_check(path,string); val_check(mode,int); gc_enter_blocking(); #ifdef NEKO_WINDOWS if( mkdir(val_string(path)) != 0 ) #else if( mkdir(val_string(path),val_int(mode)) != 0 ) #endif { gc_exit_blocking(); return alloc_null(); } gc_exit_blocking(); return alloc_bool(true); #endif }
static void test_max(Tuple *tuples[]) { Sum *s_int = sum_max(0, Int, val_new_int(&res.defi)); Sum *s_real = sum_max(1, Real, val_new_real(&res.defd)); Sum *s_long = sum_max(2, Long, val_new_long(&res.defl)); calc(tuples, s_int, s_real, s_long); if (res.max_int != val_int(sum_value(s_int))) fail(); if (res.max_real != val_real(sum_value(s_real))) fail(); if (res.max_long != val_long(sum_value(s_long))) fail(); test_defs(s_int, s_real, s_long); mem_free(s_int); mem_free(s_real); mem_free(s_long); }
// TODO: check if this is right // sync with udpr_connect() below static value populate_address(ENetAddress *a, value ip, value port) { if(!val_is_null(ip)) val_check(ip,int32); val_check(port,int); if(!val_is_null(ip) && val_int32(ip) != 0) { a->host = val_int32(ip); //a->host = htonl(val_int32(ip)); } else { #ifdef ENET_DEBUG fprintf(stderr, "populate_address: null ip\n"); #endif a->host = ENET_HOST_ANY; } a->port = val_int(port); //htons(val_int(port)) #ifdef ENET_DEBUG fprintf(stderr, "populate_address: %x:%u from %x:%u\n", a->host, a->port, val_is_null(ip)?0:val_int32(ip),val_int(port)); #endif return val_true; }
value snow_iosrc_file_read(value _handle, value _dest, value _size, value _maxnum) { snow::io::iosrc_file* iosrc = snow::from_hx<snow::io::iosrc_file>( _handle ); QuickVec<unsigned char> buffer; if( iosrc ) { if(!val_is_null(_dest)) { ByteArray dest(_dest); int res = snow::io::read(iosrc->file_source, dest.Bytes(), val_int(_size), val_int(_maxnum)); return alloc_int(res); } } //object from hx return alloc_int(-1); } DEFINE_PRIM(snow_iosrc_file_read, 4);
value hx_zmq_getintsockopt(value socket_handle_,value option_) { val_check_kind(socket_handle_, k_zmq_socket_handle); if (!val_is_int(option_)) { val_throw(alloc_int(EINVAL)); return alloc_null(); } int rc = 0; int err = 0; uint64_t optval = 0; size_t optvallen = sizeof(optval); rc = zmq_getsockopt(val_data(socket_handle_),val_int(option_),&optval, &optvallen); err = zmq_errno(); if (rc != 0) { val_throw(alloc_int(err)); return alloc_int(0); } return alloc_int(optval); }
value lime_system_get_directory (value type, value company, value title) { const char* companyName = ""; const char* titleName = ""; if (!val_is_null (company)) companyName = val_string (company); if (!val_is_null (title)) titleName = val_string (title); const char* directory = System::GetDirectory ((SystemDirectory)val_int (type), companyName, titleName); if (directory) { return alloc_string (directory); } else { return alloc_null (); } }
/** inflate_init : window_size:int? -> 'istream <doc>Open a decompression stream</doc> **/ static value inflate_init( value wsize ) { z_stream *z; value s; int err; int wbits; if( val_is_null(wsize) ) wbits = MAX_WBITS; else { val_check(wsize,int); wbits = val_int(wsize); } z = (z_stream*)malloc(sizeof(z_stream) + sizeof(int)); memset(z,0,sizeof(z_stream)); val_flush(z) = Z_NO_FLUSH; if( (err = inflateInit2(z,wbits)) != Z_OK ) { free(z); zlib_error(NULL,err); } s = alloc_abstract(k_stream_inf,z); //val_gc(s,free_stream_inf); return s; }
value hx_zmq_construct_socket (value context_handle,value type) { val_is_kind(context_handle,k_zmq_context_handle); if (!val_is_int(type)) { val_throw(alloc_int(EINVAL)); return alloc_null(); } void *s = zmq_socket (val_data(context_handle),val_int(type)); int err = zmq_errno(); if (s == NULL) { val_throw (alloc_int(err)); return alloc_null(); } // See: http://nekovm.org/doc/ffi#abstracts_and_kinds value v = alloc_abstract(k_zmq_socket_handle,s); val_gc(v,finalize_socket); // finalize_socket is called when the abstract value is garbage collected return v; }
/** socket_bind : host : int32 -> port:int -> connections:int -> incoming:int32 -> outgoing:int32 -> bool <doc>Bind a UDPR socket for server usage on the given host and port, with max connections, incoming bandwidth limited to bytes per second or 0 for unlimited, outgoing also. Host may be val_type_null, in which case the binding is to ENET_HOST_ANY </doc> **/ static value udpr_bind( value ip, value port, value connections, value incoming, value outgoing ) { ENetAddress address; ENetHost *s; val_check(connections,int); val_check(incoming,int32); val_check(outgoing,int32); if(populate_address(& address, ip, port) != val_true) neko_error(); s = enet_host_create( &address, (size_t)val_int(connections), /* number of clients and/or outgoing connections */ (enet_uint32)val_int32(incoming), /* amount of incoming bandwidth in Bytes/sec */ (enet_uint32)val_int32(outgoing)); if(s == NULL) neko_error(); value v = alloc_abstract(k_udprhost,s); val_gc(v, destroy_enethost); #ifdef ENET_DEBUG fprintf(stderr, "udpr_bind: complete\n"); #endif return v; }
static const cst_val *asyl_in(const cst_item *syl) { /* Number of accented syllables since last major break */ const cst_item *ss,*p,*fs; int c; ss = item_as(syl,"Syllable"); fs = path_to_item(syl,"R:SylStructure.parent.R:Phrase.parent.daughter.R:SylStructure.daughter"); for (c=0, p=ss; p && (c < CST_CONST_INT_MAX); p=item_prev(p)) { if (val_int(accented(p)) == 1) c++; if (item_equal(p,fs)) break; } return val_string_n(c); }
void NekoCodeChunk::neko_dump(std::string const & indent) const { for (const_iterator it = begin(); it != end(); ++it) { std::cout << indent << it->first << ": "; print_neko_instruction((OPCODE) it->second.first, it->second.second, parameter_table[it->second.first]); std::cout << "; // "; { int ppc = (int)((int_val *)it->first - m->code); int idx = m->dbgidxs[ppc>>5].base + bitcount(m->dbgidxs[ppc>>5].bits >> (31 - (ppc & 31))); value s = val_array_ptr(m->dbgtbl)[idx]; if( val_is_string(s) ) printf("%s",val_string(s)); else if( val_is_array(s) && val_array_size(s) == 2 && val_is_string(val_array_ptr(s)[0]) && val_is_int(val_array_ptr(s)[1]) ) printf("file %s line %d",val_string(val_array_ptr(s)[0]),val_int(val_array_ptr(s)[1])); else printf("???"); } std::cout << std::endl; } }
// ----------------------------------------------------------------------------- // ObjectEditPanel class constructor // ----------------------------------------------------------------------------- ObjectEditPanel::ObjectEditPanel(wxWindow* parent) : wxPanel(parent) { wxIntegerValidator<int> val_int(nullptr, wxNUM_VAL_DEFAULT); wxIntegerValidator<unsigned int> val_uint(nullptr, wxNUM_VAL_DEFAULT); wxFloatingPointValidator<double> val_double(2, nullptr, wxNUM_VAL_DEFAULT); auto tb_size = WxUtils::scaledSize(64, -1); // Create controls text_xoff_ = new wxTextCtrl(this, -1, "", wxDefaultPosition, tb_size, 0, val_int); text_yoff_ = new wxTextCtrl(this, -1, "", wxDefaultPosition, tb_size, 0, val_int); text_scalex_ = new wxTextCtrl(this, -1, "", wxDefaultPosition, tb_size, 0, val_uint); text_scaley_ = new wxTextCtrl(this, -1, "", wxDefaultPosition, tb_size, 0, val_uint); combo_rotation_ = new wxComboBox(this, -1, "", wxDefaultPosition, tb_size); cb_mirror_x_ = new wxCheckBox(this, -1, "Mirror X"); cb_mirror_y_ = new wxCheckBox(this, -1, "Mirror Y"); btn_preview_ = new SIconButton(this, "eye", "Preview"); btn_cancel_ = new SIconButton(this, "close", "Cancel"); btn_apply_ = new SIconButton(this, "tick", "Apply"); // Init controls combo_rotation_->Set(WxUtils::arrayString({ "0", "45", "90", "135", "180", "225", "270", "315" })); combo_rotation_->SetValidator(val_double); btn_preview_->SetDefault(); // Layout setupLayout(); // Bind events btn_preview_->Bind(wxEVT_BUTTON, &ObjectEditPanel::onBtnPreviewClicked, this); btn_cancel_->Bind(wxEVT_BUTTON, [&](wxCommandEvent&) { KeyBind::pressBind("map_edit_cancel"); }); btn_apply_->Bind(wxEVT_BUTTON, [&](wxCommandEvent&) { KeyBind::pressBind("map_edit_accept"); }); cb_mirror_x_->Bind(wxEVT_CHECKBOX, &ObjectEditPanel::onBtnPreviewClicked, this); cb_mirror_y_->Bind(wxEVT_CHECKBOX, &ObjectEditPanel::onBtnPreviewClicked, this); // Init layout wxWindowBase::Layout(); }
value readByte(value a) { int fd = val_int(a); char buffer[2]; //--------------------------------------------- #if defined( TARGET_OSX ) || defined( TARGET_LINUX ) if(read(fd, buffer, 1) < 0){ return alloc_null(); } #endif //--------------------------------------------- //--------------------------------------------- #ifdef TARGET_WIN32 DWORD nRead; if (!ReadFile((HANDLE)fd, buffer, 1, &nRead, 0)){ return alloc_null(); } #endif //--------------------------------------------- buffer[1] = '\0'; return alloc_int(buffer[0]); }
void Bytes::Set (value bytes) { if (val_is_null (bytes)) { _length = 0; _data = 0; _value = 0; } else { _value = bytes; _length = val_int (val_field (bytes, id_length)); if (_length > 0) { value b = val_field (bytes, id_b); if (val_is_string (b)) { _data = (unsigned char*)val_string (b); } else { _data = (unsigned char*)buffer_data (val_to_buffer (b)); } } else { _data = 0; } } }
/** inflate_buffer : 'istream -> src:string -> srcpos:int -> dst:string -> dstpos:int -> { done => bool, read => int, write => int } **/ static value inflate_buffer( value s, value src, value srcpos, value dst, value dstpos ) { z_stream *z; int err; value o; val_check_kind(s,k_stream_inf); val_check(srcpos,int); buffer src_buf = val_to_buffer(src); if (!src_buf) hx_failure("invalid source buffer"); buffer dst_buf = val_to_buffer(dst); if (!dst_buf) hx_failure("invalid destination buffer"); int slen = buffer_size(src_buf); int dlen = buffer_size(dst_buf); val_check(dstpos,int); z = val_stream(s); if( val_int(srcpos) < 0 || val_int(dstpos) < 0 ) return alloc_null(); slen -= val_int(srcpos); dlen -= val_int(dstpos); if( slen < 0 || dlen < 0 ) return alloc_null(); z->next_in = (Bytef*)buffer_data(src_buf) + val_int(srcpos); z->next_out = (Bytef*)buffer_data(dst_buf) + val_int(dstpos); z->avail_in = slen; z->avail_out = dlen; if( (err = inflate(z,val_flush(z))) < 0 ) zlib_error(z,err); z->next_in = NULL; z->next_out = NULL; o = alloc_empty_object(); alloc_field(o,id_done,alloc_bool(err == Z_STREAM_END)); alloc_field(o,id_read,alloc_int((int)(slen - z->avail_in))); alloc_field(o,id_write,alloc_int((int)(dlen - z->avail_out))); return o; }
value _SSL_set_mode(value ssl, value op) { long response = SSL_set_mode((SSL*) val_data(ssl), val_int(op)); return alloc_best_int(response); }
//int SSL_write(SSL *ssl,const void *buf,int num); value _SSL_write(value ssl, const value buf, value num) { return alloc_int(SSL_write((SSL*) val_data(ssl), val_data(buf), val_int(num))); }
//int SSL_read(SSL *ssl,void *buf,int num); value _SSL_read(value ssl, value buf, value num) { return alloc_int( SSL_read((SSL*) val_data(ssl), val_data(buf), val_int(num))); }