Datum spherecircle_in(PG_FUNCTION_ARGS) { SCIRCLE * c = ( SCIRCLE * ) MALLOC ( sizeof ( SCIRCLE ) ) ; char * s = PG_GETARG_CSTRING(0); double lng, lat, radius ; void sphere_yyparse( void ); init_buffer ( s ); sphere_yyparse(); if ( get_circle( &lng, &lat, &radius ) ){ c->center.lng = lng; c->center.lat = lat; c->radius = radius; reset_buffer(); /* It's important to allow circles with radius 90deg!! */ if ( FPgt(c->radius,PIH) ){ FREE( c ); c = NULL; elog ( ERROR , "spherecircle_in: radius must be not greater than 90 degrees" ); } else if ( FPeq(c->radius,PIH) ){ // set "exact" 90 degrees c->radius = PIH; } spoint_check ( &c->center ); } else { reset_buffer(); FREE( c ); c = NULL; elog ( ERROR , "spherecircle_in: parse error" ); } PG_RETURN_POINTER( c ); }
Datum spheretrans_in(PG_FUNCTION_ARGS) { SEuler * se = ( SEuler * ) MALLOC ( sizeof ( SEuler ) ) ; char * c = PG_GETARG_CSTRING(0); unsigned char etype[3]; int i; void sphere_yyparse( void ); init_buffer ( c ); sphere_yyparse(); if ( get_euler ( &se->phi, &se->theta, &se->psi, etype ) ){ for ( i=0; i<3; i++ ){ switch ( i ){ case 0: se->phi_a = etype[i] ; break; case 1: se->theta_a = etype[i] ; break; case 2: se->psi_a = etype[i] ; break; } } spheretrans_check(se); } else { reset_buffer(); FREE( se ); se = NULL; elog ( ERROR , "spheretrans_in: parse error" ); } reset_buffer(); PG_RETURN_POINTER( se ); }
Datum spherepoint_in(PG_FUNCTION_ARGS) { SPoint *sp = (SPoint *) palloc(sizeof(SPoint)); char *c = PG_GETARG_CSTRING(0); double lng, lat; void sphere_yyparse(void); init_buffer(c); sphere_yyparse(); if (get_point(&lng, &lat)) { sp->lng = lng; sp->lat = lat; spoint_check(sp); } else { reset_buffer(); pfree(sp); sp = NULL; elog(ERROR, "spherepoint_in: parse error"); } reset_buffer(); PG_RETURN_POINTER(sp); }
Datum spherepoly_in(PG_FUNCTION_ARGS) { SPOLY * poly ; char * c = PG_GETARG_CSTRING(0); static int32 i, nelem; void sphere_yyparse( void ); init_buffer ( c ); sphere_yyparse() ; nelem = get_path_count( ) ; if ( nelem > 2 ){ SPoint arr[nelem]; for ( i = 0; i<nelem ; i++ ){ get_path_elem ( i , &arr[i].lng , &arr[i].lat ); } poly = spherepoly_from_array ( &arr[0], nelem ); } else { reset_buffer(); elog ( ERROR , "spherepoly_in: more than two points needed" ); PG_RETURN_NULL(); } reset_buffer(); PG_RETURN_POINTER( poly ); }
lcb_error_t lcb_connection_reset_buffers(lcb_connection_t conn) { if (reset_buffer(&conn->input, conn->instance->config.rbufsize) != LCB_SUCCESS) { return LCB_CLIENT_ENOMEM; } if (reset_buffer(&conn->output, conn->instance->config.wbufsize) != LCB_SUCCESS) { return LCB_CLIENT_ENOMEM; } return LCB_SUCCESS; }
int parse_file(t_tetrim *t, int fd, char *data) { char last; t_buffer *buffer; int i; i = 0; buffer = create_buffer(); while ((read(fd, data, 1)) > 0) { if ((i == 20 || i == 21) && (last == '\n' && data[0] == '\n' && parse_buffer(buffer, t, 0))) return (-1); else if ((i == 20 || i == 21) && last == '\n' && data[0] == '\n' && (t = t->next) != NULL) { buffer = reset_buffer(buffer); i = 0; } add_buffer(buffer, data[0]); last = data[0]; i++; } if ((i != 21 && i != 20) || (parse_buffer(buffer, t, 1) || close(fd))) return (-1); free(buffer); return (0); }
bool lexer::tokenize() { _next_line = _line = 1; _next_column = _column = 1; _current_char = _next_char = '\0'; _next_char_cached = false; for (; next() != '\0';) { whitespace(); _line = _next_line; _column = _next_column; if (current() == '\0') { break; } emit_result const test = string(); switch (test) { case no_match: emit(token_kind::error); // fallthrough case digest_failure: return false; case good: break; } reset_buffer(); } return true; }
void camera_init_buffer(buffer_arr_t *pbuf) { print_debug("enter %s", __func__); memset(pbuf->buffers, 0x00, sizeof(camera_frame_buf) * MAX_FRAME_NR); pbuf->buf_count = 0; reset_buffer(pbuf->buffers, MAX_FRAME_NR); }
//this function sets up the global dictionary in the flash and sets the pointers to the same. static int set_up_data_segment () { int j=0; char * Flash_ptr; //here = data_segment; //latest = 0; //*TOIP(data_segment) = 0; //data_set(0,global_dictionary); Global_Dict=&GlobalDict; Global_Dict->here=global_dictionary; Global_Dict->latest=0; *TOIP(global_dictionary) = 0; for (j = 0; j < 1024; j++) Global_Dict->here[j] = 0xff; Flash_ptr = (char *) (global_dictionary); //FCTL3 = FWKEY; // Clear Lock bit //FCTL1 = FWKEY+ERASE; // Set Erase bit *Flash_ptr = 0; //FCTL1 = FWKEY+ERASE; Flash_ptr = (char *) (global_dictionary+512); *Flash_ptr = 0; Global_Dict->vtid=-1; Global_Dict->Next=0; vt_cur_node=Global_Dict; reset_buffer(); return 0; }
int completion_search_path(t_comp *comp) { t_env *env; t_env_list *path; char **paths; env = &get_shell_data()->env; if (!(path = ft_getenv(env->env_list, "PATH"))) return (0); if (!(paths = ft_strsplit(path->value, ':'))) return (MALLOC_FAIL); if (ft_tab_len(paths) > MAX_PATH_COMPONENTS) { ft_dprintf(STDERR_FILENO, "42sh: Max path components reached"); reset_buffer(&get_shell_data()->input); ft_free_string_tab(&paths); return (1); } if ((comp->matches = open_path_dirs(comp, paths)) == NULL && comp->nb_matches == -1) { ft_free_string_tab(&paths); return (MALLOC_FAIL); } ft_free_string_tab(&paths); return (0); }
bool http_reply::add_content(char const * content, std::size_t content_size) { if (!content || content_size == 0) return false; try { add_crlf(); std::size_t const prev_buf_size = buf_ref_.size(); std::size_t new_buf_size = prev_buf_size + content_size; if (enable_buf_realocation_) buf_ref_.resize(new_buf_size); for (std::size_t it = prev_buf_size, it_ = 0; it < new_buf_size && it_ < content_size; ++it, ++it_) { buf_ref_.at(it) = content[it_]; } } catch (std::exception const &) { reset_buffer(); return false; } return true; }
// TODO: Get this thing to be able to setup ANY of the UART channels somehow!! void config_uart(unsigned long baudRate) { // Make sure our buffers start empty: reset_buffer(); // Configure RX pin: // Set R7 as an input. I don't think this is needed for uart.. but let's // just be sure. //TRISBBITS rxPinU1 = TRISBbits.TRISB7; TRISBbits.TRISB7 = 1; OSCCONbits.IOLOCK = 0; // unlock the peripheral Control Register Lock // Configure RX pin: RPINR18bits.U1RXR = 7; // Map UART1 RX peripheral to RP7 // RPINR18bits.U1RXR = 26; // Map UART1 RX peripheral to RP26 (also, RG7) // Configure TX pin: RPOR3bits.RP6R = 3; // Map RP6 pin to UART1 TX OSCCONbits.IOLOCK = 1; // relock the peripheral Control Register Lock // Set baud rate: U1BRG = (((FCY)/(4 * baudRate)) - 1); // Set interrupt priorities: // (Honestly, not sure exactly what this is doing...) IPC3bits.U1TXIP2 = 1; //Set Uart TX Interrupt Priority IPC3bits.U1TXIP1 = 0; IPC3bits.U1TXIP0 = 0; IPC2bits.U1RXIP2 = 1; //Set Uart RX Interrupt Priority IPC2bits.U1RXIP1 = 0; IPC2bits.U1RXIP0 = 0; U1TXREG = 0; // Ensure that we start with an empty TX buffer U1STA = 0; // Clear the UxSTA register (for tx1 and rx1 only) U1STAbits.URXISEL = 0; // Configure when the TX interrupt will fire // Enable UART for 8-bit data: U1MODE = 0; // Clear the UxMode register (for tx1 and rx1 only) //U1MODEbits.RTSMD = 1; // RTS pin bit is in simplex mode not flow control mode U1MODEbits.BRGH = 1; // 1 = low speed U1MODEbits.UARTEN = 1; // Actually enable the UART module (MUST be done before UTXEN is set) U1STAbits.UTXEN = 1; // enable transmit IEC0bits.U1TXIE = 1; // enable transmit interrupt IEC0bits.U1RXIE = 1; // enable receive interrupt // Clear the flags for both interrupts: IFS0bits.U1TXIF = 0; IFS0bits.U1RXIF = 0; // Configure the buffer pointers: U1TXCharPtr = &txBufU1[0]; U1RXCharPtr = &rxBufU1[0]; __delay_ms(100); printf("\n\nUART should be working at 115200 baud now!\r\n"); }
void etna_cmd_stream_finish(struct etna_cmd_stream *stream) { struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream); flush(stream); etna_pipe_wait(priv->pipe, priv->last_timestamp, 5000); reset_buffer(stream); }
static void __producer_stop(void) { if (producer_status == PS_PLAYING || producer_status == PS_PAUSED) { ip_close(ip); __producer_status_update(PS_STOPPED); reset_buffer(); } }
Session::~Session() { reset_buffer(); if (m_sockfd > 0) { close(m_sockfd); } }
static void flush(struct etna_cmd_stream *stream, int in_fence_fd, int *out_fence_fd) { struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream); int ret, id = priv->pipe->id; struct etna_gpu *gpu = priv->pipe->gpu; struct drm_etnaviv_gem_submit req = { .pipe = gpu->core, .exec_state = id, .bos = VOID2U64(priv->submit.bos), .nr_bos = priv->submit.nr_bos, .relocs = VOID2U64(priv->submit.relocs), .nr_relocs = priv->submit.nr_relocs, .stream = VOID2U64(stream->buffer), .stream_size = stream->offset * 4, /* in bytes */ }; if (in_fence_fd != -1) { req.flags |= ETNA_SUBMIT_FENCE_FD_IN | ETNA_SUBMIT_NO_IMPLICIT; req.fence_fd = in_fence_fd; } if (out_fence_fd) req.flags |= ETNA_SUBMIT_FENCE_FD_OUT; /* * Pass the complete submit structure only if flags are set. Otherwise, * only pass the fields up to, but not including the flags field for * backwards compatiblity with older kernels. */ ret = drmCommandWriteRead(gpu->dev->fd, DRM_ETNAVIV_GEM_SUBMIT, &req, req.flags ? sizeof(req) : offsetof(struct drm_etnaviv_gem_submit, flags)); if (ret) ERROR_MSG("submit failed: %d (%s)", ret, strerror(errno)); else priv->last_timestamp = req.fence; for (uint32_t i = 0; i < priv->nr_bos; i++) { struct etna_bo *bo = priv->bos[i]; bo->current_stream = NULL; etna_bo_del(bo); } if (out_fence_fd) *out_fence_fd = req.fence_fd; } void etna_cmd_stream_flush(struct etna_cmd_stream *stream) { flush(stream, -1, NULL); reset_buffer(stream); }
int Session::on_close() { logdbg("session close:%s, pid:%d\n", get_string_ip().c_str(), g_pid); reset_buffer(); close(m_sockfd); m_sockfd = -1; return 0; }
static void receive_frame( int fd, void *user_data ) { UNUSED( fd ); ether_device *device = user_data; assert( device != NULL ); if ( !device->status.up ) { return; } if ( get_max_packet_buffers_length( device->recv_queue ) <= get_packet_buffers_length( device->recv_queue ) ) { warn( "Receive queue is full ( device = %s, usage = %u/%u ).", device->name, get_packet_buffers_length( device->recv_queue ), get_max_packet_buffers_length( device->recv_queue ) ); return; } unsigned int count = 0; const unsigned int max_queue_length = get_max_packet_buffers_length( device->recv_queue ); const unsigned int max_loop_count = max_queue_length < 256 ? max_queue_length : 256; while ( count < max_loop_count ) { buffer *frame = get_buffer_from_free_buffers( device->recv_queue ); if ( frame == NULL ) { warn( "Failed to retrieve a receive buffer ( device = %s, queue usage = %u/%u ).", device->name, get_packet_buffers_length( device->recv_queue ), max_queue_length ); frame = device->recv_buffer; // Use recv_buffer as a trash. } append_back_buffer( frame, device->mtu ); ssize_t length = recv( device->fd, frame->data, frame->length, MSG_DONTWAIT ); assert( length != 0 ); if ( length < 0 ) { if ( frame != device->recv_buffer ) { mark_packet_buffer_as_used( device->recv_queue, frame ); } if ( ( errno == EINTR ) || ( errno == EAGAIN ) || ( errno == EWOULDBLOCK ) || ( errno == ENETDOWN ) ) { break; } char error_string[ ERROR_STRING_SIZE ]; error( "Receive error ( device = %s, errno = %s [%d] ).", device->name, safe_strerror_r( errno, error_string, sizeof( error_string ) ), errno ); break; } if ( frame != device->recv_buffer ) { frame->length = ( size_t ) length; enqueue_packet_buffer( device->recv_queue, frame ); } else { reset_buffer( frame ); } count++; } handle_received_frames( device ); }
static void _consumer_handle_eof(void) { struct track_info *ti; if (ip_is_remote(ip)) { _producer_stop(); _consumer_drain_and_stop(); player_error("lost connection"); return; } if (player_info.ti) player_info.ti->play_count++; if (player_repeat_current) { if (player_cont) { ip_seek(ip, 0); reset_buffer(); } else { _producer_stop(); _consumer_drain_and_stop(); _player_status_changed(); } return; } if (get_next(&ti) == 0) { _producer_unload(); ip = ip_new(ti->filename); _producer_status_update(PS_STOPPED); /* PS_STOPPED, CS_PLAYING */ if (player_cont) { _producer_play(); if (producer_status == PS_UNLOADED) { _consumer_stop(); track_info_unref(ti); file_changed(NULL); } else { /* PS_PLAYING */ file_changed(ti); if (!change_sf(0)) _prebuffer(); } } else { _consumer_drain_and_stop(); file_changed(ti); } } else { _producer_unload(); _consumer_drain_and_stop(); file_changed(NULL); } _player_status_changed(); }
/* * Function: Read a byte from the file buffer * Parameters: file - open file descriptor to the target * Return: Byte read */ char read_char(FILE* file) { if (bytes_in_buffer != CHUNK_SIZE && read_ptr >= bytes_in_buffer) { eof = 1; return 0xff; } if (read_ptr == CHUNK_SIZE) { reset_buffer(file); } return read_buffer[read_ptr++]; }
int Session::on_read_event() { int ret; while (true) { if (!m_has_head) { ret = read_head(); if (ret < 0) { return -1; } if (ret == SESSION_RET_NO_DATA) { return 0; } if (m_msg_type == MSG_HEART_BEAT) { if (g_is_master) { update_active_time(); } else { struct commu_msg msg; msg.ip = get_cli_addr(); msg.msg = MSG_HEART_BEAT; notify_master(msg); } continue; } m_has_head = true; m_buff = (u_char *)glb_mempool()->get(m_msg_len); } int n_read = readn(m_sockfd, &m_buff[m_n_read], m_msg_len - m_n_read); if (n_read < 0) { logerr("socket broken\n"); m_msg_len = 0; m_has_head = false; return -1; } m_n_read += n_read; if (m_n_read == m_msg_len) { write_msg(m_buff, m_msg_len); reset_buffer(); } } return 0; }
s8 set_echo(s8 on) { reset_buffer(); sprintf(temp, "ATE%d\r\n", on); bus_send_string(temp); msleep(200); bus_recieve_string(output); return str_include(output, "OK"); }
/* Reads any base64-encoded certificates present in fp and adds them to store. * Returns TRUE if any certificates were successfully imported. */ static BOOL import_base64_certs_from_fp(FILE *fp, HCERTSTORE store) { char line[1024]; BOOL in_cert = FALSE; struct DynamicBuffer saved_cert = { 0, 0, NULL }; int num_certs = 0; TRACE("\n"); while (fgets(line, sizeof(line), fp)) { static const char header[] = "-----BEGIN CERTIFICATE-----"; static const char trailer[] = "-----END CERTIFICATE-----"; if (!strncmp(line, header, strlen(header))) { TRACE("begin new certificate\n"); in_cert = TRUE; reset_buffer(&saved_cert); } else if (!strncmp(line, trailer, strlen(trailer))) { DWORD size; TRACE("end of certificate, adding cert\n"); in_cert = FALSE; if (CryptStringToBinaryA((char *)saved_cert.data, saved_cert.used, CRYPT_STRING_BASE64, NULL, &size, NULL, NULL)) { LPBYTE buf = CryptMemAlloc(size); if (buf) { CryptStringToBinaryA((char *)saved_cert.data, saved_cert.used, CRYPT_STRING_BASE64, buf, &size, NULL, NULL); if (CertAddEncodedCertificateToStore(store, X509_ASN_ENCODING, buf, size, CERT_STORE_ADD_NEW, NULL)) num_certs++; CryptMemFree(buf); } } } else if (in_cert) add_line_to_buffer(&saved_cert, line); } CryptMemFree(saved_cert.data); TRACE("Read %d certs\n", num_certs); return num_certs > 0; }
int count_vertices() { int result=0; char *ptr; char line[LINELENGTH]; reset_buffer(); while (next_line(line)==0) { ptr = strstr(line,"node"); if (ptr!=NULL) result++; } return result; }
void get_degrees(NETWORK *network) { int s,t; int vs,vt; char *ptr; char line[LINELENGTH]; reset_buffer(); while (next_line(line)==0) { // Find the next edge entry ptr = strstr(line,"edge"); if (ptr==NULL) continue; // Read the source and target of the edge s = t = -1; do { ptr = strstr(line,"source"); if (ptr!=NULL) sscanf(ptr,"source %i",&s); ptr = strstr(line,"target"); if (ptr!=NULL) sscanf(ptr,"target %i",&t); // If we see a closing square bracket we are done if (strstr(line,"]")!=NULL) break; } while (next_line(line)==0); // Increment the degrees of the appropriate vertex or vertices if ((s>=0)&&(t>=0)) { vs = find_vertex(s,network); network->vertex[vs].degree++; if (network->directed==0) { vt = find_vertex(t,network); network->vertex[vt].degree++; } } } return; }
int is_directed() { int result=0; char *ptr; char line[LINELENGTH]; reset_buffer(); while (next_line(line)==0) { ptr = strstr(line,"directed"); if (ptr==NULL) continue; sscanf(ptr,"directed %i",&result); break; } return result; }
bool http_reply::stock_reply(http_reply::status_type status) { try { reset_buffer(); std::string const content = stock_replies::cast_to_string(status); std::size_t const content_size = content.size(); add_status(status); add_header("Content-Length", safe_lexical_cast<std::string>(content_size)); add_header("Content-Type", "text/html"); add_content(content.c_str(), content_size); } catch (std::exception const & expt) { return false; } return true; }
//*************************************************** //*************************************************** // Pops the top of the stack uint8_t Single_buff::pop_top(uint8_t* buff, const uint8_t sz) { // ensure there is even a top if(!m_buff_ready) return 0; // ensure the buffer to copy to is big enough if(sz < m_buff_sz) return 0; // copy over the buffer m_util.cpy_buff(buff, m_buff_array, m_buff_sz); // buffer no longer ready reset_buffer(); return m_buff_sz; }
static void __producer_play(void) { if (producer_status == PS_UNLOADED) { struct track_info *ti; if (get_next(&ti) == 0) { int rc; ip = ip_new(ti->filename); rc = ip_open(ip); if (rc) { player_ip_error(rc, "opening file `%s'", ti->filename); ip_delete(ip); track_info_unref(ti); file_changed(NULL); } else { ip_setup(ip); __producer_status_update(PS_PLAYING); file_changed(ti); } } } else if (producer_status == PS_PLAYING) { if (ip_seek(ip, 0.0) == 0) { reset_buffer(); } } else if (producer_status == PS_STOPPED) { int rc; rc = ip_open(ip); if (rc) { player_ip_error(rc, "opening file `%s'", ip_get_filename(ip)); ip_delete(ip); __producer_status_update(PS_UNLOADED); } else { ip_setup(ip); __producer_status_update(PS_PLAYING); } } else if (producer_status == PS_PAUSED) { __producer_status_update(PS_PLAYING); } }
//*************************************************** //*************************************************** // Add a TUN buffer uint8_t Single_buff::add_TUN_buffer(uint8_t* buff, const uint8_t sz) { // keep track if we had to remove the frame boolean frame_removed = false; // ensure the size is less than max if(sz < LARGE_BUFF_SZ ) { // reset the buffer reset_buffer(); // remove the TUN framing just-in-case frame_removed = m_util.remove_TUN_frame(buff); // only add the TUN packet if it passes // the checksum if(m_util.verify_checksum(buff)) { // set the size if(frame_removed) m_buff_sz = sz - 2; else m_buff_sz = sz; // copy over the buffer m_util.cpy_buff(m_buff_array, buff, m_buff_sz); // signal that we have a buffer ready m_buff_ready = true; // update the packet_id m_buffer_id++; } } else return 0; return m_buff_sz; }