示例#1
0
int draw_outline(void)
{
    int raster_size;

    row = col = top = 0;	/* get started for read of first */
    bottom = 1;			/*   line from raster map */
    scan_length = read_next();
    k = 0;
    raster_size = Rast_cell_size(map_type);
    while (read_next()) {	/* read rest of file, one row at *//*   a time */
	n1 = Rast_row_to_northing((double)row - 1., &(PS.w));
	n2 = Rast_row_to_northing((double)row, &(PS.w));
	n3 = Rast_row_to_northing((double)row + 1., &(PS.w));

	for (col = 0; col < scan_length - 1; col++) {
	    e1 = Rast_col_to_easting((double)col - 1., &(PS.w));
	    e2 = Rast_col_to_easting((double)col, &(PS.w));
	    e3 = Rast_col_to_easting((double)col + 1., &(PS.w));
	    tl = G_incr_void_ptr(buffer[top], col * raster_size);
	    /* top left in window */
	    tr = G_incr_void_ptr(buffer[top], (col + 1) * raster_size);
	    /* top right in window */
	    bl = G_incr_void_ptr(buffer[bottom], col * raster_size);
	    /* bottom left in window */
	    br = G_incr_void_ptr(buffer[bottom], (col + 1) * raster_size);
	    /* bottom right in window */
	    draw_boundaries();
	    if (k == 3)
		k = 0;
	}
	row++;
    }

    return 0;
}				/* draw_outlines */
示例#2
0
文件: serwer.c 项目: Solmis/SO
/* Funkcja obsługująca sesję z komisją */
void* serve_committee(void* mesg_type)
{
    long msg_type = atol(mesg_type);
    long l, k, n, rows = 0, sum = 0;

    while (1)
    {
        l = read_next(msg_type);

        if (l == -1)
            break;

        k = read_next(msg_type);
        n = read_next(msg_type);
        rows++;
        sum += n;
    }

    send_val(msg_snd_kom_id, msg_type, rows);
    send_val(msg_snd_kom_id, msg_type, sum);
    //procesy--;

    //(zapisujemy dane)
    return 0;
}
示例#3
0
StTextFileScanner::StTextFileScanner(const char * file, bool skip) :
	mFile(fopen(file, "r")),
	mDone(false),
	mSkipBlanks(skip)
{
	read_next();
}	
示例#4
0
static void
read_array(ParseInfo pi, const char *key) {
    if (pi->has_array_start) {
	call_no_value(pi->handler, oj_array_start_id, key);
    }
    pi->s++;
    next_non_white(pi);
    if (']' == *pi->s) {
	pi->s++;
    } else {
	while (1) {
	    read_next(pi, 0);
	    next_non_white(pi);
	    if (',' == *pi->s) {
		pi->s++;
	    } else if (']' == *pi->s) {
		pi->s++;
		break;
	    } else {
		if (pi->has_error) {
		    call_error("invalid format, expected , or ] while in an array", pi, __FILE__, __LINE__);
		}
		raise_error("invalid format, expected , or ] while in an array", pi->str, pi->s);
	    }
	}
    }
    if (pi->has_array_end) {
	call_no_value(pi->handler, oj_array_end_id, key);
    }
}
示例#5
0
int Range::iterator::reset (const Range& rng) {
    cur_node = NULL;
    file_handle = NULL;
    atEnd = 0;
    myrange = &rng;
    if (myrange->GetType() == RNG_TYPE_FILE) {
	filename = myrange->GetDefStr()+1;
	if ( (file_handle = fopen(filename, "r")) == NULL) {
	    fprintf(stderr, "Range::iterator: unable to read file '%s'\n", 
		    filename);
	    exit(-1);
	}
	buflen = 1024;
	buf = NULL;
	bufpos = 0;
	bufline = 0;
	if ( read_next(&cur_value, file_handle, filename) == 0) {
	    atEnd = 1;
	}
    } else {
	// Assume regular range
	cur_node = rng.getRangeList();
	if (cur_node) {
	    cur_value = cur_node->start;
	} else {
	    // Empty list
	    cur_value = 0;
	    atEnd = 1;
	}
    }
    return cur_value;
}
示例#6
0
文件: pymp.cpp 项目: sharpeye/pymp
    PyObject * next()
    {
        auto obj = read_next();

        if( is_array( obj ) )
        {
            if( obj.as.array_size )
            {
                push_list( obj.as.array_size );

                return nullptr;
            }

            return PyList_New( 0 );
        }
        
        if( is_map( obj ) )
        {
            if( obj.as.map_size )
            {
                push_dict( obj.as.map_size );

                return nullptr;
            }

            return PyDict_New();
        }
            
        return read_simple( obj );
    }
