自学教程：C++ stream_close函数代码示例

int main(int argc, char *argv[]){	char*gcf_name;	archive_t gcf=NULL;	RTinitPopt(&argc,&argv,options,1,-1,&gcf_name,NULL,"([-c] <gcf> (<dir>|<file>)*) | (-x <gcf> [<dir>|<pattern>])",		"Tool for creating and extracting GCF archives/n/nOptions");	compression_policy_compile(policy);	if (operation==GCF_EXTRACT) {		char *out_name=RTinitNextArg();		archive_t dir;		if(out_name){			if(RTinitNextArg()){				Fatal(1,error,"extraction uses gcf -x <gcf> [<dir>|<pattern>]");			}			if (strstr(out_name,"%s")) {				dir=arch_fmt(out_name,file_input,file_output,blocksize);			} else {				dir=arch_dir_create(out_name,blocksize,force?DELETE_ALL:DELETE_NONE);			}		} else {			dir=arch_dir_open(".",blocksize);		}		if (is_a_dir(gcf_name)){			gcf=arch_dir_open(gcf_name,blocksize);		} else {			gcf=arch_gcf_read(raf_unistd(gcf_name));		}		archive_copy(gcf,"auto",dir,NULL,blocksize);		arch_close(&dir);		arch_close(&gcf);	} else {		if (operation==GCF_FILE){			gcf=arch_gcf_create(raf_unistd(gcf_name),blocksize,blocksize*blockcount,0,1);		} else {			gcf=arch_dir_create(gcf_name,blocksize,force?DELETE_ALL:DELETE_NONE);		}		for(;;){			char *input_name=RTinitNextArg();			if (!input_name) break;			if (is_a_dir(input_name)){				Warning(info,"copying contents of %s",input_name);				archive_t dir=arch_dir_open(input_name,blocksize);				archive_copy(dir,NULL,gcf,get_compression,blocksize);				arch_close(&dir);			} else {				Warning(info,"copying %s",input_name);				stream_t is=file_input(input_name);				stream_t os=arch_write(gcf,input_name,get_compression(input_name),1);				char buf[blocksize];				for(;;){					int len=stream_read_max(is,buf,blocksize);					if (len) stream_write(os,buf,len);					if(len<blocksize) break;				}				stream_close(&is);				stream_close(&os);				}		}		arch_close(&gcf);	}}

static void gcf_compress(){    char*source;    char target[LTSMIN_PATHNAME_MAX];    while((source=HREnextArg())){        if (is_a_file(source)){            sprintf(target,"%s.gzf",source);            stream_t is=file_input(source);            stream_t os=file_output(target);            char *code=SSMcall(compression_policy,source);            DSwriteS(os,code);            os=stream_add_code(os,code);            char buf[blocksize];            for(;;){                int len=stream_read_max(is,buf,blocksize);                if (len) stream_write(os,buf,len);                if(len<blocksize) break;            }            stream_close(&is);            stream_close(&os);            if (!keep) recursive_erase(source);        } else if (is_a_dir(source)){            sprintf(target,"%s.gcf",source);            archive_t arch_in=arch_dir_open(source,blocksize);            archive_t arch_out=arch_gcf_create(raf_unistd(target),blocksize,blocksize*blockcount,0,1);            archive_copy(arch_in,arch_out,compression_policy,blocksize,NULL);            arch_close(&arch_in);            arch_close(&arch_out);            if (!keep) recursive_erase(source);        } else {            Abort("source %s is neither a file nor a directory",source);        }    }}

