int PREFIX(fgetc) (const int * unit, char * c, gfc_charlen_type c_len) { int ret; gfc_unit * u = find_unit (*unit); if (u == NULL) return -1; fbuf_reset (u); if (u->mode == WRITING) { sflush (u->s); u->mode = READING; } memset (c, ' ', c_len); ret = sread (u->s, c, 1); unlock_unit (u); if (ret < 0) return ret; if (ret != 1) return -1; else return 0; }
/* Write the file (if necessary) and page headers. */ private void ps_image_write_headers(FILE *f, gx_device_printer *pdev, const char *const setup[], gx_device_pswrite_common_t *pdpc) { if (gdev_prn_file_is_new(pdev)) { gs_rect bbox; bbox.p.x = 0; bbox.p.y = 0; bbox.q.x = pdev->width / pdev->HWResolution[0] * 72.0; bbox.q.y = pdev->height / pdev->HWResolution[1] * 72.0; psw_begin_file_header(f, (gx_device *)pdev, &bbox, pdpc, false); psw_print_lines(f, setup); psw_end_file_header(f); } { byte buf[100]; /* arbitrary */ stream s; s_init(&s, pdev->memory); swrite_file(&s, f, buf, sizeof(buf)); psw_write_page_header(&s, (gx_device *)pdev, pdpc, true, pdev->PageCount + 1, 10); sflush(&s); } }
/* <file> flushfile - */ static int zflushfile(i_ctx_t *i_ctx_p) { os_ptr op = osp; stream *s; int status; check_type(*op, t_file); /* * We think flushfile is a no-op on closed input files, but causes an * error on closed output files. */ if (file_is_invalid(s, op)) { if (r_has_attr(op, a_write)) return_error(e_invalidaccess); pop(1); return 0; } status = sflush(s); if (status == 0 || status == EOFC) { pop(1); return 0; } return (s_is_writing(s) ? handle_write_status(i_ctx_p, status, op, NULL, zflushfile) : handle_read_status(i_ctx_p, status, op, NULL, zflushfile)); }
void srv(Srv *srv) { Req *r; fmtinstall('D', dirfmt); fmtinstall('F', fcallfmt); if(srv->fpool == nil) srv->fpool = allocfidpool(srv->destroyfid); if(srv->rpool == nil) srv->rpool = allocreqpool(srv->destroyreq); if(srv->msize == 0) srv->msize = 8192+IOHDRSZ; changemsize(srv, srv->msize); srv->fpool->srv = srv; srv->rpool->srv = srv; while(r = getreq(srv)){ if(r->error){ respond(r, r->error); continue; } switch(r->ifcall.type){ default: respond(r, "unknown message"); break; case Tversion: sversion(srv, r); break; case Tauth: sauth(srv, r); break; case Tattach: sattach(srv, r); break; case Tflush: sflush(srv, r); break; case Twalk: swalk(srv, r); break; case Topen: sopen(srv, r); break; case Tcreate: screate(srv, r); break; case Tread: sread(srv, r); break; case Twrite: swrite(srv, r); break; case Tclunk: sclunk(srv, r); break; case Tremove: sremove(srv, r); break; case Tstat: sstat(srv, r); break; case Twstat: swstat(srv, r); break; } } free(srv->rbuf); srv->rbuf = nil; free(srv->wbuf); srv->wbuf = nil; srv->msize = 0; freefidpool(srv->fpool); srv->fpool = nil; freereqpool(srv->rpool); srv->rpool = nil; if(srv->end) srv->end(srv); }
/* Procedures for writing on a file */ static int s_fileno_write_seek(stream * s, long pos) { /* We must flush the buffer to reposition. */ int code = sflush(s); if (code < 0) return code; if (lseek(sfileno(s), pos, SEEK_SET) < 0) return ERRC; s->position = pos; return 0; }
void flush_i8 (GFC_INTEGER_8 *unit) { gfc_unit *us; /* flush all streams */ if (unit == NULL) flush_all_units (); else { us = find_unit (*unit); if (us != NULL) { sflush (us->s); unlock_unit (us); } } }
/* - flush - */ int zflush(i_ctx_t *i_ctx_p) { stream *s; int status; ref rstdout; int code = zget_stdout(i_ctx_p, &s); if (code < 0) return code; make_stream_file(&rstdout, s, "w"); status = sflush(s); if (status == 0 || status == EOFC) { return 0; } return (s_is_writing(s) ? handle_write_status(i_ctx_p, status, &rstdout, NULL, zflush) : handle_read_status(i_ctx_p, status, &rstdout, NULL, zflush)); }
/* Open the printer, writing the stream header. */ static int ljet5_open(gx_device * pdev) { int code = gdev_prn_open(pdev); if (code < 0) return code; code = gdev_prn_open_printer(pdev, true); if (code < 0) return code; { gx_device_printer *const ppdev = (gx_device_printer *)pdev; stream fs; stream *const s = &fs; byte buf[50]; /* arbitrary */ s_init(s, pdev->memory); swrite_file(s, ppdev->file, buf, sizeof(buf)); px_write_file_header(s, pdev); sflush(s); /* don't close */ } return 0; }
int PREFIX(fputc) (const int * unit, char * c, gfc_charlen_type c_len __attribute__((unused))) { ssize_t s; gfc_unit * u = find_unit (*unit); if (u == NULL) return -1; fbuf_reset (u); if (u->mode == READING) { sflush (u->s); u->mode = WRITING; } s = swrite (u->s, c, 1); unlock_unit (u); if (s < 0) return -1; return 0; }
/* Switch a file stream to reading or writing. */ static int s_fileno_switch(stream * s, bool writing) { uint modes = s->file_modes; int fd = sfileno(s); long pos; if (writing) { if (!(s->file_modes & s_mode_write)) return ERRC; pos = stell(s); if_debug2('s', "[s]switch 0x%lx to write at %ld\n", (ulong) s, pos); lseek(fd, pos, SEEK_SET); /* pacify OS */ if (modes & s_mode_append) { sappend_file(s, s->file, s->cbuf, s->cbsize); /* sets position */ } else { swrite_file(s, s->file, s->cbuf, s->cbsize); s->position = pos; } s->modes = modes; } else { if (!(s->file_modes & s_mode_read)) return ERRC; pos = stell(s); if_debug2('s', "[s]switch 0x%lx to read at %ld\n", (ulong) s, pos); if (sflush(s) < 0) return ERRC; lseek(fd, 0L, SEEK_CUR); /* pacify OS */ sread_file(s, s->file, s->cbuf, s->cbsize); s->modes |= modes & s_mode_append; /* don't lose append info */ s->position = pos; } s->file_modes = modes; return 0; }
void st_flush (st_parameter_filepos *fpp) { gfc_unit *u; library_start (&fpp->common); u = find_unit (fpp->common.unit); if (u != NULL) { /* Make sure format buffer is flushed. */ if (u->flags.form == FORM_FORMATTED) fbuf_flush (u, u->mode); sflush (u->s); unlock_unit (u); } else /* FLUSH on unconnected unit is illegal: F95 std., 9.3.5. */ generate_error (&fpp->common, LIBERROR_BAD_OPTION, "Specified UNIT in FLUSH is not connected"); library_end (); }
/* Send the page to the printer. For now, just send the whole image. */ static int ljet5_print_page(gx_device_printer * pdev, FILE * prn_stream) { gs_memory_t *mem = pdev->memory; uint line_size = gdev_mem_bytes_per_scan_line((gx_device *) pdev); uint line_size_words = (line_size + W - 1) / W; uint out_size = line_size + (line_size / 127) + 1; word *line = (word *)gs_alloc_byte_array(mem, line_size_words, W, "ljet5(line)"); byte *out = gs_alloc_bytes(mem, out_size, "ljet5(out)"); int code = 0; int lnum; stream fs; stream *const s = &fs; byte buf[200]; /* arbitrary */ if (line == 0 || out == 0) { code = gs_note_error(gs_error_VMerror); goto done; } s_init(s, mem); swrite_file(s, prn_stream, buf, sizeof(buf)); /* Write the page header. */ { static const byte page_header[] = { pxtBeginPage, DUSP(0, 0), DA(pxaPoint), pxtSetCursor }; static const byte mono_header[] = { DUB(eGray), DA(pxaColorSpace), DUB(e8Bit), DA(pxaPaletteDepth), pxt_ubyte_array, pxt_ubyte, 2, 0xff, 0x00, DA(pxaPaletteData), pxtSetColorSpace }; static const byte gray_header[] = { DUB(eGray), DA(pxaColorSpace), pxtSetColorSpace }; px_write_page_header(s, (gx_device *)pdev); px_write_select_media(s, (gx_device *)pdev, NULL, NULL, 0, false, false); PX_PUT_LIT(s, page_header); if (pdev->color_info.depth == 1) PX_PUT_LIT(s, mono_header); else PX_PUT_LIT(s, gray_header); } /* Write the image header. */ { static const byte mono_image_header[] = { DA(pxaDestinationSize), DUB(eIndexedPixel), DA(pxaColorMapping), DUB(e1Bit), DA(pxaColorDepth), pxtBeginImage }; static const byte gray_image_header[] = { DA(pxaDestinationSize), DUB(eDirectPixel), DA(pxaColorMapping), DUB(e8Bit), DA(pxaColorDepth), pxtBeginImage }; px_put_us(s, pdev->width); px_put_a(s, pxaSourceWidth); px_put_us(s, pdev->height); px_put_a(s, pxaSourceHeight); px_put_usp(s, pdev->width, pdev->height); if (pdev->color_info.depth == 1) PX_PUT_LIT(s, mono_image_header); else PX_PUT_LIT(s, gray_image_header); } /* Write the image data, compressing each line. */ for (lnum = 0; lnum < pdev->height; ++lnum) { int ncompr; static const byte line_header[] = { DA(pxaStartLine), DUS(1), DA(pxaBlockHeight), DUB(eRLECompression), DA(pxaCompressMode), pxtReadImage }; code = gdev_prn_copy_scan_lines(pdev, lnum, (byte *) line, line_size); if (code < 0) goto fin; px_put_us(s, lnum); PX_PUT_LIT(s, line_header); ncompr = gdev_pcl_mode2compress_padded(line, line + line_size_words, out, true); px_put_data_length(s, ncompr); px_put_bytes(s, out, ncompr); } /* Finish up. */ fin: spputc(s, pxtEndImage); spputc(s, pxtEndPage); sflush(s); done: gs_free_object(mem, out, "ljet5(out)"); gs_free_object(mem, line, "ljet5(line)"); return code; }
static void inquire_via_unit (st_parameter_inquire *iqp, gfc_unit * u) { const char *p; GFC_INTEGER_4 cf = iqp->common.flags; if (iqp->common.unit == GFC_INTERNAL_UNIT || iqp->common.unit == GFC_INTERNAL_UNIT4 || u->internal_unit_kind != 0) generate_error (&iqp->common, LIBERROR_INQUIRE_INTERNAL_UNIT, NULL); if ((cf & IOPARM_INQUIRE_HAS_EXIST) != 0) *iqp->exist = (u != NULL) || (iqp->common.unit >= 0); if ((cf & IOPARM_INQUIRE_HAS_OPENED) != 0) *iqp->opened = (u != NULL); if ((cf & IOPARM_INQUIRE_HAS_NUMBER) != 0) *iqp->number = (u != NULL) ? u->unit_number : -1; if ((cf & IOPARM_INQUIRE_HAS_NAMED) != 0) *iqp->named = (u != NULL && u->flags.status != STATUS_SCRATCH); if ((cf & IOPARM_INQUIRE_HAS_NAME) != 0 && u != NULL && u->flags.status != STATUS_SCRATCH) { #if defined(HAVE_TTYNAME_R) || defined(HAVE_TTYNAME) if (u->unit_number == options.stdin_unit || u->unit_number == options.stdout_unit || u->unit_number == options.stderr_unit) { int err = stream_ttyname (u->s, iqp->name, iqp->name_len); if (err == 0) { gfc_charlen_type tmplen = strlen (iqp->name); if (iqp->name_len > tmplen) memset (&iqp->name[tmplen], ' ', iqp->name_len - tmplen); } else /* If ttyname does not work, go with the default. */ cf_strcpy (iqp->name, iqp->name_len, u->filename); } else cf_strcpy (iqp->name, iqp->name_len, u->filename); #elif defined __MINGW32__ if (u->unit_number == options.stdin_unit) fstrcpy (iqp->name, iqp->name_len, "CONIN$", sizeof("CONIN$")); else if (u->unit_number == options.stdout_unit) fstrcpy (iqp->name, iqp->name_len, "CONOUT$", sizeof("CONOUT$")); else if (u->unit_number == options.stderr_unit) fstrcpy (iqp->name, iqp->name_len, "CONERR$", sizeof("CONERR$")); else cf_strcpy (iqp->name, iqp->name_len, u->filename); #else cf_strcpy (iqp->name, iqp->name_len, u->filename); #endif } if ((cf & IOPARM_INQUIRE_HAS_ACCESS) != 0) { if (u == NULL) p = undefined; else switch (u->flags.access) { case ACCESS_SEQUENTIAL: p = "SEQUENTIAL"; break; case ACCESS_DIRECT: p = "DIRECT"; break; case ACCESS_STREAM: p = "STREAM"; break; default: internal_error (&iqp->common, "inquire_via_unit(): Bad access"); } cf_strcpy (iqp->access, iqp->access_len, p); } if ((cf & IOPARM_INQUIRE_HAS_SEQUENTIAL) != 0) { if (u == NULL) p = inquire_sequential (NULL, 0); else switch (u->flags.access) { case ACCESS_DIRECT: case ACCESS_STREAM: p = no; break; case ACCESS_SEQUENTIAL: p = yes; break; default: internal_error (&iqp->common, "inquire_via_unit(): Bad access"); } cf_strcpy (iqp->sequential, iqp->sequential_len, p); } if ((cf & IOPARM_INQUIRE_HAS_DIRECT) != 0) { if (u == NULL) p = inquire_direct (NULL, 0); else switch (u->flags.access) { case ACCESS_SEQUENTIAL: case ACCESS_STREAM: p = no; break; case ACCESS_DIRECT: p = yes; break; default: internal_error (&iqp->common, "inquire_via_unit(): Bad access"); } cf_strcpy (iqp->direct, iqp->direct_len, p); } if ((cf & IOPARM_INQUIRE_HAS_FORM) != 0) { if (u == NULL) p = undefined; else switch (u->flags.form) { case FORM_FORMATTED: p = "FORMATTED"; break; case FORM_UNFORMATTED: p = "UNFORMATTED"; break; default: internal_error (&iqp->common, "inquire_via_unit(): Bad form"); } cf_strcpy (iqp->form, iqp->form_len, p); } if ((cf & IOPARM_INQUIRE_HAS_FORMATTED) != 0) { if (u == NULL) p = inquire_formatted (NULL, 0); else switch (u->flags.form) { case FORM_FORMATTED: p = yes; break; case FORM_UNFORMATTED: p = no; break; default: internal_error (&iqp->common, "inquire_via_unit(): Bad form"); } cf_strcpy (iqp->formatted, iqp->formatted_len, p); } if ((cf & IOPARM_INQUIRE_HAS_UNFORMATTED) != 0) { if (u == NULL) p = inquire_unformatted (NULL, 0); else switch (u->flags.form) { case FORM_FORMATTED: p = no; break; case FORM_UNFORMATTED: p = yes; break; default: internal_error (&iqp->common, "inquire_via_unit(): Bad form"); } cf_strcpy (iqp->unformatted, iqp->unformatted_len, p); } if ((cf & IOPARM_INQUIRE_HAS_RECL_OUT) != 0) *iqp->recl_out = (u != NULL) ? u->recl : 0; if ((cf & IOPARM_INQUIRE_HAS_STRM_POS_OUT) != 0) *iqp->strm_pos_out = (u != NULL) ? u->strm_pos : 0; if ((cf & IOPARM_INQUIRE_HAS_NEXTREC) != 0) { /* This only makes sense in the context of DIRECT access. */ if (u != NULL && u->flags.access == ACCESS_DIRECT) *iqp->nextrec = u->last_record + 1; else *iqp->nextrec = 0; } if ((cf & IOPARM_INQUIRE_HAS_BLANK) != 0) { if (u == NULL || u->flags.form != FORM_FORMATTED) p = undefined; else switch (u->flags.blank) { case BLANK_NULL: p = "NULL"; break; case BLANK_ZERO: p = "ZERO"; break; default: internal_error (&iqp->common, "inquire_via_unit(): Bad blank"); } cf_strcpy (iqp->blank, iqp->blank_len, p); } if ((cf & IOPARM_INQUIRE_HAS_PAD) != 0) { if (u == NULL || u->flags.form != FORM_FORMATTED) p = undefined; else switch (u->flags.pad) { case PAD_YES: p = yes; break; case PAD_NO: p = no; break; default: internal_error (&iqp->common, "inquire_via_unit(): Bad pad"); } cf_strcpy (iqp->pad, iqp->pad_len, p); } if (cf & IOPARM_INQUIRE_HAS_FLAGS2) { GFC_INTEGER_4 cf2 = iqp->flags2; if ((cf2 & IOPARM_INQUIRE_HAS_PENDING) != 0) *iqp->pending = 0; if ((cf2 & IOPARM_INQUIRE_HAS_ID) != 0) *iqp->id = 0; if ((cf2 & IOPARM_INQUIRE_HAS_ENCODING) != 0) { if (u == NULL || u->flags.form != FORM_FORMATTED) p = undefined; else switch (u->flags.encoding) { case ENCODING_DEFAULT: p = "UNKNOWN"; break; case ENCODING_UTF8: p = "UTF-8"; break; default: internal_error (&iqp->common, "inquire_via_unit(): Bad encoding"); } cf_strcpy (iqp->encoding, iqp->encoding_len, p); } if ((cf2 & IOPARM_INQUIRE_HAS_DECIMAL) != 0) { if (u == NULL || u->flags.form != FORM_FORMATTED) p = undefined; else switch (u->flags.decimal) { case DECIMAL_POINT: p = "POINT"; break; case DECIMAL_COMMA: p = "COMMA"; break; default: internal_error (&iqp->common, "inquire_via_unit(): Bad comma"); } cf_strcpy (iqp->decimal, iqp->decimal_len, p); } if ((cf2 & IOPARM_INQUIRE_HAS_ASYNCHRONOUS) != 0) { if (u == NULL) p = undefined; else switch (u->flags.async) { case ASYNC_YES: p = yes; break; case ASYNC_NO: p = no; break; default: internal_error (&iqp->common, "inquire_via_unit(): Bad async"); } cf_strcpy (iqp->asynchronous, iqp->asynchronous_len, p); } if ((cf2 & IOPARM_INQUIRE_HAS_SIGN) != 0) { if (u == NULL) p = undefined; else switch (u->flags.sign) { case SIGN_PROCDEFINED: p = "PROCESSOR_DEFINED"; break; case SIGN_SUPPRESS: p = "SUPPRESS"; break; case SIGN_PLUS: p = "PLUS"; break; default: internal_error (&iqp->common, "inquire_via_unit(): Bad sign"); } cf_strcpy (iqp->sign, iqp->sign_len, p); } if ((cf2 & IOPARM_INQUIRE_HAS_ROUND) != 0) { if (u == NULL) p = undefined; else switch (u->flags.round) { case ROUND_UP: p = "UP"; break; case ROUND_DOWN: p = "DOWN"; break; case ROUND_ZERO: p = "ZERO"; break; case ROUND_NEAREST: p = "NEAREST"; break; case ROUND_COMPATIBLE: p = "COMPATIBLE"; break; case ROUND_PROCDEFINED: p = "PROCESSOR_DEFINED"; break; default: internal_error (&iqp->common, "inquire_via_unit(): Bad round"); } cf_strcpy (iqp->round, iqp->round_len, p); } if ((cf2 & IOPARM_INQUIRE_HAS_SIZE) != 0) { if (u == NULL) *iqp->size = -1; else { sflush (u->s); *iqp->size = ssize (u->s); } } if ((cf2 & IOPARM_INQUIRE_HAS_IQSTREAM) != 0) { if (u == NULL) p = "UNKNOWN"; else switch (u->flags.access) { case ACCESS_SEQUENTIAL: case ACCESS_DIRECT: p = no; break; case ACCESS_STREAM: p = yes; break; default: internal_error (&iqp->common, "inquire_via_unit(): Bad pad"); } cf_strcpy (iqp->iqstream, iqp->iqstream_len, p); } } if ((cf & IOPARM_INQUIRE_HAS_POSITION) != 0) { if (u == NULL || u->flags.access == ACCESS_DIRECT) p = undefined; else { /* If the position is unspecified, check if we can figure out whether it's at the beginning or end. */ if (u->flags.position == POSITION_UNSPECIFIED) { gfc_offset cur = stell (u->s); if (cur == 0) u->flags.position = POSITION_REWIND; else if (cur != -1 && (ssize (u->s) == cur)) u->flags.position = POSITION_APPEND; } switch (u->flags.position) { case POSITION_REWIND: p = "REWIND"; break; case POSITION_APPEND: p = "APPEND"; break; case POSITION_ASIS: p = "ASIS"; break; default: /* If the position has changed and is not rewind or append, it must be set to a processor-dependent value. */ p = "UNSPECIFIED"; break; } } cf_strcpy (iqp->position, iqp->position_len, p); } if ((cf & IOPARM_INQUIRE_HAS_ACTION) != 0) { if (u == NULL) p = undefined; else switch (u->flags.action) { case ACTION_READ: p = "READ"; break; case ACTION_WRITE: p = "WRITE"; break; case ACTION_READWRITE: p = "READWRITE"; break; default: internal_error (&iqp->common, "inquire_via_unit(): Bad action"); } cf_strcpy (iqp->action, iqp->action_len, p); } if ((cf & IOPARM_INQUIRE_HAS_READ) != 0) { p = (!u || u->flags.action == ACTION_WRITE) ? no : yes; cf_strcpy (iqp->read, iqp->read_len, p); } if ((cf & IOPARM_INQUIRE_HAS_WRITE) != 0) { p = (!u || u->flags.action == ACTION_READ) ? no : yes; cf_strcpy (iqp->write, iqp->write_len, p); } if ((cf & IOPARM_INQUIRE_HAS_READWRITE) != 0) { p = (!u || u->flags.action != ACTION_READWRITE) ? no : yes; cf_strcpy (iqp->readwrite, iqp->readwrite_len, p); } if ((cf & IOPARM_INQUIRE_HAS_DELIM) != 0) { if (u == NULL || u->flags.form != FORM_FORMATTED) p = undefined; else switch (u->flags.delim) { case DELIM_NONE: case DELIM_UNSPECIFIED: p = "NONE"; break; case DELIM_QUOTE: p = "QUOTE"; break; case DELIM_APOSTROPHE: p = "APOSTROPHE"; break; default: internal_error (&iqp->common, "inquire_via_unit(): Bad delim"); } cf_strcpy (iqp->delim, iqp->delim_len, p); } if ((cf & IOPARM_INQUIRE_HAS_PAD) != 0) { if (u == NULL || u->flags.form != FORM_FORMATTED) p = undefined; else switch (u->flags.pad) { case PAD_NO: p = no; break; case PAD_YES: p = yes; break; default: internal_error (&iqp->common, "inquire_via_unit(): Bad pad"); } cf_strcpy (iqp->pad, iqp->pad_len, p); } if ((cf & IOPARM_INQUIRE_HAS_CONVERT) != 0) { if (u == NULL) p = undefined; else switch (u->flags.convert) { /* big_endian is 0 for little-endian, 1 for big-endian. */ case GFC_CONVERT_NATIVE: p = big_endian ? "BIG_ENDIAN" : "LITTLE_ENDIAN"; break; case GFC_CONVERT_SWAP: p = big_endian ? "LITTLE_ENDIAN" : "BIG_ENDIAN"; break; default: internal_error (&iqp->common, "inquire_via_unit(): Bad convert"); } cf_strcpy (iqp->convert, iqp->convert_len, p); } }
Network::~Network() { sflush(); }
/* Send the page to the file. */ static int jbig2_print_page(gx_device_printer * pdev, FILE * prn_stream) { gx_device_jbig2 *jdev = (gx_device_jbig2 *) pdev; gs_memory_t *mem = jdev->memory; int line_size = gdev_mem_bytes_per_scan_line((gx_device *) pdev); byte *in = gs_alloc_bytes(mem, line_size, "jbig2_print_page(in)"); byte *fbuf = 0; uint fbuf_size; byte *jbuf = 0; uint jbuf_size; int lnum; int code = 0; stream_jbig2encode_state state; stream fstrm, cstrm; if (in == 0) { code = gs_note_error(gs_error_VMerror); goto fail; } /* Create the jbig2encode state. */ s_init_state((stream_state *)&state, &s_jbig2encode_template, 0); if (state.templat->set_defaults) (*state.templat->set_defaults) ((stream_state *) & state); state.width = jdev->width; state.height = jdev->height; /* Set up the streams. */ fbuf_size = max(512 /* arbitrary */ , state.templat->min_out_size); jbuf_size = state.templat->min_in_size; if ((fbuf = gs_alloc_bytes(mem, fbuf_size, "jbig2_print_page(fbuf)")) == 0 || (jbuf = gs_alloc_bytes(mem, jbuf_size, "jbig2_print_page(jbuf)")) == 0 ) { code = gs_note_error(gs_error_VMerror); goto done; } s_init(&fstrm, mem); swrite_file(&fstrm, prn_stream, fbuf, fbuf_size); s_init(&cstrm, mem); s_std_init(&cstrm, jbuf, jbuf_size, &s_filter_write_procs, s_mode_write); cstrm.state = (stream_state *) & state; cstrm.procs.process = state.templat->process; cstrm.strm = &fstrm; if (state.templat->init) (*state.templat->init) (cstrm.state); /* Copy the data to the output. */ for (lnum = 0; lnum < jdev->height; ++lnum) { byte *data; uint ignore_used; if (cstrm.end_status) { code = gs_note_error(gs_error_ioerror); goto done; } gdev_prn_get_bits(pdev, lnum, in, &data); sputs(&cstrm, data, state.stride, &ignore_used); } /* Wrap up. */ sclose(&cstrm); sflush(&fstrm); done: gs_free_object(mem, jbuf, "jbig2_print_page(jbuf)"); gs_free_object(mem, fbuf, "jbig2_print_page(fbuf)"); gs_free_object(mem, in, "jbig2_print_page(in)"); return code; fail: gs_free_object(mem, in, "jbig2_print_page(in)"); return code; }
/* * Create an Indexed color space. This is a single-use procedure, * broken out only for readability. */ static int pdf_indexed_color_space(gx_device_pdf *pdev, cos_value_t *pvalue, const gs_color_space *pcs, cos_array_t *pca) { const gs_indexed_params *pip = &pcs->params.indexed; const gs_color_space *base_space = pcs->base_space; int num_entries = pip->hival + 1; int num_components = gs_color_space_num_components(base_space); uint table_size = num_entries * num_components; /* Guess at the extra space needed for PS string encoding. */ uint string_size = 2 + table_size * 4; uint string_used; byte buf[100]; /* arbitrary */ stream_AXE_state st; stream s, es; gs_memory_t *mem = pdev->pdf_memory; byte *table; byte *palette; cos_value_t v; int code; /* PDF doesn't support Indexed color spaces with more than 256 entries. */ if (num_entries > 256) return_error(gs_error_rangecheck); if (pdev->CompatibilityLevel < 1.3) { switch (gs_color_space_get_index(pcs)) { case gs_color_space_index_Pattern: case gs_color_space_index_Separation: case gs_color_space_index_Indexed: case gs_color_space_index_DeviceN: return_error(gs_error_rangecheck); default: DO_NOTHING; } } table = gs_alloc_string(mem, string_size, "pdf_color_space(table)"); palette = gs_alloc_string(mem, table_size, "pdf_color_space(palette)"); if (table == 0 || palette == 0) { gs_free_string(mem, palette, table_size, "pdf_color_space(palette)"); gs_free_string(mem, table, string_size, "pdf_color_space(table)"); return_error(gs_error_VMerror); } s_init(&s, mem); swrite_string(&s, table, string_size); s_init(&es, mem); s_init_state((stream_state *)&st, &s_PSSE_template, NULL); s_init_filter(&es, (stream_state *)&st, buf, sizeof(buf), &s); sputc(&s, '('); if (pcs->params.indexed.use_proc) { gs_client_color cmin, cmax; byte *pnext = palette; int i, j; /* Find the legal range for the color components. */ for (j = 0; j < num_components; ++j) cmin.paint.values[j] = (float)min_long, cmax.paint.values[j] = (float)max_long; gs_color_space_restrict_color(&cmin, base_space); gs_color_space_restrict_color(&cmax, base_space); /* * Compute the palette values, with the legal range for each * one mapped to [0 .. 255]. */ for (i = 0; i < num_entries; ++i) { gs_client_color cc; gs_cspace_indexed_lookup(pcs, i, &cc); for (j = 0; j < num_components; ++j) { float v = (cc.paint.values[j] - cmin.paint.values[j]) * 255 / (cmax.paint.values[j] - cmin.paint.values[j]); *pnext++ = (v <= 0 ? 0 : v >= 255 ? 255 : (byte)v); } } } else memcpy(palette, pip->lookup.table.data, table_size); if (gs_color_space_get_index(base_space) == gs_color_space_index_DeviceRGB ) { /* Check for an all-gray palette3. */ int i; for (i = table_size; (i -= 3) >= 0; ) if (palette[i] != palette[i + 1] || palette[i] != palette[i + 2] ) break; if (i < 0) { /* Change the color space to DeviceGray. */ for (i = 0; i < num_entries; ++i) palette[i] = palette[i * 3]; table_size = num_entries; base_space = gs_cspace_new_DeviceGray(mem); } } stream_write(&es, palette, table_size); gs_free_string(mem, palette, table_size, "pdf_color_space(palette)"); sclose(&es); sflush(&s); string_used = (uint)stell(&s); table = gs_resize_string(mem, table, string_size, string_used, "pdf_color_space(table)"); /* * Since the array is always referenced by name as a resource * rather than being written as a value, even for in-line images, * always use the full name for the color space. * * We don't have to worry about the range of the base space: * in PDF, unlike PostScript, the values from the lookup table are * scaled automatically. */ if ((code = pdf_color_space(pdev, pvalue, NULL, base_space, &pdf_color_space_names, false)) < 0 || (code = cos_array_add(pca, cos_c_string_value(&v, pdf_color_space_names.Indexed /*pcsn->Indexed*/))) < 0 || (code = cos_array_add(pca, pvalue)) < 0 || (code = cos_array_add_int(pca, pip->hival)) < 0 || (code = cos_array_add_no_copy(pca, cos_string_value(&v, table, string_used))) < 0 ) return code; return 0; }
void st_backspace (st_parameter_filepos *fpp) { gfc_unit *u; library_start (&fpp->common); u = find_unit (fpp->common.unit); if (u == NULL) { generate_error (&fpp->common, LIBERROR_BAD_UNIT, NULL); goto done; } /* Direct access is prohibited, and so is unformatted stream access. */ if (u->flags.access == ACCESS_DIRECT) { generate_error (&fpp->common, LIBERROR_OPTION_CONFLICT, "Cannot BACKSPACE a file opened for DIRECT access"); goto done; } if (u->flags.access == ACCESS_STREAM && u->flags.form == FORM_UNFORMATTED) { generate_error (&fpp->common, LIBERROR_OPTION_CONFLICT, "Cannot BACKSPACE an unformatted stream file"); goto done; } /* Make sure format buffer is flushed and reset. */ if (u->flags.form == FORM_FORMATTED) { int pos = fbuf_reset (u); if (pos != 0) sseek (u->s, pos, SEEK_CUR); } /* Check for special cases involving the ENDFILE record first. */ if (u->endfile == AFTER_ENDFILE) { u->endfile = AT_ENDFILE; u->flags.position = POSITION_APPEND; sflush (u->s); } else { if (stell (u->s) == 0) { u->flags.position = POSITION_REWIND; goto done; /* Common special case */ } if (u->mode == WRITING) { /* If there are previously written bytes from a write with ADVANCE="no", add a record marker before performing the BACKSPACE. */ if (u->previous_nonadvancing_write) finish_last_advance_record (u); u->previous_nonadvancing_write = 0; unit_truncate (u, stell (u->s), &fpp->common); u->mode = READING; } if (u->flags.form == FORM_FORMATTED) formatted_backspace (fpp, u); else unformatted_backspace (fpp, u); u->flags.position = POSITION_UNSPECIFIED; u->endfile = NO_ENDFILE; u->current_record = 0; u->bytes_left = 0; } done: if (u != NULL) unlock_unit (u); library_end (); }