示例#7
0
 void next()
 {
     const auto next_val = read_next(detail::has_read_next<stream_type>{}, ec);
     if (next_val) {
         val_ = *next_val;
     } else {
         done_ = true;
     }
 }
示例#8
0
 I read_prev() {
     assert(start_ <= position_ && position_ < end_);
     I result = read_next();
     if (position_ != 1 && _fseeki64(pFile, -2 * sizeof(I), SEEK_CUR) != 0) {
         perror("Error seek");
         exit(1);
     }
     position_-=2;
     return result;
 }
示例#9
0
文件: lib.c 项目: daveshields/AdaEd
int last_comp_index(IFILE *ifile)						/*;last_comp_index*/
{
	/* determine the number of comp units in ifile. */
    long	rec;
    int		i;

	i=0;
	for (rec=read_init(ifile); rec!=0; rec=read_next(ifile,rec)) i++; 
	return i;
}
示例#10
0
文件: areas.c 项目: imincik/pkg-grass
int extract_areas(void)
{
    double nullVal;

    row = col = top = 0;	/* get started for read of first */
    bottom = 1;			/* line from raster map */
    area_num = 0;
    tl_area = 0;

    G_set_d_null_value(&nullVal, 1);
    /* represents the "outside", the external null values */
    assign_area(nullVal, 0);

    G_message(_("Extracting areas..."));

    scan_length = read_next();
    while (read_next()) {	/* read rest of file, one row at *//*   a time */
	G_percent(row, n_rows, 2);

	for (col = 0; col < scan_length - 1; col++) {
	    tl = get_raster_value(buffer[top], col);	/* top left in window */
	    tr = get_raster_value(buffer[top], col + 1);	/* top right */
	    bl = get_raster_value(buffer[bottom], col);	/* bottom left */
	    br = get_raster_value(buffer[bottom], col + 1);	/* bottom right */
	    update_list(nabors());
	}

	if (h_ptr != NULPTR)	/* if we have a loose end, */
	    end_hline();	/*   tie it down */

	row++;
    }

    G_percent(row, n_rows, 2);

    write_area(a_list, e_list, area_num, n_equiv);

    G_free(a_list);
    G_free(e_list);

    return 0;
}				/* extract_areas */
示例#11
0
    nmea_port(boost::asio::io_service& io_service,
              std::string& port_name,
              unsigned int baud_rate)
        : m_serial(io_service),
          m_buffer(max_sentence_length)
    {
        m_serial.set_option(boost::asio::serial_port_base::baud_rate(baud_rate));
        m_serial.open(port_name);

        read_next();
    }