/* Model terminate function */void omni_interface_terminate(void){  /* S-Function Block: omni_interface/HIL Initialize (hil_initialize_block) */  {    t_boolean is_switching;    t_int result;    hil_task_stop_all(omni_interface_DWork.HILInitialize_Card);    hil_task_delete_all(omni_interface_DWork.HILInitialize_Card);    is_switching = false;    if ((omni_interface_P.HILInitialize_POTerminate && !is_switching) ||        (omni_interface_P.HILInitialize_POExit && is_switching)) {      omni_interface_DWork.HILInitialize_POValues[0] =        omni_interface_P.HILInitialize_POFinal;      omni_interface_DWork.HILInitialize_POValues[1] =        omni_interface_P.HILInitialize_POFinal;      omni_interface_DWork.HILInitialize_POValues[2] =        omni_interface_P.HILInitialize_POFinal;      result = hil_write_pwm(omni_interface_DWork.HILInitialize_Card,        &omni_interface_P.HILInitialize_POChannels[0], 3U,        &omni_interface_DWork.HILInitialize_POValues[0]);      if (result < 0) {        msg_get_error_messageA(NULL, result, _rt_error_message, sizeof          (_rt_error_message));        rtmSetErrorStatus(omni_interface_M, _rt_error_message);      }    }    hil_close(omni_interface_DWork.HILInitialize_Card);    omni_interface_DWork.HILInitialize_Card = NULL;  }  /* S-Function Block: omni_interface/Stream Answer (stream_answer_block) */  {    if (omni_interface_DWork.StreamAnswer_Client != NULL) {      stream_close(omni_interface_DWork.StreamAnswer_Client);      omni_interface_DWork.StreamAnswer_Client = NULL;    }    if (omni_interface_DWork.StreamAnswer_Listener != NULL) {      stream_close(omni_interface_DWork.StreamAnswer_Listener);      omni_interface_DWork.StreamAnswer_Listener = NULL;    }  }  /* S-Function Block: omni_interface/Stream Answer1 (stream_answer_block) */  {    if (omni_interface_DWork.StreamAnswer1_Client != NULL) {      stream_close(omni_interface_DWork.StreamAnswer1_Client);      omni_interface_DWork.StreamAnswer1_Client = NULL;    }    if (omni_interface_DWork.StreamAnswer1_Listener != NULL) {      stream_close(omni_interface_DWork.StreamAnswer1_Listener);      omni_interface_DWork.StreamAnswer1_Listener = NULL;    }  }  /* External mode */  rtExtModeShutdown(1);}

static void gcf_create(){    char *gcf_name=HREnextArg();    if (gcf_name==NULL) {        Abort("missing <gcf archive> argument");    }    archive_t arch=arch_gcf_create(raf_unistd(gcf_name),blocksize,blocksize*blockcount,0,1);    char*file;    while((file=HREnextArg())){        if (is_a_file(file)){            stream_t is=file_input(file);            stream_t os=arch_write_apply(arch,file,SSMcall(compression_policy,file));            char buf[blocksize];            for(;;){                int len=stream_read_max(is,buf,blocksize);                if (len) stream_write(os,buf,len);                if(len<blocksize) break;            }            stream_close(&is);            stream_close(&os);        } else {            Abort("cannot add %s because it is not a file",file);        }    }    arch_close(&arch);}

static intauth_lookuprecord(char *server, struct srvrecord *auth){	char *home, *line, authfile[FILENAME_MAX];	struct stream *s;	int linenum = 0, error;	home = getenv("HOME");	if (home == NULL) {		lprintf(-1, "Environment variable /"HOME/" is not set/n");		return (STATUS_FAILURE);	}	snprintf(authfile, sizeof(authfile), "%s/%s", home, AUTHFILE);	s = stream_open_file(authfile, O_RDONLY);	if (s == NULL) {		lprintf(-1, "Could not open file %s/n", authfile);		return (STATUS_FAILURE);	}	while ((line = stream_getln(s, NULL)) != NULL) {		linenum++;		if (line[0] == '#' || line[0] == '/0')			continue;		error = auth_parsetoken(&line, auth->server,		    sizeof(auth->server));		if (error != STATUS_SUCCESS) {			lprintf(-1, "%s:%d Missing client name/n", authfile, linenum);			goto close;		}		/* Skip the rest of this line, it isn't what we are looking for. */		if (strcasecmp(auth->server, server) != 0)			continue;		error = auth_parsetoken(&line, auth->client,		    sizeof(auth->client));		if (error != STATUS_SUCCESS) {			lprintf(-1, "%s:%d Missing password/n", authfile, linenum);			goto close;		}		error = auth_parsetoken(&line, auth->password,		    sizeof(auth->password));		if (error != STATUS_SUCCESS) {			lprintf(-1, "%s:%d Missing comment/n", authfile, linenum);			goto close;		}		stream_close(s);		lprintf(2, "Found authentication record for server /"%s/"/n",		    server);		return (STATUS_SUCCESS);	}	lprintf(-1, "Unknown server /"%s/". Fix your %s/n", server , authfile);	memset(auth->password, 0, sizeof(auth->password));close:	stream_close(s);	return (STATUS_FAILURE);}

static void vrt_rdev_close_superblock_streams(vrt_realdev_t *rdev){    int i;    for (i = 0; i < 2; i++)    {        stream_close(rdev->checksum_sb_streams[i]);        stream_close(rdev->sb_data_streams[i]);    }    stream_close(rdev->raw_sb_stream);}

alsa_midi_t* alsa_rawmidi_new(jack_client_t *jack){    alsa_rawmidi_t *midi = calloc(1, sizeof(alsa_rawmidi_t));    if (!midi)        goto fail_0;    midi->client = jack;    if (pipe(midi->scan.wake_pipe)==-1) {        error_log("pipe() in alsa_midi_new failed: %s", strerror(errno));        goto fail_1;    }    if (stream_init(&midi->in, midi, "in"))        goto fail_2;    midi->in.mode = POLLIN;    midi->in.port_size = sizeof(input_port_t);    midi->in.port_init = input_port_init;    midi->in.port_close = input_port_close;    midi->in.process_jack = do_jack_input;    midi->in.process_midi = do_midi_input;    if (stream_init(&midi->out, midi, "out"))        goto fail_3;    midi->out.mode = POLLOUT;    midi->out.port_size = sizeof(output_port_t);    midi->out.port_init = output_port_init;    midi->out.port_close = output_port_close;    midi->out.process_jack = do_jack_output;    midi->out.process_midi = do_midi_output;    midi->ops.destroy = alsa_rawmidi_delete;    midi->ops.attach = alsa_rawmidi_attach;    midi->ops.detach = alsa_rawmidi_detach;    midi->ops.start = alsa_rawmidi_start;    midi->ops.stop = alsa_rawmidi_stop;    midi->ops.read = alsa_rawmidi_read;    midi->ops.write = alsa_rawmidi_write;    midi->midi_in_cnt = 0;    midi->midi_out_cnt = 0;    return &midi->ops;fail_3:    stream_close(&midi->out);fail_2:    stream_close(&midi->in);    close(midi->scan.wake_pipe[1]);    close(midi->scan.wake_pipe[0]);fail_1:    free(midi);fail_0:    return NULL;}

staticvoid alsa_rawmidi_delete(alsa_midi_t *m){    alsa_rawmidi_t *midi = (alsa_rawmidi_t*)m;    alsa_rawmidi_detach(m);    stream_close(&midi->out);    stream_close(&midi->in);    close(midi->scan.wake_pipe[0]);    close(midi->scan.wake_pipe[1]);    free(midi);}

void cdc_acmd_destroy(CDC_ACMD* cdc_acmd){    io_destroy(cdc_acmd->notify);    io_destroy(cdc_acmd->rx);    stream_close(cdc_acmd->rx_stream_handle);    stream_destroy(cdc_acmd->rx_stream);    io_destroy(cdc_acmd->tx);    stream_close(cdc_acmd->tx_stream_handle);    stream_destroy(cdc_acmd->tx_stream);    free(cdc_acmd);}