示例#12
0
char Read::ReadBit() {
    if (_bits_count_read / 8 > _buffer_in_size - 1) {
        read_next();
    }
    int bit_pos = _bits_count_read % 8;
    int byte_pos = _bits_count_read / 8;
    if (bit_pos == 0) {
        unsigned char answ = _buffer_in[byte_pos] >> 7;
        _bits_count_read++;
        return answ;
    }
示例#13
0
文件: json.cpp 项目: mzeric/parser
double match_digit(){
	char buf[128];
	int i = 0;
	do {
		look_ahead = read_next();
		buf[i++] = look_ahead;
	}while((look_ahead <='9' && look_ahead >='0') || look_ahead=='.');
	buf[i] = 0;
	match_space();

	return atof(buf);
}
示例#14
0
int FastqFile::read_next() {

    const int r = kseq_read(kseq);

    if (r == -1) {

        open_next();

        if (fnit != fnames.end()) return read_next();
    }

    return r;
}
示例#15
0
static void
md5_stream(lua_State *L, char *output) {
  WORD32 d[4];
  char tmp[64];
  size_t lastlen = 0;
  size_t len = 0;
  size_t total;
  lua_pushnil(L);	// read_next would pop 1
  const char * message = read_next(L, &len);
  if (message == NULL) {
    return md5("", 0, output);	// empty string
  }
  total = len;
  inic_digest(d);
  do {
    lastlen = md5_cat(tmp, lastlen,  message, len, d);
    message = read_next(L, &len);
    total += len;
  } while (message != NULL);

  md5_close(tmp, lastlen, d, total);
  word32tobytes(d, output);
}
示例#16
0
文件: json.cpp 项目: mzeric/parser
std::string match_str(){
	char buf[128];

	assert(look_ahead == '\"');
	memset(buf, 0, sizeof(buf));
	int i = 0;
	do {
		look_ahead = read_next();
		buf[i++] = look_ahead;
	}while(look_ahead != '\"');
	buf[i-1] = 0;
	match_space();

	return std::string(buf);
}
示例#17
0
    void handle_line(const boost::system::error_code& error, size_t bytes_received) {
        if(!error) {
            boost::asio::streambuf::const_buffers_type bufs = m_buffer.data();
            std::string line(boost::asio::buffers_begin(bufs),
                             boost::asio::buffers_begin(bufs) + bytes_received);

            std::cerr << "Sentence: " << line << std::endl;

            m_buffer.consume(bytes_received);

            read_next();
        } else {
            std::cerr << "Error: " << error << std::endl;
        }
    }
示例#18
0
 void assert_done()
 {
     bool err = false;
     try
     {
         read_next();
     }
     catch (...)
     {
         err = true;
     }
     if (err || parser_.state() != state::start)
     {
         err_handler_->error(std::error_code(json_parser_errc::extra_character, json_parser_category()), parser_.parsing_context());
     }
 }
示例#19
0
static Errcode read_first(Image_file *ifile, Rcel *screen)
/*****************************************************************************
 * Seek to the beginning of an open  file, and then read in the
 * first frame of image into screen.
 ****************************************************************************/
{
Ifile *gf = (Ifile *)ifile; 	/* There's a bit of data past ifile header */
Errcode err;

				/* skip past header & offset list */
if ((err = fseek(gf->file,
				 gf->rif.frame_count * sizeof(long) + sizeof(Riff_head),
				 SEEK_SET)) < Success)
	return(err);
return(read_next(ifile, screen));
}
示例#20
0
static void
read_hash(ParseInfo pi, const char *key) {
    const char	*ks;
    
    if (pi->has_hash_start) {
	call_no_value(pi->handler, oj_hash_start_id, key);
    }
    pi->s++;
    next_non_white(pi);
    if ('}' == *pi->s) {
	pi->s++;
    } else {
	while (1) {
	    next_non_white(pi);
	    ks = read_quoted_value(pi);
	    next_non_white(pi);
	    if (':' == *pi->s) {
		pi->s++;
	    } else {
		if (pi->has_error) {
		    call_error("invalid format, expected :", pi, __FILE__, __LINE__);
		}
		raise_error("invalid format, expected :", pi->str, pi->s);
	    }
	    read_next(pi, ks);
	    next_non_white(pi);
	    if ('}' == *pi->s) {
		pi->s++;
		break;
	    } else if (',' == *pi->s) {
		pi->s++;
	    } else {
		if (pi->has_error) {
		    call_error("invalid format, expected , or } while in an object", pi, __FILE__, __LINE__);
		}
		raise_error("invalid format, expected , or } while in an object", pi->str, pi->s);
	    }
	}
    }
    if (pi->has_hash_end) {
	call_no_value(pi->handler, oj_hash_end_id, key);
    }
}
示例#21
0
// returns >=0 (length of seq), -1 end of last file, -2 truncated quality string
int FastqFile::read_next(string &seq, size_t& id) {

    const int r = kseq_read(kseq);

    if (r >= 0) seq.assign(kseq->seq.s);
    else if (r == -1) {

        open_next();

        if (fnit != fnames.end()){

            id = file_no;

            return read_next(seq, id);
        }
    }

    return r;
}
示例#22
0
std::string
Avro2PBReader::read_next()
{
  if(!get_is_valid()){
    return "";
  }
  if(!avro_reader_){
    avro_reader_ = new t_avro_reader
      (avro_filenames_[cur_file_].c_str(),
       IMP::npctransport::get_avro_data_file_schema());
  }
  IMP_npctransport::wrapper data;

  if( ! (avro_reader_->read(data)) ){ // no more data = go to next
    advance_current_reader();
    return read_next();
  }
  return std::string(data.value.begin(), data.value.end());
}
示例#23
0
文件: stream.c 项目: EQ4/musicd
static int get_next(stream_t *stream)
{
  int result;
  if (stream->dst_codec_type) {
    do {
      result = encode_next(stream);
      if (result <= 0) {
        return result;
      }
    } while (stream->dst_size == 0);

    stream->data = stream->dst_data;
    stream->size = stream->dst_size;

  } else {
    result = read_next(stream);
    stream->data = stream->src_packet.data;
    stream->size = stream->src_packet.size;
  }
  return result;
}
示例#24
0
int Range::iterator::next_el(void) {
    if (file_handle) {
	// Assume a file type
	if ( read_next(&cur_value, file_handle, filename) == 0) {
	    atEnd = 1;
	}
    } else if (cur_node) {
	if (cur_value == cur_node->end) {
	    // Need to move on to next node
	    cur_node = cur_node->next;
	    if (cur_node) {
		cur_value = cur_node->start;
	    } else {
		cur_value = 0;
		atEnd = 1;
	    }
	} else {
	    cur_value += cur_node->step;
	}
    }
    return cur_value;
}
示例#25
0
// returns >=0 (length of seq), -1 end of last file, -2 truncated quality string
int FastqFile::read_next(char* read, size_t* read_len, string &seq, size_t* seq_len, unsigned int* file_id, char* qual) {

    int r;

    if ((r = kseq_read(kseq)) >= 0) {

        memcpy(read, kseq->name.s, kseq->name.l + 1); // 0-terminated string
        *read_len = kseq->name.l;
        seq.assign(kseq->seq.s);
        *seq_len = kseq->seq.l;

        if (qual != NULL) memcpy(qual, kseq->qual.s, kseq->qual.l + 1); // 0-terminated string
        if (file_id != NULL) *file_id = file_no / 2;
    }
    else if (r == -1) {

        open_next();

        if (fnit != fnames.end()) return read_next(read, read_len, seq, seq_len, file_id, qual);
        return -1;
    }

    return r;
}
示例#26
0
文件: serwer.c 项目: Solmis/SO
/* Funkcja obsługująca sesję z raportem */
void* serve_report(void* mesg_type)
{
    long msg_type = atol(mesg_type);
    long l = read_next(msg_type);
    long x, y, z, v;
    int i, j;
    long ** rows;

    if (l > 0)
    {
        rows = malloc(sizeof(long));
        rows[0] = malloc(sizeof(long) * K);
    }
    else
    {
        rows = malloc(sizeof(long) * L);

        for (i = 0; i < L; i++)
            rows[i] = malloc(sizeof(long) * K);
    }

    send_val(msg_snd_rap_id, msg_type, K);
    send_val(msg_snd_rap_id, msg_type, M);

    pthread_rwlock_rdlock(&rwlock);
    x = db.committees_served;
    y = db.could_vote;
    z = db.valid_votes;
    v = db.invalid_votes;

    if (l > 0)
    {
        for (i = 0; i < K; i++)
            rows[0][i] = db.votes[l-1][i];
    }
    else
    {
        for (i = 0; i < L; i++)
            for (j = 0; j < K; j++)
                rows[i][j] = db.votes[i][j];
    }
    pthread_rwlock_unlock(&rwlock);
    
    send_val(msg_snd_rap_id, msg_type, x);
    send_val(msg_snd_rap_id, msg_type, y);
    send_val(msg_snd_rap_id, msg_type, z);
    send_val(msg_snd_rap_id, msg_type, v);

    if (l > 0)
    {
        for (i = 0; i < K; i++)
            send_val(msg_snd_rap_id, msg_type, rows[0][i]);
    }
    else
    {
        for (i = 0; i < L; i++)
            for (j = 0; j < K; j++)
                send_val(msg_snd_rap_id, msg_type, rows[i][j]);
    }

    if (l > 0)
        free(rows[0]);
    else
    {
        for (i = 0; i < L; i++)
            free(rows[i]);
    }
    free(rows);

    return 0;
}
示例#27
0
文件: stream.c 项目: EQ4/musicd
static int decode_next(stream_t *stream)
{
  int result, got_frame;
  AVFrame *frame = stream->decode_frame;

  result = read_next(stream);
  if (result <= 0) {
    return result;
  }

  avcodec_get_frame_defaults(frame);

  result = avcodec_decode_audio4(stream->decoder, frame,
                                 &got_frame, &stream->src_packet);

  if (result < 0) {
    /* Decoding right after seeking, especially with mp3, might fail because
     * we don't have the frame header available yet. */
    ++stream->error_counter;
    musicd_log(LOG_VERBOSE, "stream", "can't decode: %s, error_counter = %d",
               strerror(AVUNERROR(result)), stream->error_counter);
    if (stream->error_counter > 10) {
      musicd_log(LOG_ERROR, "stream", "error_counter too high, failing: %s",
                 strerror(AVUNERROR(result)));
      return -1;
    }
    /* Technically we failed, but we are going to try again so make it look
     * like success... */
    return 1;
  }

  if (stream->error_counter) {
    musicd_log(LOG_VERBOSE, "stream", "recovered from error_counter = %d",
               stream->error_counter);
    stream->error_counter = 0;
  }

  if (!got_frame) {
    return 1;
  }

  if (stream->resampler) {
    if (stream->resample_frame->nb_samples < frame->nb_samples) {
      av_free(stream->resample_buf);

      int buf_size = av_samples_get_buffer_size(NULL,
                                                stream->encoder->channels,
                                                frame->nb_samples,
                                                stream->encoder->sample_fmt, 0);
      stream->resample_buf = av_mallocz(buf_size);
      stream->resample_frame->nb_samples = frame->nb_samples;
      result = avcodec_fill_audio_frame(stream->resample_frame,
                                        stream->encoder->channels,
                                        stream->encoder->sample_fmt,
                                        stream->resample_buf, buf_size, 0);
    }
    result = resampler_convert(stream->resampler,
                               stream->resample_frame->extended_data,
                               stream->resample_frame->nb_samples,
                               (const uint8_t **)frame->extended_data,
                               frame->nb_samples);

    av_audio_fifo_write(stream->src_buf,
                        (void **)stream->resample_frame->extended_data,
                        result);
  } else {
    av_audio_fifo_write(stream->src_buf,
                        (void **)frame->extended_data,
                        frame->nb_samples);
  }

  return 1;
}
示例#28
0
int main () {
	char line[40], *str, cmd, last_cmd = 0;

	if (!(ld = open_list ())) {
		fprintf (stderr, "Error opening List\n");
		exit (1);
	}
	printf ("Type \'-?\' or \'-h\' for Help contents\n");
	while (1) {
		printf ("list> ");
		fgets (line, 40, stdin);
		for (str = line; *str ==  ' ' || *str == '\t'; str++)
			;
		str[strchr (str, '\n') - str] = '\0';

		switch (*str) {
		case '\0' : continue;
		default :
			append (ld, str);
			break;
		case '.' : 
			cmd = last_cmd;
		case '-' :
			if (*str != '.') cmd = last_cmd = *++str;
			switch (cmd) {
			default : 
				fprintf (stderr, "Invalid Command\n");
				continue;
			case '?' : case 'h' : case 'H' :
				printf ("Type any name to add to list\n"
					"-r<name> to remove from list\n"
					"\'-d\' to display all list items\n"
					"\'-f\' to print the first item in list\n"
					"\'-l\' to print the last item in list\n"
					"\'-n\' to print the next list item\n"
					"\'-p\' to print the previous list item\n"
					"\'.\' to repeat last command\n"
					//"\'-s\' to sort list items\n"
					"\'-e\' to exit\n");
				break;
			case 'd' : case 'D' :
				print_list (ld);
				break;
			case 'f' : case 'F' :
				if (read_first (ld, str)) PRINT_MSG
			case 'l' : case 'L' :
				if (read_last (ld, str)) PRINT_MSG
			case 'n' : case 'N' :
				if (read_next (ld, str)) PRINT_MSG
			case 'p' : case 'P' :
				if (read_prev (ld, str)) PRINT_MSG
			case 'r' : case 'R' :
				if (delete (ld, ++str)) {
					fprintf (stderr, "%s not on list\n", str);
					continue;
				} else printf ("%s removed\n", str);
				break;
			case 'e' : case 'E' :
				print_list (ld);
				close_list (ld);
				printf ("===> End of App <===\n");
				exit (0);
			}
		}
	}
}
示例#29
0
message_part_deserialize_part(struct deserialize_context *ctx,
			      struct message_part *parent,
			      unsigned int siblings,
			      struct message_part **part_r)
{
	struct message_part *p, *part, *first_part, **next_part;
	unsigned int children_count;
	uoff_t pos;
	bool root = parent == NULL;

	first_part = NULL;
	next_part = NULL;
	while (siblings > 0) {
		siblings--;

		part = p_new(ctx->pool, struct message_part, 1);
		part->parent = parent;
		for (p = parent; p != NULL; p = p->parent)
			p->children_count++;

		if (!read_next(ctx, &part->flags, sizeof(part->flags)))
			return FALSE;

		if (root)
			root = FALSE;
		else {
			if (!read_next(ctx, &part->physical_pos,
				       sizeof(part->physical_pos)))
				return FALSE;
		}

		if (part->physical_pos < ctx->pos) {
			ctx->error = "physical_pos less than expected";
			return FALSE;
		}

		if (!read_next(ctx, &part->header_size.physical_size,
			       sizeof(part->header_size.physical_size)))
			return FALSE;

		if (!read_next(ctx, &part->header_size.virtual_size,
			       sizeof(part->header_size.virtual_size)))
			return FALSE;

		if (part->header_size.virtual_size <
		    part->header_size.physical_size) {
			ctx->error = "header_size.virtual_size too small";
			return FALSE;
		}

		if (!read_next(ctx, &part->body_size.physical_size,
			       sizeof(part->body_size.physical_size)))
			return FALSE;

		if (!read_next(ctx, &part->body_size.virtual_size,
			       sizeof(part->body_size.virtual_size)))
			return FALSE;

		if ((part->flags & (MESSAGE_PART_FLAG_TEXT |
				    MESSAGE_PART_FLAG_MESSAGE_RFC822)) != 0) {
			if (!read_next(ctx, &part->body_size.lines,
				       sizeof(part->body_size.lines)))
				return FALSE;
		}

		if (part->body_size.virtual_size <
		    part->body_size.physical_size) {
			ctx->error = "body_size.virtual_size too small";
			return FALSE;
		}

		if ((part->flags & (MESSAGE_PART_FLAG_MULTIPART |
				    MESSAGE_PART_FLAG_MESSAGE_RFC822)) != 0) {
			if (!read_next(ctx, &children_count,
				       sizeof(children_count)))
				return FALSE;
		} else {
                        children_count = 0;
		}

		if (part->flags & MESSAGE_PART_FLAG_MESSAGE_RFC822) {
			/* Only one child is possible */
			if (children_count == 0) {
				ctx->error =
					"message/rfc822 part has no children";
				return FALSE;
			}
			if (children_count != 1) {
				ctx->error = "message/rfc822 part "
					"has multiple children";
				return FALSE;
			}
		}

		if (children_count > 0) {
			/* our children must be after our physical_pos+header
			   and the last child must be within our size. */
			ctx->pos = part->physical_pos +
				part->header_size.physical_size;
			pos = ctx->pos + part->body_size.physical_size;

			if (!message_part_deserialize_part(ctx, part,
							   children_count,
							   &part->children))
				return FALSE;

			if (ctx->pos > pos) {
				ctx->error =
					"child part location exceeds our size";
				return FALSE;
			}
			ctx->pos = pos; /* save it for above check for parent */
		}

		if (first_part == NULL)
			first_part = part;
		if (next_part != NULL)
			*next_part = part;
		next_part = &part->next;
	}

	*part_r = first_part;
	return TRUE;
}
示例#30
0
 // Deprecated
 void read()
 {
     read_next();
 }