static void read_test(void *v_t){	struct read_test *t = v_t;	enum stream_result sres;	ssize_t res;	switch (t->step) {	case 0:		t->stream = delim_read_next(t->dr);		t->pos = 0;	STEP:		res = read_some(t, 8);		if (res == STREAM_WAITING)			return;		assert(res == 7);		assert(!memcmp(t->buf, "hello, ", 7));	STEP:		sres = stream_close(t->stream, &t->tasklet, &t->err);		if (sres == STREAM_WAITING)			return;		assert(sres == STREAM_OK);		stream_destroy(t->stream);		t->stream = delim_read_next(t->dr);		t->pos = 0;	STEP:		res = read_some(t, 7);		if (res == STREAM_WAITING)			return;		assert(res == 6);		assert(!memcmp(t->buf, "world!", 6));	STEP:		sres = stream_close(t->stream, &t->tasklet, &t->err);		if (sres == STREAM_WAITING)			return;		assert(sres == STREAM_OK);		stream_destroy(t->stream);	}	tasklet_stop(&t->tasklet);	application_stop();}

ut_cleanup(){    int i;    stream_close(stream);    stream_close(memory_stream);    rain1_group_free(rxg, sto);    storage_free(sto);    for (i = 0; i < NUM_SPOF_GROUPS; i++)        os_free(rdevs[i]);    os_random_cleanup();}

int config_parse_file(server *srv, config_t *context, const char *fn) {    tokenizer_t t;    stream s;    int ret;    buffer *filename;    if (buffer_is_empty(context->basedir) ||            (fn[0] == '/' || fn[0] == '//') ||            (fn[0] == '.' && (fn[1] == '/' || fn[1] == '//'))) {        filename = buffer_init_string(fn);    } else {        filename = buffer_init_buffer(context->basedir);        buffer_append_string(filename, fn);    }    if (0 != stream_open(&s, filename)) {        if (s.size == 0) {            /* the file was empty, nothing to parse */            ret = 0;        } else {            log_error_write(srv, __FILE__, __LINE__, "sbss",                            "opening configfile ", filename, "failed:", strerror(errno));            ret = -1;        }    } else {        tokenizer_init(&t, filename, s.start, s.size);        ret = config_parse(srv, context, &t);    }    stream_close(&s);    buffer_free(filename);    return ret;}

int downloadData(){  char device[255];  sprintf(device, "/dev/tcp/%s/80", "netdata.be");  char headers[255];  sprintf(headers, "GET /loxone/test2.php HTTP/1.1/r/nHost: %s/r/nUser-Agent: LoxLIVE [en]/r/nContent-Type: text/html; charset=utf-8/r/n/r/n",  "netdata.be");  STREAM* tcpStream = stream_create(device, 0, 0);  stream_write(tcpStream, headers, strlen(headers));  stream_flush(tcpStream);  char block[RD_BLOCK_SIZE];  int count;  int i = 0;  // read stream  do  {    count = stream_read(tcpStream, block, RD_BLOCK_SIZE, 4000);    if (count > 0) strncpy((char*)buffer + i * RD_BLOCK_SIZE, block, count);    i++;    if (i >= ( ( MAX_BUFF - 1 ) / RD_BLOCK_SIZE )) count=0; // avoid buffer overflows  }  while (count > 0);  stream_close(tcpStream);  buffer[MAX_BUFF] = 0; //put null character or end of string at the end.  return 0;}

static void ti85b_file_exit(imgtool_image * img){	ti85b_file *file=(ti85b_file*)img;	stream_close(file->file_handle);	free(file->data);	free(file);}

static imgtoolerr_t ascii_writefile(imgtool_partition *partition, const char *filename, const char *fork, imgtool_stream *sourcef, option_resolution *opts){	imgtoolerr_t err;	imgtool_stream *mem_stream = NULL;	const char *eoln;	/* create a stream */	mem_stream = stream_open_mem(NULL, 0);	if (!mem_stream)	{		err = IMGTOOLERR_OUTOFMEMORY;		goto done;	}	eoln = imgtool_partition_get_info_string(partition, IMGTOOLINFO_STR_EOLN);	err = convert_stream_eolns(sourcef, mem_stream, eoln);	if (err)		goto done;	stream_seek(mem_stream, SEEK_SET, 0);	err = imgtool_partition_write_file(partition, filename, fork, mem_stream, opts, NULL);	if (err)		goto done;done:	if (mem_stream)		stream_close(mem_stream);	return err;}

static imgtoolerr_t ascii_readfile(imgtool_partition *partition, const char *filename, const char *fork, imgtool_stream *destf){	imgtoolerr_t err;	imgtool_stream *mem_stream;	mem_stream = stream_open_mem(NULL, 0);	if (!mem_stream)	{		err = IMGTOOLERR_OUTOFMEMORY;		goto done;	}	err = imgtool_partition_read_file(partition, filename, fork, mem_stream, NULL);	if (err)		goto done;	stream_seek(mem_stream, SEEK_SET, 0);	err = convert_stream_eolns(mem_stream, destf, EOLN);	if (err)		goto done;done:	if (mem_stream)		stream_close(mem_stream);	return err;}

/* -1: connection got closed, 0: nothing to read, n: read n bytes */gssize stream_read(server *srv, stream *s, char *buf, gssize bufsize) {	gssize len;	while (-1 == (len = read(s->fd, buf, bufsize))) {		switch (errno) {		case EAGAIN:#if EWOULDBLOCK != EAGAIN		case EWOULDBLOCK:#endif			/* nothing to read */			return 0;		case ECONNRESET:			return stream_closed(srv, s);		case EINTR: /* try again */			break;		default:			g_message("read error: %s", g_strerror(errno));			stream_close(srv, s, s->other);			return -1;		}	}	if (0 == len) { /* connection closed */		return stream_closed(srv, s);	}	return len;}

static void vmsx_gm2_image_exit(imgtool_image *img){    GM2_IMAGE *image=(GM2_IMAGE*)img;    stream_close(image->file_handle);    free(image->data);    free(image);}

static imgtoolerr_t write_fork(imgtool_partition *partition, const char *filename, const char *fork,	imgtool_stream *sourcef, UINT64 pos, UINT64 fork_len, option_resolution *opts){	imgtoolerr_t err = IMGTOOLERR_SUCCESS;	imgtool_stream *mem_stream = NULL;	size_t len;	if (fork_len > 0)	{		mem_stream = stream_open_mem(NULL, 0);		if (!mem_stream)		{			err = IMGTOOLERR_OUTOFMEMORY;			goto done;		}		stream_seek(sourcef, pos, SEEK_SET);		len = stream_transfer(mem_stream, sourcef, fork_len);		if (len < fork_len)			stream_fill(mem_stream, 0, fork_len);		stream_seek(mem_stream, 0, SEEK_SET);		err = imgtool_partition_write_file(partition, filename, fork, mem_stream, opts, NULL);		if (err)			goto done;	}done:	if (mem_stream)		stream_close(mem_stream);	return err;}

int main(int argc, char* argv[]){  size_t n = 0x200000;  double rate = 1;  zfp_field* field;  uint insize;  zfp_stream* zfp;  bitstream* stream;  void* buffer;  size_t bytes;  clock_t c;  double time;  uint i;  switch (argc) {    case 3:      sscanf(argv[2], "%zu", &n);      /* FALLTHROUGH */    case 2:      sscanf(argv[1], "%lf", &rate);      break;  }  /* declare array to compress */  field = zfp_field_3d(NULL, zfp_type_double, 4, 4, 4 * n);  insize = n * sizeof(block);  /* allocate storage for compressed bit stream */  zfp = zfp_stream_open(NULL);  zfp_stream_set_rate(zfp, rate, zfp_field_type(field), zfp_field_dimensionality(field), 0);  bytes = zfp_stream_maximum_size(zfp, field);  buffer = malloc(bytes);  stream = stream_open(buffer, bytes);  zfp_stream_set_bit_stream(zfp, stream);  zfp_field_free(field);  /* compress */  c = clock();  for (i = 0; i < n; i++)    zfp_encode_block_double_3(zfp, (const double*)block);  zfp_stream_flush(zfp);  time = (double)(clock() - c) / CLOCKS_PER_SEC;  printf("encode in=%u out=%u %.0f MB/s/n", insize, (uint)stream_size(stream), insize / (1024 * 1024 * time));  /* decompress */  zfp_stream_rewind(zfp);  c = clock();  for (i = 0; i < n; i++) {    double a[64];    zfp_decode_block_double_3(zfp, a);  }  time = (double)(clock() - c) / CLOCKS_PER_SEC;  printf("decode in=%u out=%u %.0f MB/s/n", (uint)stream_size(stream), insize, insize / (1024 * 1024 * time));  zfp_stream_close(zfp);  stream_close(stream);  free(buffer);  return 0;}

int main(int argc, char **argv){	int ret;	/* validate arguments */	if ( argc != 2 ){		fprintf(stderr, "usage: %s FILENAME/n", argv[0]);		return 1;	}	/* load tracefile address */	const char* filename = argv[1];	stream_addr_t addr = STREAM_ADDR_INITIALIZER;	stream_addr_str(&addr, filename, 0);	/* open stream */	stream_t stream;	if ( (ret=stream_open(&stream, &addr, NULL, 0)) != 0 ){		fprintf(stderr, "%s: %s/n", filename, caputils_error_string(ret));		return ret;	}	/* read packets */	while ( stream_read_cb(stream, handle_packet, NULL, NULL) == 0 );	/* close stream */	stream_close(stream);	return 0;}

// Update the tranfer state with new informationstatic void transfer_stream_data(uint32_t sector, const uint8_t *data, uint32_t size){    error_t status;    vfs_mngr_printf("vfs_manager transfer_stream_data(sector=%i, size=%i)/r/n", sector, size);    vfs_mngr_printf("    size processed=0x%x, data=%x,%x,%x,%x,.../r/n",                    file_transfer_state.size_processed, data[0], data[1], data[2], data[3]);    if (file_transfer_state.stream_finished) {        util_assert(0);        return;    }    util_assert(size % VFS_SECTOR_SIZE == 0);    util_assert(file_transfer_state.stream_open);    status = stream_write((uint8_t *)data, size);    vfs_mngr_printf("    stream_write ret=%i/r/n", status);    if (ERROR_SUCCESS_DONE == status) {        // Override status so ERROR_SUCCESS_DONE        // does not get passed into transfer_update_state        status = stream_close();        vfs_mngr_printf("    stream_close ret=%i/r/n", status);        file_transfer_state.stream_open = false;        file_transfer_state.stream_finished = true;        file_transfer_state.stream_optional_finish = true;    } else if (ERROR_SUCCESS_DONE_OR_CONTINUE == status) {        status = ERROR_SUCCESS;        file_transfer_state.stream_optional_finish = true;    } else {        file_transfer_state.stream_optional_finish = false;    }    file_transfer_state.size_processed += size;    transfer_update_state(status);}

TODOLIST *parse_todolist(char *source, size_t length) {  TODOLIST *list = NULL;  STREAM *input = stream_buffer(source, length);  list = read_todolist(input);  stream_close(input);  return list;}

intmain(void){  struct stream *s;  CURL *curl;  CURLcode res;  s = stream_new(ZOUT);  stream_open(s, Z_BEST_COMPRESSION);  curl_global_init(CURL_GLOBAL_ALL);  curl = curl_easy_init();  curl_easy_setopt(curl, CURLOPT_URL, ZURL);  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);  curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *) s);  res = curl_easy_perform(curl);  if (res != CURLE_OK)    fprintf(stderr, "error: %s/n", curl_easy_strerror(res));  stream_close(s);  if (s->error)    fprintf(stderr, "error: stream is invalid/n");  curl_easy_cleanup(curl);  curl_global_cleanup();  stream_del(s);  return 0;}

void stream_deinit(struct _libstream_stream* stream) {  stream_close(stream);  sem_destroy(&stream->download);  curl_easy_cleanup(stream->handle);  queue_deinit(&stream->buffer);  return;}

mp_lexer_t *mp_lexer_new(qstr src_name, void *stream_data, mp_lexer_stream_next_byte_t stream_next_byte, mp_lexer_stream_close_t stream_close) {    mp_lexer_t *lex = m_new_obj_maybe(mp_lexer_t);    // check for memory allocation error    if (lex == NULL) {        if (stream_close) {            stream_close(stream_data);        }        return NULL;    }    lex->source_name = src_name;    lex->stream_data = stream_data;    lex->stream_next_byte = stream_next_byte;    lex->stream_close = stream_close;    lex->line = 1;    lex->column = 1;    lex->emit_dent = 0;    lex->nested_bracket_level = 0;    lex->alloc_indent_level = MICROPY_ALLOC_LEXER_INDENT_INIT;    lex->num_indent_level = 1;    lex->indent_level = m_new_maybe(uint16_t, lex->alloc_indent_level);    vstr_init(&lex->vstr, 32);    // check for memory allocation error    if (lex->indent_level == NULL || vstr_had_error(&lex->vstr)) {        mp_lexer_free(lex);        return NULL;    }    // store sentinel for first indentation level    lex->indent_level[0] = 0;    // preload characters    lex->chr0 = stream_next_byte(stream_data);    lex->chr1 = stream_next_byte(stream_data);    lex->chr2 = stream_next_byte(stream_data);    // if input stream is 0, 1 or 2 characters long and doesn't end in a newline, then insert a newline at the end    if (lex->chr0 == MP_LEXER_EOF) {        lex->chr0 = '/n';    } else if (lex->chr1 == MP_LEXER_EOF) {        if (lex->chr0 == '/r') {            lex->chr0 = '/n';        } else if (lex->chr0 != '/n') {            lex->chr1 = '/n';        }    } else if (lex->chr2 == MP_LEXER_EOF) {        if (lex->chr1 == '/r') {            lex->chr1 = '/n';        } else if (lex->chr1 != '/n') {            lex->chr2 = '/n';        }    }    // preload first token    mp_lexer_next_token_into(lex, true);    return lex;}

/* Connects to a fake_pvconn with vconn_open(), accepts that connection and * closes it immediately, and verifies that vconn_connect() reports * 'expected_error'. */static voidtest_accept_then_close(struct ovs_cmdl_context *ctx){    const char *type = ctx->argv[1];    struct fake_pvconn fpv;    struct vconn *vconn;    int error;    fpv_create(type, &fpv);    CHECK_ERRNO(vconn_open(fpv.vconn_name, 0, DSCP_DEFAULT, &vconn), 0);    vconn_run(vconn);    stream_close(fpv_accept(&fpv));    fpv_close(&fpv);    error = vconn_connect_block(vconn);    if (!strcmp(type, "tcp") || !strcmp(type, "unix")) {        if (error != ECONNRESET && error != EPIPE#ifdef _WIN32            && error != WSAECONNRESET#endif            ) {            ovs_fatal(0, "unexpected vconn_connect() return value %d (%s)",                      error, ovs_strerror(error));        }    } else {        CHECK_ERRNO(error, EPROTO);    }    vconn_close(vconn);    fpv_destroy(&fpv);}

/* -1: connection closed, n: wrote n bytes */gssize stream_write(server *srv, stream *s) {	gssize len;	while (-1 == (len = write(s->fd, s->buffer->str, s->buffer->len))) {		switch (errno) {		case EAGAIN:#if EWOULDBLOCK != EAGAIN		case EWOULDBLOCK:#endif			/* try again later */			return 0;		case ECONNRESET:		case EPIPE:			return stream_closed(srv, s);		case EINTR: /* try again */			break;		default:			g_message("write error: %s", g_strerror(errno));			stream_close(srv, s, s->other);			return -1;		}	}	g_string_erase(s->buffer, 0, len);	if (s->buffer->len == 0) {		if (s->other->closed) return stream_closed(srv, s);		ev_io_rem_events(srv->loop, &s->watcher, EV_WRITE);	}	if (s->buffer->len < MAX_STREAM_BUF_SIZE && !s->other->closed)		ev_io_add_events(srv->loop, &s->other->watcher, EV_READ);	return 0;}